DEV Community: Satish Yadav

What's new in .NET 8?

Satish Yadav — Thu, 16 Nov 2023 19:33:03 +0000

The release of .NET 8 heralds a new era in software development, marking a significant milestone in the evolution of the .NET ecosystem. This iteration introduces a plethora of groundbreaking technical enhancements designed to amplify the capabilities of developers and the performance of applications across various domains.

Unprecedented Performance Optimizations

The latest iteration of .NET brings forth several performance optimizations that significantly augment application efficiency and responsiveness:

Dynamic Profile-Guided Optimization (PGO): Enabling up to a 20% improvement in application performance through real-world usage-based code optimization.
AVX-512 Support: Empowering parallel operations on 512-bit data vectors, ensuring enhanced data processing capabilities and accelerated computational throughput.
UTF-8 Formattable and Parsable Interface: Direct UTF-8 formatting and parsing capabilities sans transcoding overhead, fortifying application efficiency and responsiveness.

.NET Aspire: Redefining Cloud-Native Development

.NET Aspire represents a curated collection of components tailored explicitly for cloud-native application development. With an emphasis on resilience, observability, and simplified configuration, it provides:

Curated Components: Equipped with enhanced telemetry, resilience, configuration, and health check capabilities by default.
Streamlined Local Developer Experience: Simplified acquisition and configuration of essential dependencies for cloud-native applications, facilitating a seamless development journey.

Augmented Container Capabilities in .NET 8

Containerized application deployment is further fortified in .NET 8, ensuring:

Enhanced Container Security: Incorporation of non-root users within .NET images, bolstering container security measures.
Compact Image Sizes: Faster deployment facilitated by minimized .NET base image sizes, optimizing resource utilization.

Native AoT - Facilitating Compute Efficiency

Compile .NET applications into native code to minimize memory footprint and expedite app initialization:

Compiled Native Code: Immediate app startup without JIT compilation overhead, facilitating operation in restricted environments.

Integrating Artificial Intelligence with .NET

Harness the power of generative AI and large language models, seamlessly integrated into .NET 8:

Generative AI Integration: Simplified AI integration with first-class out-of-the-box AI features within the .NET SDK.
System.Numerics Library Enhancements: Enhanced compatibility with Generative AI workloads, integrating Tensor Primitives.

Advanced Web Application Development with Blazor

Blazor in .NET 8 introduces innovative features for comprehensive web UI development:

Blazor Server and Blazor WebAssembly Integration: Full-stack web UI capabilities merging server and client-side functionalities.
Robust Authentication and Authorization: Full support for Blazor-based Identity UI, elevating security measures.

.NET MAUI - Unifying Cross-Platform Development

.NET MAUI revolutionizes cross-platform app development, unifying project systems across multiple platforms:

Unified Project System: Develop WinUI, Mac Catalyst, iOS, and Android applications from a single codebase.
Quality Improvements: Enhanced performance, controls, UI elements, and platform-specific behaviors.

C# 12 Features - Amplifying Developer Productivity

The introduction of C# 12 brings forth a range of productivity enhancements:

Primary Constructors: Streamlined class initialization, minimizing boilerplate code.
Concise Collection Types: Simplified array and span creation, augmenting code readability.
Lambda Expression Parameter Defaults: Improved handling of optional arguments within lambda expressions.

Broader .NET 8 Support Across Development Tools

Visual Studio 2022 17.8 and Visual Studio Code's C# Dev Kit offer extended support for .NET 8, empowering developers with advanced tooling capabilities across diverse development environments.

Additional new features

ASP.NET Core: Streamlines identity for single-page applications (SPA) and Blazor providing cookie-based authentication, pre-built APIs, token support, and a new identity UI. Enhances minimal APIs with form-binding, antiforgery support to protect against cross-site request forgery (XSRF/CSRF), and asParameters support for parameter-binding with Open API definitions.
ASP.NET Core Tooling: Route syntax highlighting, auto-completion, and analyzers to help you create Web APIs.
Entity Framework Core: Provides new “complex types” as value objects, primitive collections, and SQL Server support for hierarchical data.
NuGet: Helps you audit your NuGet packages in projects and solutions for any known security vulnerabilities.
.NET Runtime: Brings a new AOT compilation mode for WebAssembly (WASM) and Android.
.NET SDK: Revitalizes terminal build output and production-ready defaults.
WPF: Supports OpenFolderDialog and Enabled HW Acceleration in RDP.
ARM64: Significant feature enhancements and improved code quality for ARM64 platforms through collaboration with ARM engineers.
Debugging: Displays debug summaries and provides simplified debug proxies for commonly used .NET types.
System.Text.Json: Helps populate read-only members, customizes unmapped member handling, and improves Native AOT support.
.NET Community Toolkit: Accelerates building .NET libraries and applications while ensuring they are trim and AOT compatible (including the MVVM source generators!)
Azure: Supports .NET 8 with Azure’s PaaS services like App Service for Windows and Linux, Static Web Apps, Azure Functions, and Azure Container Apps.
F# 8: Includes significant language changes, new diagnostics, improvements in usability, and performance enhancements in project compilation, as well as upgrades to the FSharp.Core standard library.

Conclusion

.NET 8 stands as a testament to continuous innovation, fostering a robust ecosystem for developers to craft high-performance, resilient, and scalable applications across diverse domains. It represents a leap forward in the realm of software development, revolutionizing the way applications are built and optimized.

Embrace the future of development with .NET 8, explore its technical depths, and join my journey at my blog here at https://blog.satishyadav.com

Getting started

5 things I wish I knew before writing 1 Million lines of code

Satish Yadav — Mon, 26 Jun 2023 12:25:36 +0000

Developers spend much more time reading the code than writing it. So, after optimizing code for time and space complexity — optimize it for reading complexity. There’s even a term for that — Cyclomatic Complexity.

After having written more than 1 million lines of code and having read much more awful lot, here are the top 5 things I wish I knew sooner to write more readable code.

1. Your code will be read more times than you think.

A common misconception among upcoming and new developers is — Software Development is about writing the O(n) complexity code of binary tree inversion. And I hate to break it to you — it’s not.

A lot of time it’s about, adding a new feature or fixing a bug in an existing code base with its own coding conventions, naming conventions, design, and architecture. So reading and understanding the existing code becomes one of the most important parts of the job.

Great developers spend a lot of time reading other people’s code.

2. Readable code > Smart Code

In almost all programming languages and frameworks, there are numerous ways of doing the same thing. The smarter and one-liner way may feel good to write at the moment, but often it’s not good for the next reader — which can be YOU six months down the line.

So,

If there is a little more verbose but more readable way to do it — do it and your future self will thank you later.

3. Document the “why” instead of “what”.

Usually, I’m against documentation. Because

The code is literally the instructions written to build something.

The only parts that need documentation are the “why”. Why we’ve written this piece of code this way?

If you don't understand the "what"? Maybe you shouldn't be the one changing it.

4. Describe everything your function/method does in the name.

There are only 2 difficult things in Computer Science — Cache Invalidation and Naming

Just by reading the name of the function, its intent should be clear.

“But then large functions would have way big names” — that’s the point. Your function should do only 1 or a few things and do it properly.

Refactor the function/method if it’s job can’t be described in the name.

5. “Deadline” is a silly excuse for writing bad code.

“There’s no time to write good code” is not a good enough excuse for writing bad code.

Checking for the readability of your code is like flushing the toilet — it’s part of the ceremony. You do it no matter how late you are for anything else.

So next time you write code, think about your future self, what would you answer to that person? Don’t bring the shame to yourself. Write readable code.

Happy Coding!

Managing Technical Debt with NDepend!

Satish Yadav — Sat, 03 Sep 2022 09:21:42 +0000

What the hell is a Technical Debt?

You are working on a cool new project, want to implement the amazing new design pattern that you learned about few days ago. All is well. Until, your boss comes to your desk and tells you the release is pre-poned (is that even a word?) by 10 days. WTH man! Now whatever plans you had to make the code readable, testable, SOLID - goes for a toss, and you stuff the code to make up for the early release.

So you bought some time by writing "not so good code" to meet the deadline.

Let this sink in for a moment.

You know that the code that you had written needs to be refactored, but you don't have the bandwidth (not the internet one) to do so, so you live with this "bad code" - aka technical debt.

Well, debts inherently aren't bad, you take debts all the time - Credit Cards, Car Loan, House Loan. But you need to pay the interest, and as long you re-pay, it's well and good. Same goes for the technical debt. It's a trade-off between Product Delivery and impeccable code.

How do I know that I have a Technical Debt

Some times ago, I did not have any single tool which can give a clear idea what kind of and how much technical debt I have.

I was looking at different metrics e.g., Code Duplication, Cyclomatic Complexity, Test Coverage, Dependency and Coupling, and more to get an idea.

Then I stumbled upon NDepend.

NDepende can scan your code-base and tell you how much technical debt you have in a single actionable dashboard?

What is NDepend

NDepend can do much more than that, e.g.,

Code Rule and Code Query over LINQ (CQLinq)
Powerful Dependency Graph and Matrix
Smart Technical Debt Estimation
Quality Gates
In-Depth Issues Management
Trend Monitoring
Harness Test Coverage Data
Code Quality and Code Metrics
Detect Dependency Cycles
Code Diff since Baseline
Enforce Immutability and Purity
Complexity and Diagrams
Continuous Integration Reporting
Warnings on Build
Process Health

and more.

They consider themselves, The "Swiss Army Knife" for .NET Developers, Architects and Teams

Visit their official site to know more.

NDepende team was generous to give me a copy of their license to try out the product

If you're new to NDepend or want to know how to install and get started, folks at NDepend have written a wonderful step-by-step documentation.

Thing I like about NDepend is, it gives me a visual dashboard which is actionable. And all the data it provides, it has LINQ queries to support that and accommodate custom rules as well.

How to find out Technical Debt

For this post, I've taken the Clean Architecture repo from Jason Taylor. If you don't know Jason, he's the Clean Architecture guy, a great developer, trainer, architect, and more.

Once you clone the repo in Visual Studio, here's how the Project structure looks like:

An Angular SPA with Application Layer, Domain Layer, Infrastructure Layer - basically the Clean Architecture.

Attached the NDepend to this solution:

NDepend will detect the projects and exclude test projects. Click on Analyze X NET Assemblies.

Give it some time to finish.

Click on the View NDepend Dashboard.

Dashboard

The dashboard gives you plethora of information about the Project code quality, lines of code, issues, comments, but we're interested in technical debt.

In this case, you can see there is a 5.56% of technical debt. Well done, Jason!

The Smart Technical Debt feature of NDepend also tell us how many days it would take us to resolve the technical debt.

Amazing, right?

Additionally, it gives us the Rating of the project based on Technical Debt. In our case B. Pretty good. And how much effort is required to reach to A.

Exploring Technical Debt

If you click on the rating, NDepend will show you the hot-spots of the code where most of the debt is.

Clicking on the Debt % gives list of all the issue

Click on a specific rule to find out the details and what all code has contributed to this technical debt.

In the above example, our code base has violated following rule:

• Rule Name: Avoid namespaces dependency cycles
• Rule Id: ND1401
• Rule Explicit Id: AvoidNamespacesDependencyCycles

• Rule Description:

This rule lists all application namespace dependency cycles. Each row shows a different cycle, indexed with one of the namespace entangled in the cycle.

Read our white books relative to partitioning code, to know more about namespaces dependency cycles, and why avoiding them is a simple yet efficient solution to clean the architecture of a code base. https://www.ndepend.com/docs/white-books

• How to Fix Issues of this Rule:

Removing first pairs of mutually dependent namespaces will eliminate most namespaces dependency cycles. This is why it is recommended to focus first on matches of the default rule Avoid namespaces mutually dependent before attempting to fix issues of the present rule.

Once all mutually dependent namespaces occurrences are solved, remaining cycles matched by the present rule necessarily involve 3 or more namespaces like in: A is using B is using C is using A.

To browse a cycle on the dependency graph or the dependency matrix, right click a cycle cell in the result of the present rule and export the matched namespaces to the dependency graph or matrix. This is illustrated here: https://www.ndepend.com/docs/visual-studio-dependency-graph#Entangled

With such a cycle graph visualized, you can determine which dependencies should be discarded to break the cycle. To do so, you need to identify which namespace should be at low-level and which one should be at high-level.

In the A is using B is using C is using A cycle example, if A should be at low level then C should be at a higher-level than A. As a consequence C shouldn't use A and this dependency should be removed. To remove a dependency you can refer to patterns described in the HowToFix section of the rule Avoid namespaces mutually dependent.

Notice that the dependency matrix can also help visualizing and breaking cycles. In the matrix cycles are represented with red squares and black cells. To easily browse dependency cycles, the dependency matrix comes with an option: Display Direct and Indirect Dependencies. See related documentation here: https://www.ndepend.com/docs/dependency-structure-matrix-dsm#Cycle https://www.ndepend.com/docs/dependency-structure-matrix-dsm#Mutual

The estimated Debt, which means the effort to fix such issue, doesn't depend on the cycle length. First because fixing the rule Avoid namespaces mutually dependent will fix most cycle reported here, second because even a long cycle can be broken by removing a single or a few dependencies.

• How to Suppress an Issue of this Rule:

In source code, tag the concerned code element with this attribute:
[SuppressMessage("NDepend", "ND1401:AvoidNamespacesDependencyCycles", Justification="...")]
This attribute requires the compilation symbol CODE_ANALYSIS to be set on each Visual Studio project relying on it. Without CODE_ANALYSIS symbol defined, the attribute is not compiled and the issues are not suppressed.

Pretty detailed, right?

Next steps

Now you have a basic understanding of what Technical Debt is and how NDepend can take you into your journey of becoming Technical-Debt-free (if that's a thing).

Visit the NDepend site to learn more.

Here's the repo used in this post, give this a star:

https://github.com/iSatishYadav/CleanArchitectureCodeBase

Originally posted at:

https://blog.satishyadav.com/managing-technical-debt-with-ndepend

Happy Coding!

Automate Windows Software and Apps' installation!

Satish Yadav — Sun, 28 Aug 2022 13:13:11 +0000

Why?

If you've installed Windows enough times, you already know the pain of installing all your Software and Apps again and again. If you haven't, let me save you the pain and show you how to:

Automate the installation of Windows Software and Apps

Package Manager FTW!

What we need here is something called Package Manager, which we can give some commands and it would install the software from the command line itself.

Why command line — so that we can repeat the process.

~~Windows doesn't have an official Package Manager yet~~, but Chocolatey is your safest bet.

Windows has gotten winget but it's relatively new and community support/references are much better for Chocolatey.

So here's what we're going to do, we need to search and list down all the software that we typically install and save that command at a place where we can refer it later. It can be on any of Drives (Google Drive, OneDrive) or if you're a developer or power user (whatever that is) - on a Git repo. I don't care, as long as you have the access to it when the time comes.

So let's get to it.

1. Install Chocolatey itself

From an Admin terminal (PowerShell or Windows Terminal)

Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
```
{% endraw %}


## 2. Install packages
If you know alrady familiar with the package names of individual Software or the App, you can skip this otherwise you can search 

### 2.1 Search
Let's say I don't know what is the name of the Node.js package. I can serach:

#### 2.1.1 Search from CLI
{% raw %}


````shell
choco search nodejs
```
{% endraw %}

It should return results something like that:
{% raw %}


````shell
nodejs 16.11.0 [Approved]
nodejs.commandline 6.11.0 [Approved]
nodejs.install 16.11.0 [Approved]
nodejs-lts 14.18.0 [Approved]
...
30 packages found.

```
{% endraw %}


> Homework: What does {% raw %}`[Approved]`{% endraw %} mean?

#### 2.1.1 Seach from Chocolatey site:

Visit https://community.chocolatey.org/packages to find all the supported packages. You can find all sorts of amazing Software and Apps including day-to-day Sofrware like Chrome, Zoom, iTunes - to Enterprise Developer Tools like Visual Studio, Python, Azure and AWS CLIs - and whatnot.

### 2.2 Install 

This is how you install a pacakge. From an Admin terminal:

* Node.js
{% raw %}

````shell
choco install nodejs-lts
```
{% endraw %}


* VS Code
{% raw %}

````shell
choco install vscode
```
{% endraw %}


Now you can save all this in a file and install, but wait "where is the automation you promised? I need my money back." Don't worry, people way smarter than me have thought about this and came up with:

## Packages.config
There's an official way to list all the packages and install from that file.

Here's what a typical package looks like:
{% raw %}


````xml
<?xml version="1.0" encoding="utf-8"?>
<packages>
    <package id="vscode" />
    <package id="nodejs-lts" version="14.18.0" />
</packages>
```



Save this file and in future you can install all the Software and Apps. e.g.



````shell
choco install "sample-packages.config"
```



Since I already have these pacakges installed, I got following message, but you can figure it out from here.



````shell
Installing from config file:
sample-packages.config
By installing, you accept licenses for the packages.
Installing the following packages:
vscode
nodejs-lts
vscode v1.61.0 already installed.
 Use --force to reinstall, specify a version to install, or try upgrade.
nodejs-lts v14.18.0 already installed.
 Use --force to reinstall, specify a version to install, or try upgrade.

Chocolatey installed 0/2 packages.
 See the log for details (C:\ProgramData\chocolatey\logs\chocolatey.log).
```


## Conclusion

That's it! This is how you can automate the installation of your favorite Software and Apps in a repeatable way.

If you liked this, please like and share this post. And visit https://github.com/iSatishYadav/AutomateWindowsSoftwareInstallation and give this repo a star.

Originally posted at:

[https://blog.satishyadav.com/automate-new-windows-machine-installation](https://blog.satishyadav.com/automate-new-windows-machine-installation/?utm_source=devto_&utm_medium=blog)

Happy Hacking!

An “I don’t know what Docker is and at this point I’m too afraid to ask” guide to Docker.

Satish Yadav — Sat, 12 Mar 2022 03:41:27 +0000

What is Docker?

Docker is an open source platform for building, deploying, and managing containerized applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly.

It is based on the idea that you can package your code with dependencies into a deployable unit called a "container" that has everything the software needs to run including libraries, system tools, code, and runtime.

Wait, but what's a "Container"?

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another.

Containers are made possible by process isolation and virtualization capabilities built into the Linux kernel. As a result, container technology offers all the functionality and benefits of VMs - including application isolation, cost-effective scalability, and disposability - plus important additional advantages:

Lighter weight
Greater resource efficiency
Improved developer productivity

That's too much of jargons, can you give me a simple analogy?

Perhaps a simple analogy can help getting the grasp of the core concept of Docker...

Let's go back in time to the 1950s for a moment. There were no word processors, and the photocopiers were used everywhere (kind of).

Imagine you're responsible for quickly issuing batches of letters as required, to mail them to customers, using real paper and envelopes, to be delivered physically to each customer's address (there was no email back then).

At some point, you realize the letters are just a composition of a large set of paragraphs, which are picked and arranged as needed, according to the purpose of the letter, so you devise a system to issue letters quickly, expecting to get a hefty raise.

The system is simple:

You begin with a deck of transparent sheets containing one paragraph each.

To issue a set of letters, you pick the sheets with the paragraphs you need, then you stack and align them so they look and read fine.

Finally, you place the set in the photocopier and press start to produce as many letters as required.

So, simplifying, that's the core idea of Docker.

In Docker, each layer is the resulting set of changes that happen to the filesystem after executing a command, such as, installing a program.

So, when you "look" at the filesystem after the layer has been copied, you see all the files, included the layer when the program was installed.

You can think of an image as an auxiliary read-only hard disk ready to be installed in a "computer" where the operating system is already installed.

Similarly, you can think of a container as the "computer" with the image hard disk installed. The container, just like a computer, can be powered on or off.

Why use Docker

Using Docker lets you ship software faster, standardize application operations, seamlessly move code, and save money by improving resource utilization.

With Docker, you get a single object that can reliably run anywhere. Docker's simple and straightforward syntax gives you full control. Wide adoption means there's a robust ecosystem of tools and off-the-shelf applications that are ready to use with Docker.

Docker is so popular today that Docker and containers are used interchangeably.

But we already have Virtual Machines? Why Containers?

Containers	Virtual Machines
Containers are an abstraction at the Application layer that packages code and dependencies together.	Virtual machines (VMs) are an abstraction of physical hardware turning one server into many servers.
Multiple containers can run on the same machine and share the OS kernel with other containers, each running as isolated processes in user space.	The hypervisor allows multiple VMs to run on a single machine.
Containers take up less space than VMs (container images are typically tens of MBs in size), can handle more applications and require fewer VMs and Operating systems.	Each VM includes a full copy of an operating system, the application, necessary binaries and libraries - taking up tens of GBs.
Containers boot up quickly	VMs can be slow to boot.

Docker tools and terms

Let us familiarize ourselves with Docker terminology.

DockerFile

Every Docker container starts with a simple text file containing instructions for how to build the Docker container image. DockerFile automates the process of Docker image creation. It’s essentially a list of command-line interface (CLI) instructions that Docker Engine will run in order to assemble the image.

Docker images

Docker images contain executable application source code as well as all the tools, libraries, and dependencies that the application code needs to run as a container. When you run the Docker image, it becomes one instance (or multiple instances) of the container.

Docker containers

Docker containers are the live, running instances of Docker images. While Docker images are read-only files, containers are live, ephemeral, executable content. Users can interact with them, and administrators can adjust their settings and conditions using docker commands.

Docker Hub

Docker Hub is the public repository of Docker images.

Docker daemon

Docker daemon is a service running on your operating system, such as Microsoft Windows or Apple MacOS or iOS. This service creates and manages your Docker images for you using the commands from the client, acting as the control center of your Docker implementation.

Docker registry

A Docker registry is a scalable open-source storage and distribution system for docker images. The registry enables you to track image versions in repositories, using tagging for identification. This is accomplished using Git, a version control tool.

When to use Docker

You can use Docker containers as a core building block creating modern applications and platforms. Docker makes it easy to build and run distributed microservices architecures, deploy your code with standardized continuous integration and delivery pipelines, build highly-scalable data processing systems, and create fully-managed platforms for your developers.

Micro-Services

Build and scale distributed application architectures by taking advantage of standardized code deployments using Docker containers.

Continuous Integration & Delivery

Accelerate application delivery by standardizing environments and removing conflicts between language stacks and versions.

Docker deployment and orchestration

If you're running only a few containers, it's fairly simple to manage your application within Docker Engine, the industry de facto runtime. But if your deployment comprises thousands of containers and hundreds of services, it's nearly impossible to manage that workflow without the help of these purpose-built tools.

Docker Compose

If you're building an application out of processes in multiple containers that all reside on the same host, you can use Docker Compose to manage the application's architecture. Docker Compose creates a YAML file that specifies which services are included in the application and can deploy and run containers with a single command. Using Docker Compose, you can also define persistent volumes for storage, specify base nodes, and document and configure service dependencies.

Kubernetes

To monitor and manage container lifecycles in more complex environments, you'll need to turn to a container orchestration tool. While Docker includes its own orchestration tool (called Docker Swarm), most developers choose Kubernetes instead.

Kubernetes is an open-source container orchestration platform descended from a project developed for internal use at Google.

Kubernetes schedules and automates tasks integral to the management of container-based architectures, including container deployment, updates, service discovery, storage provisioning, load balancing, health monitoring, and more.

Next steps and Credits

Visit official Docker website to learn more. All major clouds e.g. Azure, AWS, Google Cloud have Containers offerings, visit their sites for more info.
Credits:
https://aws.amazon.com/docker/
https://www.ibm.com/cloud/learn/docker
https://www.docker.com/
https://docs.microsoft.com/en-us/dotnet/architecture/microservices/container-docker-introduction/docker-defined

🆕 SQL Server 2022 First Look - Top 5 New Features (Bonus 5 Features)

Satish Yadav — Fri, 05 Nov 2021 06:57:20 +0000

Microsoft announced the first private preview of SQL Server 2022 claiming "the most Azure-enabled release of SQL Server yet, with continued innovation in performance, security, and availability".

In this post we're going to have a look on top 5 most interesting features.

5. Ledger (Blockchain) Support

SQL Server 2022 introduces new Ledger capabilities for creating Blockchain like immutable records to ensure data integrity. If somebody modifies the record, it would no longer be valid.

It would be beneficial for scenarios such as internal and external audits.

4. Peer-to-peer replica conflict resolution

In a multi-write scenario - With SQL Server 2022, last-write rule is being automated. Now, when a conflict is detected, the most recent modification time will be chosen to be persisted on all replicas. This helps keep your multi-write scenarios running smoothly.

Previously this peer-to-peer replica conflict would stall the whole operation until it was addressed.

3. Intelligent Query Processing

Next generation of Intelligent Query Processing (IQP) includes solutions to some of the most common problems we face today, without any code changes required including:

MAXDOP and CE model feedback using the Query store to create a feedback cycle to automatically adapt and resolve problems with common query patterns.

2. Parameter Sensitive Query Plan Caching

SQL Server has a great Query Optimizer, but one of the issue faced by a lot of people is Parameter Sniffing. SQL Server caches the execution plan for a Stored Procedure based on certain parameters (sniffing the parameters). This is usually good but it might not necessarily be efficient with another set of parameters.

SQL Server 2022 introduces Parameter Sensitive Plan Optimization which can cache multiple plans based on parameters - without requiring any code change.

Before revealing my top pick, let's see some honorable Mentions:

Query Store is now turned on by default.
Read Replica Support for Query Store - you can now use Query Store for your Read-Only workloads of your AG (Available Group).
New extensions to the T-SQL language to support data virtualization and backup/restore with S3 compatible storage systems. Furthermore, T-SQL will support new JSON functions and time-series capabilities.
Azure Synapse Link - Previously, moving data from on-premises databases, like SQL Server, to Synapse required you to use ETL. Azure Synapse Link for SQL Server 2022 provides automatic change feeds that capture the changes within SQL Server and feed those into Azure Synapse Analytics. It provides near real-time analysis and hybrid transactional and analytical processing with minimal impact on operational systems.
Azure Purview Integration - Azure Purview as a unified data governance and management service. SQL Server 2022 is integrated with Azure Purview for greater data discovery, allowing you to break down data silos. Through this integration you will be able to:
- Automatically scan your on-premises SQL Server for free to capture metadata.
- Classify data using built-in and custom classifiers and Microsoft Information Protection sensitivity labels.
- Set up and control specific access rights to SQL Server.

Now for the last feature:

1. Fully Managed Disaster Recovery in the Cloud

Using SQL Server 2022 and the new link feature for Azure SQL Managed Instance, you now get all the benefits of running a PaaS environment applied to disaster recovery—allowing you to spend less time on setup and management even when compared to an IaaS environment. This works by using a built-in Distributed Availability Group (DAG) to replicate data to a previously deployed Azure SQL Managed Instance as a DR replica site. The instance is ready and waiting for whenever you need it—no lengthy configuration or maintenance is required. You can also use this link feature in read scale-out scenarios to offload heavy requests that might otherwise affect database performance.

Did I miss any other cool feature? Let me know.

Happy Coding! 👨‍💻

How to Install Windows 11 on unsupported Devices - Officially - No Crack - No 3rd Party Tool

Satish Yadav — Sun, 10 Oct 2021 07:40:47 +0000

So you wanted the new Windows 11 everyone's talking about, but got a dreadful message liked that:

This PC doesn't currently meet Windows 11 system requirements:

Unfortunately, you're not one of the lucky ones. Don't worry, we'll figure out a way together.

Check the Microsof's Official System Requirements for Windows 11.

Now let's see how can you still install Windows 11. The answer is, of course - it depends. On what you don't have.

I've categorized into 3 reason:

You don't have TPM 2.0 (but do have 1.2 or other).
You don't have any TPM. But do have Secure Boot.
You don't even have Secure Boot.

What is TPM (Trusted Platform Module)

How to find out which one do you have? Here's how, type following command on your Command Prompt or Run

tpm.msc

If you don't have any TPM, following screen should pop up.

Otherwise, details of your TPM would show up.

Now, back to our solutions.

Solutions based on what you're missing

1. You don't have `TPM` 2.0 (but do have `TPM` 1.2 or other)

Things are easier when you have some sort of TPM e.g. 1.2 (but not 2.0). You just need to tell Windows - not to check for TPM 2.0. Wait, what? Yes!

The usual disclaimer from Microsoft:

Serious problems might occur if you modify the registry incorrectly by using Registry Editor or by using another method. These problems might require that you reinstall the operating system. Microsoft cannot guarantee that these problems can be solved. Modify the registry at your own risk.

1. Add the following registry setting in your existing Windows 10 Registry Editor:

Registry Key: HKEY_LOCAL_MACHINE\SYSTEM\Setup\MoSetup

Name: AllowUpgradesWithUnsupportedTPMOrCPU

Type: REG_DWORD

Value: 1

Should look like this:

1.2. Go to Windows 11 Create Windows 11 installation media page and follow the Official Instructions to create Bootable Media.
1.3. Boot from this new media and you're good to go.

2. If you don't have a any `TPM`

Follow the step #1.1 and step #1.2. But before booting from the new media, make note of follwing.

You need to change one more registry setting, not on your current Windows Installation, but after you boot from your new media. I'd recommend to open this blog post in another device for reference, or note it down.

Since you don't have any sort of TPM, add follwoing registry after booting from new media and BEFORE proceeding to "Install Now".

2.1. Press Shift+F10 to open a Command Prompt. Open registry editor by typing regedit.
2.2. Add new registry key named LabConfig.

2.3 Add new DWORD named BypassTPMCheck and change the value to 1.

2.4 Continue with the setup.

3. If you don't have Secure Boot

3.1. Follow till step# 2.3 and add a DWORD named BypassSecureBootCheck and change the value to 1.

3.2. Continue with the setup.

And that's it! That wasn't so bad, right?

Disclaimer

Even though I've personally tested the instruction on my personal Windows 10 machine (without any TPM, but with Secure Boot). I am by no means responsible for any damage resulted by following instructions.

Originally posted at https://blog.satishyadav.com/How-to-Install-Windows-11-on-unsupported-Devices-Officially-No-Crack-No-3rd-Party-Tool/

If you liked this post, show some love to the GitHub repo by giving a star.
https://github.com/iSatishYadav/Windows11WithoutTPM

Defense In-Depth: Designing an HTTP Content Length Restriction Middleware - ASP.NET 5 (or .NET Core)

Satish Yadav — Sun, 22 Aug 2021 14:58:37 +0000

The What?

We want to design a Middleware that - when plugged into an ASP.NET 5 (or .NET Core) application pipeline - restricts the input payload size, so attacks which rely of sending a bigger sized (or larger than our specified size) payload can be rejected by Application itself.

The Why?

You'd argue that I have a firewall and other Security and Network devices so why do I need to implement this at Application level?

Well, if you follow Defence-in-Depth, US-CERT (United States Computer Emergency Readiness Team) has this to say about redundant security mechanisms:

Layering security defenses in an application can reduce the chance of a successful attack. Incorporating redundant security mechanisms requires an attacker to circumvent each mechanism to gain access to a digital asset. For example, a software system with authentication checks may prevent an attacker that has subverted a firewall. Defending an application with multiple layers can prevent a single point of failure that compromises the security of the application.

The How? - Let's code

So I broken down this designing to 3 parts:

Create the basic logic
Make it a re-useable Middleware
Make it look like a Native Middleware

So let's get into it:

1. Create the basic logic

We want to check the ContentLength of Request payload against our limit, if it exceeds, it should send the HTTP 413 Entity Too Large as per IETF RFC 7231 specification of HTTP.

if (httpContext.Request.ContentLength > SOME_LIMIT)
{    
    httpContext.Response.StatusCode = StatusCodes.Status413RequestEntityTooLarge;
    await httpContext.Response.WriteAsJsonAsync(new
    {
        Title = "Request too large",
        Status = StatusCodes.Status413RequestEntityTooLarge,
        Type = "https://tools.ietf.org/html/rfc7231#section-6.5.11",
    });
    await httpContext.Response.CompleteAsync();
}
else
{
    await _requestDelegate.Invoke(httpContext);
}
```
{% endraw %}

Let's break it down:

* First we're checking the content length.
* If it's greater than our limit, we're writing a {% raw %}`JSON`{% endraw %} response with {% raw %}`HTTP 413`{% endraw %}. And completing the response as we don't need to execute any further Middleware.
* If not, we can continue the Middleware pipe and execute next Middleware.

### 2. Create a re-usable middleware
Now we have our basic logic ready, let's create a re-usable middleware out of it.
We need to do following:
1. Create a Middleware class and run our logic in {% raw %}`Invoke`{% endraw %} or {% raw %}`InvokeAsync`{% endraw %} method.
2. Take input at the runtime instead of hard-coding it.
3. Add logging

Let's complete this one by one:

#### 2.1.  Create a Middleware class and run our logic in {% raw %}`Invoke`{% endraw %} or {% raw %}`InvokeAsync`{% endraw %} method.
Here's a basic structure of a Middleware class looks like. It should have an {% raw %}`Invoke`{% endraw %} or {% raw %}`InvokeAsync`{% endraw %} method which would be called by runtime based on our configuration.
{% raw %}


````csharp
public class ContentLengthRestrictionMiddleware
{
    private readonly RequestDelegate _requestDelegate;

    public ContentLengthRestrictionMiddleware(RequestDelegate nextRequestDelegate)
    {
        _requestDelegate = nextRequestDelegate;        
    }
    public async Task InvokeAsync(HttpContext httpContext)
    {
        if (httpContext.Request.ContentLength > SOME_LIMIT)
        {
            httpContext.Response.StatusCode = StatusCodes.Status413RequestEntityTooLarge;
            await httpContext.Response.WriteAsJsonAsync(new
            {
                Title = "Request too large",
                Status = StatusCodes.Status413RequestEntityTooLarge,
                Type = "https://tools.ietf.org/html/rfc7231#section-6.5.11",
            });
            await httpContext.Response.CompleteAsync();
        }
        else
        {
            await _requestDelegate.Invoke(httpContext);
        }
    }
}                  
```
{% endraw %}

#### 2.2. Take input at the runtime instead of hard-coding it.
Currently we're hard-coding the limit ({% raw %}`SOME_LIMIT`{% endraw %}), we can create a class and take input at runtime.
{% raw %}

````csharp
public class ContentLengthRestrictionOptions
{
    public long ContentLengthLimit { get; set; }
}
```
{% endraw %}

And modify our Middleware to use this:
{% raw %}


````csharp
public class ContentLengthRestrictionMiddleware
{
    private readonly ContentLengthRestrictionOptions _contentLengthRestrictionOptions;
    private readonly RequestDelegate _requestDelegate;

    public ContentLengthRestrictionMiddleware(RequestDelegate nextRequestDelegate, ContentLengthRestrictionOptions contentLengthRestrictionOptions)
    {
        _requestDelegate = nextRequestDelegate;
        _contentLengthRestrictionOptions = contentLengthRestrictionOptions;        
    }
    public async Task InvokeAsync(HttpContext httpContext)
    {
        if (_contentLengthRestrictionOptions != null && _contentLengthRestrictionOptions.ContentLengthLimit > 0 && httpContext.Request.ContentLength > _contentLengthRestrictionOptions.ContentLengthLimit)
        {
       httpContext.Response.StatusCode = StatusCodes.Status413RequestEntityTooLarge;
            await httpContext.Response.WriteAsJsonAsync(new
            {
                Title = "Request too large",
                Status = StatusCodes.Status413RequestEntityTooLarge,
                Type = "https://tools.ietf.org/html/rfc7231#section-6.5.11",
            });
            await httpContext.Response.CompleteAsync();
        }
        else
        {
            await _requestDelegate.Invoke(httpContext);
        }
    }
}
```
{% endraw %}


#### 2.3. Add logging

Here's little tricky part, you can't just inject an {% raw %}`ILogger<T>`{% endraw %} and expect runtime to give you that dependency, you can get an {% raw %}`ILoggerFactory`{% endraw %} and then you can create your own {% raw %}`ILogger<T>`{% endraw %}.
{% raw %}


````csharp
public class ContentLengthRestrictionMiddleware
{
    private readonly ContentLengthRestrictionOptions _contentLengthRestrictionOptions;
    private readonly ILogger<ContentLengthRestrictionMiddleware> _logger;
    private readonly RequestDelegate _requestDelegate;

    public ContentLengthRestrictionMiddleware(RequestDelegate nextRequestDelegate, ContentLengthRestrictionOptions contentLengthRestrictionOptions, ILoggerFactory loggerFactory)
    {
        _requestDelegate = nextRequestDelegate;
        _contentLengthRestrictionOptions = contentLengthRestrictionOptions;
        _logger = loggerFactory.CreateLogger<ContentLengthRestrictionMiddleware>();
    }
    public async Task InvokeAsync(HttpContext httpContext)
    {
        if (_contentLengthRestrictionOptions != null && _contentLengthRestrictionOptions.ContentLengthLimit > 0 && httpContext.Request.ContentLength > _contentLengthRestrictionOptions.ContentLengthLimit)
        {
            _logger.LogWarning("Rejecting request with Content-Length {0} more than allowed {1}.", httpContext.Request.ContentLength, _contentLengthRestrictionOptions.ContentLengthLimit);
            httpContext.Response.StatusCode = StatusCodes.Status413RequestEntityTooLarge;
            await httpContext.Response.WriteAsJsonAsync(new
            {
                Title = "Request too large",
                Status = StatusCodes.Status413RequestEntityTooLarge,
                Type = "https://tools.ietf.org/html/rfc7231#section-6.5.11",
            });
            await httpContext.Response.CompleteAsync();
        }
        else
        {
            await _requestDelegate.Invoke(httpContext);
        }
    }
}
```
{% endraw %}

I've added a log only when the Middleware rejects the requests.

### 3. Make it look like a native Middleware.
We can create an Extension method on {% raw %}`IApplicationBuilder`{% endraw %}, something to call like {% raw %}`UseXXX`{% endraw %}, so it feels like a Native Middleware.
{% raw %}


````csharp
public static class MiddlewareExtensions
{
    public static IApplicationBuilder UseContentLengthRestriction(this IApplicationBuilder builder, ContentLengthRestrictionOptions contentLengthRestrictionOptions)
        => builder.UseMiddleware<ContentLengthRestrictionMiddleware>(contentLengthRestrictionOptions);
}
```
{% endraw %}

And we can use it like:
{% raw %}


````csharp
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    //This is our Middleware 😍
    app.UseContentLengthRestriction(new ContentLengthRestrictionOptions
    {
        ContentLengthLimit = 10
    });

    /// Other configuration
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseHttpsRedirection();

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}
```
{% endraw %}


## 4. The Execution
Sending a {% raw %}`POST`{% endraw %} request to our endpoint:
{% raw %}

````curl
curl -X POST "https://localhost:5001/WeatherForecast" -H  "accept: */*" -H  "Content-Type: application/json" -d "{\"date\":\"2021-08-22T14:17:58.115Z\",\"temperatureC\":0,\"summary\":\"string\"}"
```
{% endraw %}


Results in following:
{% raw %}

````json
{
  "title": "Request too large",
  "status": 413,
  "type": "https://tools.ietf.org/html/rfc7231#section-6.5.11"
}
```
{% endraw %}


And logs following in to stdout:
{% raw %}

warn: AwesomeApi.ContentLengthRestrictionMiddleware[0]
Rejecting request with Content-Length 71 more than allowed 10.




## Conclusion
That's it! Congratulations! You just designed and created a custom Middleware! Give yourself a pat in the back. Don't forget to stretch your shoulders and neck once in a while.

Happy Coding!

## Code
Source Code is available at:
[https://github.com/iSatishYadav/ContentLengthRestrictionMiddleware](https://github.com/iSatishYadav/ContentLengthRestrictionMiddleware)

If you liked it, go show some love to the repo and star it. 

Originally Posted at my blog:
[https://blog.satishyadav.com/defense-in-depth-designing-an-http-content-length-restriction-middleware-asp-net-5-or-net-core](https://blog.satishyadav.com/defense-in-depth-designing-an-http-content-length-restriction-middleware-asp-net-5-or-net-core?utm_source=dt)

How to setup and use DynamoDb Locally - Free

Satish Yadav — Tue, 06 Jul 2021 15:41:54 +0000

Did you know DynamoDB from AWS has a locally downloadable version which you can install on your local machine and use for development and testing purposes.

As a newbie to AWS, I was unable to find any comprehensive guide on how to setup and use DynamoDB locally. So without further ado, let's start.

Download the DynamoDB Local (Downloadable Version)

There are 3 ways you can download:

Standalone jar file
Using Docker
Using an Apache Maven

I'm using Docker for this tutorial, for instructions on other 2 ways, visit this official AWS site

Please note your application doesn't have to be a containerized application, we're just using DynamoDB database as a container, that's it.

Using `Docker`

Make sure you have docker up and running. If you've not, follow this official instructions

docker run -p 8000:8000 amazon/dynamodb-local
```
{% endraw %}
{% raw %}`

This will download `{% endraw %}DynamoDB{% raw %}` locally from official Docker image and run.
If everything is okay, you'd see output something like this:

`

```shell
Initializing DynamoDB Local with the following configuration:
Port:   8000
InMemory:       true
DbPath: null
SharedDb:       false
shouldDelayTransientStatuses:   false
CorsParams:     *
```

`

This would run the fully functional DynamoDB instance at `http://localhost:8000`.

## [Bonus] Verify installation using AWS CLI.
If don't have AWS CLI installed, follow [this official guide](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)

Run this command to verify the installation

`{% endraw %}
{% raw %}
```shell
aws dynamodb list-tables --endpoint-url http://localhost:8000
```
{% endraw %}
{% raw %}`

If you get an error like this:
`{% endraw %}
{% raw %}
```shell
You must specify a region. You can also configure your region by running "aws configure".
```
{% endraw %}
{% raw %}`
You can run:

`{% endraw %}
{% raw %}
```shell 
aws configure
```
{% endraw %}
{% raw %}`
And you'd be asked to setup follwoing:

`

```shell
AWS Access Key ID:
AWS Secret Access Key :
Default region name [x]:
Default output format [None]:
```

`
You can enter any values, as you're only using DynamoDB locally.

That's it!

That's how you can configure AWS DynamoDB on your local machine to develop and test your applications without spending anything.

Happy Coding!

Originally posted at my blog: [https://blog.satishyadav.com/how-to-setup-and-use-dynamodb-locally-free](https://shawt.io/r/sYW)

.NET 6 LINQ New Features

Satish Yadav — Sun, 04 Jul 2021 15:33:16 +0000

What is `.NET 6` and why should I care?

.NET 6 is the upcoming major overhaul for .NET. It unifies entire .NET experience. No more .NET Core, .NET Full Framework, Xamarin, Mono, etc. Just a single .NET.

New `LINQ` Features

At the time of writing this post, 5 previews of .NET 6 have been released and last couple of releases have been blessing for LINQ.

Here are few top new LINQ features:

New methods MaxBy and MinBy
New methods Chunk
New methods DistinctBy, UnionBy, IntersectBy, and ExceptBy
Index and Range parameters
New method TryGetNonEnumeratedCount
Default parameters for FirstOrDefault, LastOrDefault, and SingleOrDefault
Zip supports 3 IEnumerables

New methods `MaxBy` and `MinBy`

Finding out maximum or minimum has been easier than even with these new MaxBy or MinBy methods.

Suppose a List of Persons as:

static List<Person> people = new List<Person>
{
    new Person { Id = 1, Name = "Amit", Age = 38},
    new Person { Id = 2, Name = "Ravi", Age = 36},
    new Person { Id = 3, Name = "Manish", Age = 34},
    new Person { Id = 4, Name = "Satish", Age = 29},
};

If we need to get maximum and minimum, currently here's how to do it:

//Without using MaxBy and MinBy
Person oldestPerson = people.OrderByDescending(person => person.Age).First();
Person youngestPerson = people.OrderBy(person => person.Age).First();
Console.WriteLine($"Oldest Person without using MaxBy: {oldestPerson.Name}");
Console.WriteLine($"Youngest Person without using MaxBy: {youngestPerson.Name}");

But with MaxBy and MinBy, it's just a single method call:

Person oldestPerson = people.MaxBy(person => person.Age);
Person youngestPerson = people.MinBy(person => person.Age);
Console.WriteLine($"Oldest Person using MaxBy: {oldestPerson.Name}");
Console.WriteLine($"Youngest Person using MaxBy: {youngestPerson.Name}");

Neat, right? Let me know in the comments, if you have alternate methods of getting maximum and minimum using LINQ.

New method `Chunk`

A new method Chunk slices the IEnumerable into provided sizes. e.g. If you have a collection of 4 elements and you need to cluster them into fixed size of 2, here's how to do:

IEnumerable<Person[]> cluster = people.Chunk(2);
// Print each cluster.
foreach(var people in cluster)
{
    Console.WriteLine($"Cluster of {string.Join(",", people.Select(person => person.Name))}");
}
//Prints
// Cluster of Amit,Ravi
// Cluster of Manish,Satish

New methods `DistinctBy`, `UnionBy`, `IntersectBy`, and `ExceptBy`

Exisiting set methods Distinct, Union, Intersect, and Except have been powered up by these new methods which can take a selector function to operate.
e.g.

IEnumerable<Person> evenAgedPeople = people.Where(person => person.Age % 2 == 0);
//Amit,Ravi,Manish

IEnumerable<Person> personAbove35 = people.Where(person => person.Age > 35);
//Amit,Ravi

IEnumerable<Person> union = evenAgedPeople.UnionBy(personAbove35, x => x.Age);
//Amit,Ravi,Manish

IEnumerable<Person> intersection = evenAgedPeople.IntersectBy(personAbove35.Select(p => p.Age), x => x.Age);
//Amit,Ravi

Let me know in the comments, the usage of DistinctBy and ExceptBy.

`Index` and `Range` parameters

Range: .., and Index: ^ already exist in C#8, .NET 6 brings these two to LINQ.

The ElementAt operator now takes indices from the end.

Person secondLastPerson = people.ElementAt(^2);
//Manish

Skip and Take now take Range as well:

IEnumerable<Person> take3People = people.Take(..3);
//Amit,Ravi,Manish

IEnumerable<Person> skip1Person =  people.Take(1..);
//Ravi,Manish,Satish

IEnumerable<Person> take3Skip1People = people.Take(1..3);
//Ravi,Manish

IEnumerable<Person> takeLast2People = people.Take(^2..);
//Manish,Satish

IEnumerable<Person> skipLast3People = people.Take(..^3);
//Amit

IEnumerable<Person> takeLast3SkipLast2 = people.Take(^3..^2);
//Ravi

New method `TryGetNonEnumeratedCount`

Sometimes you need to get a count without the enumeration. TryGetNonEnumeratedCount will try to get count without forcing an enumeration. It internally checks for the implementation of ICollection i.e. IEnumerable that already has a mechanism to get count without forcing an enumeration. Otherwise it'll try to take advantage of new improvements in LINQ.
Useful in scenarios where you want to get a count but not at the cost of enumerating the IEnumerable.
e.g.

List<Person> anotherList = people.TryGetNonEnumeratedCount(out int count) ? new List<Person>(count): new List<Person>();
anotherList.AddRange(people);

In our case right now, we know that people is just an in-memory list, but what if it was from database of some Stream, then it would've made sense to find out the count to optimize the instantiation of anotherList object by specifying capacity parameter.

Default parameters for `FirstOrDefault`, `LastOrDefault`, and `SingleOrDefault`

Current FirstOrDefault, LastOrDefault, and SingleOrDefault methods return default(T) if the source IEnumerable is empty. The new overloads accept a parameter which will be returned if source is empty.

e.g.

List<int> emptyList = new List<int>();
int value = emptyList.FirstOrDefault(-1);
//-1 instead of 0

This reminds me of ISNULL function of SQL Server.

`Zip` supports 3 `IEnumerables`

Before .NET 6, Zip used to take only 2 parameters. Now it takes 3 parameters:

IEnumerable<int> ids = Enumerable.Range(1, 4);
IEnumerable<Person> allPeople = people;
IEnumerable<int> allAges = people.Select(person => person.Age);

IEnumerable<(int Id, Person Person, int Age)> zipped = ids.Zip(allPeople, allAges);

Conclusion

.NET 6 previews are bring awesome set of new features with every new release. Let me know in comments which all features you're excited for.

Next Steps

Download .NET 6 today and try out.
Source code is available at: https://github.com/iSatishYadav/.net-6-linq-new-features

Originally published at my blog at: https://blog.satishyadav.com/.net-6-linq-new-features

Visual Studio 2022 will write code for you!!! - Visual Studio 2022 Series - Part 1

Satish Yadav — Sun, 20 Jun 2021 11:15:11 +0000

Introduction

Visual Studio 2022 Preview 1 is now available! If you've missed the official announcement on June 17th, 2021 - check it out.
If you want to try out, head over to the official download page here.

The Visual Studio 2022 previews can be installed side-by-side with earlier versions of Visual Studio, are available in all three editions (Community, Pro, and Enterprise), and are free to use.

New Features

A lot of new features have come out in this release, however Visual Studio 2022 is just out with Preview 1, meaning there will be more and more new features coming in new Previews.

But today I want to talk about 2 of my favorite features:

64-bit
IntelliCode

64-bit

The first and the biggest feature is - and boy, that's big one - it's 64-bit!!! 😍 This means - Visual Studio 2022 will no longer be limited to ~4gb of memory in the main devenv.exe process.

In Microsoft's own words:

With a 64-bit Visual Studio on Windows, you can open, edit, run, and debug even the biggest and most complex solutions without running out of memory.

This doesn't mean you can't develop 32-bit applications using Visual Studio 2022, it just means the Visual Studio itself wil be able to fully utilize your 64-bit hardware.

IntelliCode - one step further

This one's my favorite new feature. We all know and love IntelliCode - Microsoft's AI enabled Visual Studio component which suggests code changes using Machine Learning Model based on 1000s of Open-Source GitHub repositories and optionally your own repositories if you permit.

In Visual Studio 2022, IntelliCode has gone one step further and not only will suggest the code changes, it'll will write the code for you 😲. Look at this GIF:

As soon as I write StringBuilder it knows what I'm about to write and with the TAB press, it writes StringBuilder sb = new StringBuilder(); for me.
Similarly in the foreach loop, it know I'm going to append the item to the StringBuilder and writes sb.Append(item) for me.
Finally after the loop it knows I want to print it, so it prints using Console.WriteLine by calling ToString() on the StringBuilder reference sb.

Cool, right!!!

Conclusion

This is just a Preview 1, there will be at-lest 4-5 previews before it hits GA - General Availability. So watch out for more posts.

Let me know which all features ya'll are excited for.

Next Steps

Read more about IntelliCode.
Check out the Official announcement
Download Visual Studio 2022 and try now.

Originally Posted at: https://blog.satishyadav.com/Visual-Studio-2022-will-write-code-for-you/

Happy Coding! 👨‍💻

Using NLog in a .NET 5 Console Application with Dependency Injection and send logs to AWS CloudWatch

Satish Yadav — Sat, 22 May 2021 09:04:23 +0000

Description

Explains how to setup NLog as logging provider for .NET 5 Console Application and Dependency Injection).

Demonstrated with a .NET 5 Console application. Example project can also be found on GitHub.

0. Create a new .NET 5 console project

1. Add dependency in csproj manually or using NuGet

Install:

The package NLog.Extensions.Logging
The package Microsoft.Extensions.DependencyInjection - or use another DI library.
The package Microsoft.Extensions.Configuration.Json (used in Main method SetBasePath + AddJsonFile)
Update the NLog package if possible

e.g.

  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.1.0" />
    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.1.0" />
    <PackageReference Include="NLog" Version="4.6.5" />
    <PackageReference Include="NLog.Extensions.Logging" Version="1.5.1" />
  </ItemGroup>

2. Create a nlog.config file.

Create nlog.config (lowercase all) file in the root of your application project (File Properties: Copy Always)

We use this example:

<?xml version="1.0" encoding="utf-8" ?>
<!-- XSD manual extracted from package NLog.Schema: https://www.nuget.org/packages/NLog.Schema-->
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd" xsi:schemaLocation="NLog NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      autoReload="true"
      internalLogFile="c:\temp\skylogs\nlog-internal.log"
      internalLogLevel="Info" >

  <!-- the targets to write to -->
  <targets>
    <!-- write logs to file -->
    <target xsi:type="File" name="logfile" fileName="c:\temp\skylogs\skylogs.log"
            layout="${longdate}|${level}|${message} |${all-event-properties} ${exception:format=tostring}" />
    <target xsi:type="Console" name="logconsole"
            layout="${longdate}|${level}|${message} |${all-event-properties} ${exception:format=tostring}" />
  </targets>

  <!-- rules to map from logger name to target -->
  <rules>
    <logger name="*" minlevel="Trace" writeTo="logfile,logconsole" />
  </rules>
</nlog>

It is recommended to read the NLog Tutorial. For more detailed information about config file can be found here.

If you like to include other targets or layout renderers, check the Platform support.

Ensure to configure your project-file to copy NLog.config to the output directory:

 <ItemGroup>
     <None Update="nlog.config" CopyToOutputDirectory="Always" />
 </ItemGroup>

3. Update your program

3.1 Create your Person class

public class Person
{
      public string Name { get; set; }
      private readonly ILogger<Person> _logger;

      public Person(ILogger<Person> logger)
      {
          _logger = logger;
      }

      public void Talk(string text)
      {
          _logger.LogInformation("Person {name} spoke {text}", Name, text);
      }
}

3.2 Setup the Dependency injector (DI) container

private static IServiceProvider BuildDi(IConfiguration config)
{
   return new ServiceCollection()
           //Add DI Classes here
         .AddTransient<Person>() 
         .AddLogging(loggingBuilder =>
         {
             // configure Logging with NLog
             loggingBuilder.ClearProviders();
             loggingBuilder.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
             loggingBuilder.AddNLog(config);
         })
         .BuildServiceProvider();
}

3.3 Add required usings

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using NLog;
using NLog.Extensions.Logging;

3.4 Update your `Main()`

First create the DI container, then get your Person and start running!

static void Main(string[] args)
{
    var logger = LogManager.GetCurrentClassLogger();
    try
    {
        var config = new ConfigurationBuilder()
           .SetBasePath(System.IO.Directory.GetCurrentDirectory())
           .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
           .Build();

        var servicesProvider = BuildDi(config);

        using (servicesProvider as IDisposable)
        {
            var person = servicesProvider.GetRequiredService<Person>();
            person.Name = "Sky";
            person.Talk("Hello");

            Console.WriteLine("Press ANY key to exit");
            Console.ReadKey();
        }
    }
    catch (Exception ex)
    {
        // NLog: catch any exception and log it.
        logger.Error(ex, "Stopped program because of exception");
        throw;
    }
    finally
    {
        // Ensure to flush and stop internal timers/threads before application-exit (Avoid segmentation fault on Linux)
        LogManager.Shutdown();
    }
}
private static IServiceProvider BuildDi(IConfiguration config)
{
    return new ServiceCollection()
         //Add DI Classes here
       .AddTransient<Person>() // Runner is the custom class
       .AddLogging(loggingBuilder =>
       {
           // configure Logging with NLog
           loggingBuilder.ClearProviders();
           loggingBuilder.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
           loggingBuilder.AddNLog(config);
       })
       .BuildServiceProvider();
}

4 Example output

2021-05-22 12:33:20.8486|Info|Person Sky spoke Hello |name=Sky, text=Hello

Send Logs to AWS CloudWatch

Here's a sample nlog.config to send NLog logs directly to CloudWatch Logs log group.

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      throwConfigExceptions="true">
  <extensions>
    <add assembly="NLog.AWS.Logger" />
  </extensions>
  <targets>
    <target name="aws" type="AWSTarget" logGroup="NLog.ConfigExample" region="us-east-1"/>
  </targets>
  <rules>
    <logger name="*" minlevel="Info" writeTo="aws" />
  </rules>
</nlog>

The AWS credentials will be found using the standard AWS SDK for .NET credentials search path. In this case it will look for a profile named default, search for environment variables or search for an instance profile on an EC2 instance. To use a specific AWS credential profile use the profile attribute on the target.

Configure NLog Targets for output

Next step, see Configure NLog with nlog.config

Originally posted at:
https://blog.satishyadav.com/net-core-console-nlog-with-di/

DEV Community: Satish Yadav

What's new in .NET 8?

Unprecedented Performance Optimizations

.NET Aspire: Redefining Cloud-Native Development

Augmented Container Capabilities in .NET 8

Native AoT - Facilitating Compute Efficiency

Integrating Artificial Intelligence with .NET

Advanced Web Application Development with Blazor

.NET MAUI - Unifying Cross-Platform Development

C# 12 Features - Amplifying Developer Productivity

Broader .NET 8 Support Across Development Tools

Additional new features

Conclusion

Getting started

5 things I wish I knew before writing 1 Million lines of code

1. Your code will be read more times than you think.

2. Readable code > Smart Code

3. Document the “why” instead of “what”.

4. Describe everything your function/method does in the name.

5. “Deadline” is a silly excuse for writing bad code.

Managing Technical Debt with NDepend!

What the hell is a Technical Debt?

How do I know that I have a Technical Debt

What is NDepend

How to find out Technical Debt

Dashboard

Exploring Technical Debt

Next steps

Automate Windows Software and Apps' installation!

Why?

Package Manager FTW!

1. Install Chocolatey itself

An “I don’t know what Docker is and at this point I’m too afraid to ask” guide to Docker.

What is Docker?

Wait, but what's a "Container"?

That's too much of jargons, can you give me a simple analogy?

Why use Docker

But we already have Virtual Machines? Why Containers?

Docker tools and terms

DockerFile

Docker images

Docker containers

Docker Hub

Docker daemon

Docker registry

When to use Docker

Micro-Services

Continuous Integration & Delivery

Docker deployment and orchestration

Docker Compose

Kubernetes

Next steps and Credits

🆕 SQL Server 2022 First Look - Top 5 New Features (Bonus 5 Features)

5. Ledger (Blockchain) Support

4. Peer-to-peer replica conflict resolution

3. Intelligent Query Processing

2. Parameter Sensitive Query Plan Caching

1. Fully Managed Disaster Recovery in the Cloud

How to Install Windows 11 on unsupported Devices - Officially - No Crack - No 3rd Party Tool

Solutions based on what you're missing

1. You don't have TPM 2.0 (but do have TPM 1.2 or other)

2. If you don't have a any TPM

3. If you don't have Secure Boot

Disclaimer

Defense In-Depth: Designing an HTTP Content Length Restriction Middleware - ASP.NET 5 (or .NET Core)

The What?

The Why?

The How? - Let's code

1. Create the basic logic

How to setup and use DynamoDb Locally - Free

Download the DynamoDB Local (Downloadable Version)

Using Docker

.NET 6 LINQ New Features

What is .NET 6 and why should I care?

New LINQ Features

New methods MaxBy and MinBy

New method Chunk

New methods DistinctBy, UnionBy, IntersectBy, and ExceptBy

Index and Range parameters

New method TryGetNonEnumeratedCount

1. You don't have `TPM` 2.0 (but do have `TPM` 1.2 or other)

2. If you don't have a any `TPM`

Using `Docker`

What is `.NET 6` and why should I care?

New `LINQ` Features

New methods `MaxBy` and `MinBy`

New method `Chunk`

New methods `DistinctBy`, `UnionBy`, `IntersectBy`, and `ExceptBy`

`Index` and `Range` parameters

New method `TryGetNonEnumeratedCount`

Default parameters for `FirstOrDefault`, `LastOrDefault`, and `SingleOrDefault`

`Zip` supports 3 `IEnumerables`

3.4 Update your `Main()`