Reference

https://www.youtube.com/watch?v=YiOkz1x2qaE&list=PLdo4fOcmZ0oULyHSPBx-tQzePOYlhvrAU&index=21

https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-8/

Why AOT?

• Smaller apps

• Faster startups

• Less memory usage

Demo

Create a new Api Project and publish. The output is as below.

Self Contained Deployment

By default, the output is framework-dependent. If you want your output independent of the running environment, you may use self-contained. This will include the framework.

Output will include the framework runtime which makes the size very large.

How will Native AOT Will Help?

Enable Nati AOT by adding below to csproj.

<PublishAot>true</PublishAot>

WebApplication.CreateSlimBuilder()

It has fewer defaults and is lighter. Use with Native AOT.

The output will have approximately 10 MB for Windows.

WebApplication.CreateEmptyBuilder()

It creates an empty builder but you need to configure what you need. The output will be smaller.

Reference

https://www.youtube.com/watch?v=FpQXyFoZ9aY&list=PLdo4fOcmZ0oULyHSPBx-tQzePOYlhvrAU&index=20

What is Configuration

• Settings

  • Retry Times

  • Queue Length

• Feature Flags

  • Per User

  • Percentage

• Secrets

  • Connection String

When the Configuration is Applied

• Compile Time

• Run Time

Options Pattern

Github Repo: https://github.com/ibrahimuludag/aspnetcore-configuration

Reference

https://www.youtube.com/watch?v=aOXaBZFB0-0&list=PLdo4fOcmZ0oULyHSPBx-tQzePOYlhvrAU&index=15&t=26s

Why Source Generators

• Alternatıve to Reflection

  • It is compile time not runtime

  • Unblock AOT trimming

  • It is just code

Demo

The code produces the below output.

static void Main(string[] args)
{
    var classTypes = Assembly.GetEntryAssembly()
        .GetTypes()
        .Where(c => c.IsClass && c.IsPublic)
        .Select(c => c.FullName);

    foreach (var classType in classTypes)
    {
        Console.WriteLine(classType);
    }
}

PublishAot

If you have enabled PublishAot, it will publish to machine code and remove all unused references. Since our classes (Student, Course) are not reference, they will no be included in the published code and the output will be empty.

Creating Source Generator

To use Source Generator, the project must target netstandard2.0. So, create a new class library with netstandard2.0.

Add reference for the below packages.

Microsoft.CodeAnalysis.Analyzers
Microsoft.CodeAnalysis.CSharp

Add the reference as below

    <ProjectReference Include="..\Generator\Generator.csproj" OutputItemType="Analyzer" />

Make the changes in the Generator class.

namespace Generator;

[Generator]
public class TheGenerator : IIncrementalGenerator
{
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        var provider = context.SyntaxProvider.CreateSyntaxProvider(
            predicate: static(node, _) => node is ClassDeclarationSyntax,
            transform: static (ctx, _) => (ClassDeclarationSyntax)ctx.Node
            ).Where(c => c is not null);

        var compilation = context.CompilationProvider.Combine(provider.Collect());

        context.RegisterSourceOutput(compilation, Execute);
    }

    private void Execute(SourceProductionContext context, (Compilation Left, ImmutableArray<ClassDeclarationSyntax> Right) tuple)
    {
        var (compilation, list) = tuple;

        var namelist = new List<string>();

        foreach (var systax in list) {
            var symbol = compilation.GetSemanticModel(systax.SyntaxTree)
                .GetDeclaredSymbol(systax) as INamedTypeSymbol;

            namelist.Add($"\"{symbol.ToDisplayString()}\"");
        }

        var names = string.Join(",\n ", namelist);

        var theCode = $$"""
            namespace  Generator;

            public static class ClassNames {
                public static List<string> Names = new(){
                    {{ names }}
                };
            }
            """;

        context.AddSource("YourClassList.g.cs", theCode);
    }
}

Reference

https://www.youtube.com/watch?v=Yf8t7GqA6zA&list=PLdo4fOcmZ0oULyHSPBx-tQzePOYlhvrAU&index=11

https://github.com/ibrahimuludag/sourcegenerator

No Architecture

Pros

• Little or no abstraction

• Quick to build early - go from nothing deployed

• Potential for performance due to tight coupling & less abstraction

Cons

• As the size of the system increases so does the time to develop

• Difficult for multiple teams to work on the same codebase

• Technology changes or breaks impact the whole system

• Difficult to test

N-Tier

Pros

• Fairly intuitive abstraction to start

• Reasonably quick to build

• Improved testability

Cons

• As the size of the system increases so does the time to develop

• Difficult for multiple teams to work on the same codebase

• Technology changes or breaks impact the whole system

Clean Architecture

Pros

• Highly abstracted for larger systems

• Resilient to technology changes

• Very testable

• Not influenced by anything external

• Consistent velocity

• Easy to work on by a few teams

Cons

• Higher barrier to entry

• Depends on training & a disciplined team to utilize it well

• Slower development time overall

• Lots of code to write a simple feature

Vertical Slice Architecture

Proximity Principle

Code that is changed together should live together.

Pros

• Little to no abstraction

• Low barrier to entry

• Resilient to technology changes

• The level of testability can be per feature

• Easy to work on by many teams

• Feature changes have no impact on other features

Cons

• Requires contracts & messaging when working in a larger-scale system

• Hard to decide what to have as Shared Code vs Feature Code

• Each feature can be written in a different way leading to cognitive load when switching

Reference

https://www.youtube.com/watch?v=T-EwN9UqRwE&list=PLdo4fOcmZ0oULyHSPBx-tQzePOYlhvrAU&index=17

.Net has had the aspirational goal of being the most productive platform for building Cloud Native apps for some time.

• Health Checks

• Kestrel

• HTTP Client Factory

  • Polly

• gRPC

• YARP

• Container Builds

• Native AOT

Running distributed applications locally is very hard. Microsoft has developed .Net Aspire for this purpose.

.Net Aspire

• .Net Aspire is a stack for building resilient, observable, and configurable cloud-native applications for .NET

• .Net Aspire includes a curated set of components enhanced for cloud-native fundamentals including Telemetry, Resilience, Configuration, Health Checks, and Composition

• .Net Aspire makes it easy to discover, acquire, and configure essential dependencies for cloud-native applications on day 1 and day 100

Setup

To work with .NET Aspire, you'll need the following installed locally:

• .NET 8.0

• .NET Aspire workload

• Docker Desktop

• Integrated Developer Environment (IDE) or code editor, such as:

  • Visual Studio 2022 Preview version 17.9 or higher (Optional)

  • Visual Studio Code (Optional)

Demo

https://www.youtube.com/watch?v=z1M-7Bms1Jg&list=PLdo4fOcmZ0oULyHSPBx-tQzePOYlhvrAU&index=4

Reference

• https://www.youtube.com/watch?v=z1M-7Bms1Jg&list=PLdo4fOcmZ0oULyHSPBx-tQzePOYlhvrAU&index=4

• https://learn.microsoft.com/en-us/dotnet/aspire/fundamentals/setup-tooling?tabs=visual-studio#install-net-aspire

• https://learn.microsoft.com/en-us/dotnet/aspire/fundamentals/setup-tooling?tabs=visual-studio

It is requied from communitity for .Net Container Images to be

• Small (registry pull faster)

• Secure (non-root; no shell or package manager)

• Compliant (minimal dependencies, easy audit)

• Composable (e.g. add locallication when needed)

• Compatible (glibc vs musl libc)

• Supported (part of a support contract / lifecycle)

Ubuntu Chiseled .NET images

Ubuntu Chiseled .NET images are a type of "distroless" container image that contain only the minimal set of packages .NET needs, with everything else removed. These images offer dramatically smaller deployment sizes and attack surface by including only the minimal set of packages required to run .NET applications.

Please see the Ubuntu Chiseled + .NET documentation page for more info.

Container Size Improvements

.Net Containers in General

How to Publish Your Application?

First add the below package from Nuget.

dotnet add package Microsoft.NET.Build.Containers --version 8.0.100

Then, publish your container using .NET CLI. I am using -r linux-x64, because I am on Windows.

dotnet publish -t:PublishContainer -r linux-x64

Then your application is published as a container to your local registry without any Dockerfile as below.

However, the size of the image will be big. We need to shrink the size of the container.

To shrink, add the PublishTrimmed and ContainerFamily to your csproj file.

<PropertyGroup>
....
    <PublishTrimmed>true</PublishTrimmed>
    <ContainerFamily>jammy-chiseled</ContainerFamily>
....
<PropertyGroup>

Then publish your project again.

dotnet publish -t:PublishContainer -r linux-x64 -p ContainerImageTag=chiseled

You will see that the size is reduced now.

You can also publish your app as Native AOT. Add the below to your csproj file.

<PublishAot>True</PublishAot>

dotnet publish -t:PublishContainer -r linux-x64 -p ContainerImageTag=aot

You can also specify the base image for the container.

<ContainerBaseImage>mcr.microsoft.com/dotnet/nightly/runtime:8.0</ContainerBaseImage>

I believe that creating containers without Dockerfile is a life-saving feature for developers. You can check the documentation for more information.

The namespace has new annotations and modifications to existing ones on .NET8. Let's review those. Also, you can find a working sample project on my Github Repo.

Length

Specifies the minimum and maximum length of collection/string data allowed in a property.

[Length(1, 20)]
public string FirstName { get; set; }

[Length(1, 5)]
public List<string> Courses { get; set; }

Range

Specifies the numeric range constraints for the value of a data field. Now, you can specify whether the range values are inclusive or exclusive.

• MinimumIsExclusive : Specifies whether validation should fail for values that are equal to Minimum.

• MaximumIsExclusive : Specifies whether validation should fail for values that are equal to Maximum.

[Range(15, 25, MinimumIsExclusive = true, MaximumIsExclusive = true)]
public int Age { get; set; }

AllowedValues

Specifies a list of values that should be allowed in a property.

[AllowedValues("Freshman", "Sophomore", "Junior", "Senior")]
public string Grade { get; set; }

DeniedValues

Specifies a list of values that should not be allowed in a property.

[DeniedValues("123456", "qwerty")]
public string Password { get; set; }

Base64String

Specifies that a data field value is a well-formed Base64 string.

[Base64String]
public string Hash { get; set; }

Required

From the blogs, I see that RequiredAttribute has a new property, DisallowAllDefaultValues to exclude default values. However, I cannot see this new feature in the code and documentation. I guess, this was remove in the release.

Reference

https://learn.microsoft.com/en-us/dotnet/api/system.componentmodel.dataannotations?view=net-8.0

Site Reliability Engineering

Reliability is the ability of a system or component to perform its intended function under specified conditions for an extended period without failure. A reliable product has a high probability of performing as expected over time. The reliability of a product can be measured by how long it will last before failing and how often it fails.

• Availability

• Performance

• Latency

• Security

Measuring Reliability

SLA: Service Level Agreement

The agreement made with customers about how available the system is

SLO: Service Level Objective

The goal that the service wants to reach or meet agreements

SLI: Service Level Indicators

Actual service metric behind the commitments

Why SRE?

• Ownership

• Work Silos

• Full Stack

Key Concepts

• Feedback

• Measure everything

• Alert

• Automate

• Small changes (often)

• Embrace Risk

Devops focuses on development, SRE focuses on production.

Azure Monitor

Azure Monitor is a comprehensive monitoring solution for collecting, analyzing, and responding to monitoring data from your cloud and on-premises environments.

Metrics

Azure Monitor Metrics is a feature of Azure Monitor that collects numeric data from monitored resources into a time-series database. Metrics are numerical values that are collected at regular intervals and describe some aspect of a system at a particular time.

You can

• Visualize Data

• Analyze

• Alert

• Automate

Health Checks

Application Insights is an extension of Azure Monitor and provides application performance monitoring (APM) features. APM tools are useful to monitor applications from development, through test, and into production in the following ways:

• Proactively understand how an application is performing.

• Reactively review application execution data to determine the cause of an incident.

Application Insights helps us to create health checks.

Availability - URL Ping Test

Send a HTTP Request to a specific URL

• Request duration and success rate

• Dependent Requests

• Enable retries are recommended

• Min 5 Max 16 locations

• Create alerts

Monitor > Application Insights > Investigate > Availability > Add test

To notify => Create Action Group

In action group you can add SMS, Voice, Email, Push Notification and then create action.

Actions are

• Webhook

• Azure Function

• Runbook

• Logic App

• ...

Load and Failure Conditions

Plan for failures

Failure mode Analysis

• Find Single point of failure

• Rate Risk and Severity

• Determine Response

• Understand Application

• Criticality

• Understand Dependencies

Prevent Failures

• Fault Domains

• Availability Zones

• Cross-Regions

• Auto Scaling

Performance Testing

• Load Testing : Make sure that application handle normal load

• Stress Testing : Analyze the upper limit of the application

Baseline Metrics

Normal condition is different for each environment

Smart Detection and Dynamic Thresholds

Uses machine learning. Adopt new conditions.

It is built-in.

Failure needs a minimum 24 hours of data

Performance needs minimum 8 days of data

Submodule

Submodules allow you to keep a Git repository as a subdirectory of another Git repository. This lets you clone another repository into your project and keep your commits separate.

git submodule init
git submodule update
git submodule add https://github.com/account/repo

Azure Submodules

Authentication should be either of below

• Unauthenticated

• Authenticated with the main repo account

Scalar

Scalar is a repository management tool that optimizes Git for use in large repositories. Scalar improves performance by configuring advanced Git settings, maintaining repositories in the background, and helping to reduce data sent across the network.

New Repo:

scalar clone [options] <url>

Existing Repo

scalar register

Github & AAD

Requirements

• Github Enterprise Cloud Organization

Git Commands

git log --oneline
git log --pretty="- s%"

Branching Strategies

• Trunk Based

• Feature (Task) Based

• Release Based

Pull Request

Should contain

• What

• Why

• How

• Test

• References

  • Work Item

  • Screenshot

  • Document

• The Rest

  • Challenges

  • Improvements

Efficient Pull Request

• Automatically Assignment

• Reminder

• Pull Analytics

Effective Code Review

• Size Limit

  • Less than 400 lines of code

  • Less than one hour

• Annotation

  • Guide reviewers

  • Provide Context

• Checklist

Static Code Analysis

• Coding Errors

• Security Vulnerabilities

GitHub Marketplace

• Code Quality

• Code Review

  • DeepSource

Git Tags

Mark specific versions in history

• Supports annotation

Kinds

• Lightweight

  • Just a tag

  • Simply point to a time in history

• Annotated

  • Attached note on a tag

Web Portal: Only annotated

Handling Large Files

For large files, use Git LFS (Large File System)

• Open Source Extention installed separately

• Large file is hosted seperataley

git lfs install
git lfs track "*.psd"

Tricks

• Do not commit produced binaries

• Cleanup = git gc (Remove untracked files)

Remove unwanted data

• Need to remove secure data/file/secret/GPDR/sensitive data

Remove local data

1 - Delete unwanted data
2 - git rm --cached <filename>
3 - git reset HEAD^
4- git commit --ammend -m "comment"

Remove Remote Repository

1 - Reset to last good commit before the file commit
git reset --hard #commitSHA

2 - git push --force

Remove from History

Not easy. Use 3rd party tools

• git filter-branch

• git filter-repo

• BFG Repo cleaner

Pipeline Matrix

A build matrix is something that comes out of product-based companies: you have a single code base that you need to build across multiple permutations of operating systems, software versions, etc.

trigger:
- master

strategy:
  matrix:
    'Ubuntu 16.04':
      image: 'ubuntu-16.04'
      dotnetcore: '2.2.x'
    'Ubuntu 18.04':
      image: 'ubuntu-18.04'
      dotnetcore: '3.1.x'
    'MacOS X High Sierra':
      image: 'macos-10.13'
      dotnetcore: '2.2.x'
    'MacOS X Mojave':
      image: 'macos-10.14'
      dotnetcore: '3.1.x'
    'Windows Server 2016':
      image: 'vs2017-win2016'
      dotnetcore: '2.2.x'
    'Windows Server 2019':
      image: 'windows-2019'
      dotnetcore: '3.1.x'

pool:
  vmImage: $(image)

variables:
  solution: '**/*.sln'
  buildPlatform: 'Any CPU'
  buildConfiguration: 'Release'

steps:
- task: UseDotNet@2
  inputs:
    packageType: 'sdk'
    version: $(dotnetcore)

- task: DotNetCoreCLI@2
  displayName: "Restore"
  inputs:
    command: 'restore'
    projects: '**/*.csproj'
    feedsToUse: 'select'

- task: DotNetCoreCLI@2
  displayName: "Build"
  inputs:
    command: 'build'
    projects: '**/*.csproj'

- task: DotNetCoreCLI@2
  displayName: "Unit Tests"
  inputs:
    command: 'test'
    projects: '**/tests/UnitTests/UnitTests.csproj'

- task: DotNetCoreCLI@2
  displayName: "Publish Infrastructure"
  inputs:
    command: 'publish'
    publishWebProjects: false
    projects: '$(Build.SourcesDirectory)/src/Infrastructure/Infrastructure.csproj'

- task: DotNetCoreCLI@2
  displayName: "Publish ApplicationCore"
  inputs:
    command: 'publish'
    publishWebProjects: false
    projects: '$(Build.SourcesDirectory)/src/ApplicationCore/ApplicationCore.csproj'

- task: DotNetCoreCLI@2
  displayName: "Publish Web"
  inputs:
    command: 'publish'
    publishWebProjects: true

- task: CopyFiles@2
  inputs:
    SourceFolder: '$(Build.SourcesDirectory)'
    Contents: |
      src\ApplicationCore\bin\Debug\netstandard2.1\ApplicationCore.dll
      src\Infrastructure\bin\Debug\netstandard2.1\Infrastructure.dll
      src\Web\bin\Debug\netcoreapp3.1\Web.dll
      src\Web\bin\Debug\netcoreapp3.1\Web.Views.dll
    TargetFolder: '$(Build.ArtifactStagingDirectory)'

- task: PublishPipelineArtifact@1
  inputs:
    targetPath: '$(Build.ArtifactStagingDirectory)'
    artifact: '$(image)'
    publishLocation: 'pipeline'

Azure Artifacts

Supports Maven, NPM, Nuget, Python

Semantic Versioning

2.5.7-prerelease

{major}.{minor}.{patch}-{tag}

YAML Templates

template.yml

steps
 - npm install
 - npm test
tasks

pipeline-yml (external repo)

pool:
 image: ubuntu-latest

resources:
  repositories:
    - repository: templates
    - type: git
    - name: project/repo

steps:
 - templates/template.yml@templates

pipeline-yml (same repo)

pool:
 image: ubuntu-latest

steps:
 - template.yml

Variable Groups

Variable is only used once

variables:
 vmImageName: 'ubuntu-latest'

pool:
 vmImage: $(vmImageName)

Variable groups are used in multiple places (temples)

Pipeline > Library

You can insert variable groups in pipelines. E.g. Secrets,...

variables:
 - group: my-variable-group
 - name: azureServiceConnectionId
   value: '{SUBSCRIPTION_ID}'

Powershell DSC (Desired State Condiguration)

Maintain state

Configuration HelloWorld {

    # Import the module that contains the File resource.
    Import-DscResource -ModuleName PsDesiredStateConfiguration

    # The Node statement specifies which targets to compile MOF files for, when this configuration is executed.
    Node 'localhost' {

        # The File resource can ensure the state of files, or copy them from a source to a destination with persistent updates.
        File HelloWorld {
            DestinationPath = "C:\Temp\HelloWorld.txt"
            Ensure = "Present"
            Contents   = "Hello World from DSC!"
        }
    }
}

https://www.techtarget.com/searchwindowsserver/definition/Microsoft-Windows-PowerShell-DSC-Desired-State-Configuration

Bicep Files

Alternative to ARM templates

Abstraction over ARM templates.

https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/overview?tabs=bicep

Visual Studio App Center

Deploy application to multiple devices (IOS, Mac, Windows)

Azure AD Privileged Identity Management

Privileged Identity Management (PIM) is a service in Azure Active Directory (Azure AD) that enables you to manage, control, and monitor access to important resources in your organization. These resources include resources in Azure AD, Azure, and other Microsoft Online Services such as Microsoft 365 or Microsoft Intune. The following video explains important PIM concepts and features.

What does it do?

Privileged Identity Management provides time-based and approval-based role activation to mitigate the risks of excessive, unnecessary, or misused access permissions on resources that you care about. Here are some of the key features of Privileged Identity Management:

• Provide just-in-time privileged access to Azure AD and Azure resources

• Assign time-bound access to resources using start and end dates

• Require approval to activate privileged roles

• Enforce multi-factor authentication to activate any role

• Use justification to understand why users activate

• Get notifications when privileged roles are activated

• Conduct access reviews to ensure users still need roles

• Download audit history for internal or external audit

• Prevents removal of the last active Global Administrator and Privileged Role Administrator role assignments

Azure AD Conditional Access

if then statements for actions

• Scope

• Condition

• Make Condition

Output Caching was one of my favorite features in .Net Framework. Unfortunately, output caching was not available .Net Core until .Net 7 version.

The output caching middleware enables caching of HTTP responses. .Net saves the cached entries on the server. Thus, you have more control over caching.

The output caching middleware can be used in all types of ASP.NET Core apps: Minimal API, Web API with controllers, MVC, and Razor Pages.

Basics

Add output cache middleware to services and then to the processing pipeline as below.

builder.Services.AddOutputCache();
.....
app.UseOutputCache();

Add [OutputCache] attribute to your controller.

[HttpGet(Name = "GetWeatherForecast Default")]
[OutputCache]
public IEnumerable<WeatherForecast> GetDefault()
{
....
}

For a minimal API, you can configure it as below.

app.MapGet("/cached", Gravatar.WriteGravatar).CacheOutput();
app.MapGet("/attribute", [OutputCache] (context) => 
   Gravatar.WriteGravatar(context));

As you can see, it is very easy to add output caching. The next step is configuration.

Configuration

There are simply two places for configuring the output cache.

• AddOutputCache

• OutputCacheAttribute

AddOutputCache

Add your policies while calling AddOutputCache.

builder.Services.AddOutputCache(options =>
    {
        options.AddBasePolicy(builder =>
            builder.Expire(TimeSpan.FromSeconds(10)));

        options.AddPolicy("Expire20", builder =>
            builder.Expire(TimeSpan.FromSeconds(20)));

        options.AddPolicy("Expire30", builder =>
            builder.Expire(TimeSpan.FromSeconds(30)));    
    });

AddBasePolicy is the default policy. If nothing is specified, this policy will be used. builder.Expire(TimeSpan.FromSeconds(10) specifies when the cached entry will expire.

For Controllers, you can specify your policy in the attribute.

[HttpGet("get-bypolicy", Name = "GetWeatherForecast Policy")]
[OutputCache(PolicyName = "Expire20")]
public IEnumerable<WeatherForecast> GetPolicy()
{
....
}

For a minimal API, you can use as below.

app.MapGet("/20", Gravatar.WriteGravatar).CacheOutput("Expire20");
app.MapGet("/30", [OutputCache(PolicyName = "Expire30")] (context) => 
    Gravatar.WriteGravatar(context));

Cache Key

• SetVaryByQuery - Specify one or more query string names to add to the cache key.

• SetVaryByHeader - Specify one or more HTTP headers to add to the cache key.

• VaryByValue- Specify a value to add to the cache key. The following example uses a value that indicates whether the current server time in seconds is odd or even. A new response is generated only when the number of seconds goes from odd to even or even to odd.

For example, you want the cache temperatures by city. You can achieve this by using SetVaryByQuery. You can specify this in either AddOutputCache or OutputCache attribute.

[HttpGet("{city}", Name = "GetWeatherForecast Query")]
[OutputCache(VaryByQueryKeys = new[] { "city" })]
public IEnumerable<WeatherForecast> GetByQuery(string city)
{
...
}

What can you cache?

By default, output caching follows these rules:

• Only HTTP 200 responses are cached.

• Only HTTP GET or HEAD requests are cached.

• Responses that set cookies aren't cached.

• Responses to authenticated requests aren't cached.

Conclusion

Output caching is a very simple and powerful feature of .Net 7. With a little effort, you can improve the performance of your applications.

References

• https://learn.microsoft.com/en-us/aspnet/core/performance/caching/output?view=aspnetcore-7.0

• https://learn.microsoft.com/en-us/aspnet/core/performance/caching/overview?view=aspnetcore-7.0

You can find the source code for this post on my GitHub repository.

Let's discover C# 11.

1 - Raw String Literals

I have been waiting for this feature for a long time. No more escaping strings.

You can create multiline strings as below.

string rawStringLiteralDelimiter = """"
    Raw string literals are delimited 
    by a string of at least three double quotes,
    like this: """
    """";

A raw string literal starts with at least three double-quote (""") characters. It ends with the same number of double-quote characters. Typically, a raw string literal uses three double quotes on a single line to start the string, and three double quotes on a separate line to end the string.

string singleLine = """Friends say "hello" as they pass by.""";

Embedding XML and JSON string is a piece of cake now.

string embeddedXML = """
       <element attr = "content">
           <body style="normal">
               Here is the main text
           </body>
           <footer>
               Excerpts from "An amazing story"
           </footer>
       </element >
       """;

string jsonString = """
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureCelsius": 25,
  "Summary": "Hot",
  "DatesAvailable": [
    "2019-08-01T00:00:00-07:00",
    "2019-08-02T00:00:00-07:00"
  ],
  "TemperatureRanges": {
    "Cold": {
      "High": 20,
      "Low": -10
    },
    "Hot": {
      "High": 60,
      "Low": 20
    }
            },
  "SummaryWords": [
    "Cool",
    "Windy",
    "Humid"
  ]
}
""";

The following examples demonstrate the compiler errors reported based on these rules:

// CS8997: Unterminated raw string literal.
var multiLineStart = """This
    is the beginning of a string 
    """;

// CS9000: Raw string literal delimiter must be on its own line.
var multiLineEnd = """
    This is the beginning of a string """;

// CS8999: Line does not start with the same whitespace as the closing line
// of the raw string literal
var noOutdenting = """
    A line of text.
Trying to outdent the second line.
    """;

2 - Required Members

You can add the required modifier to properties and fields to enforce constructors and callers to initialize those values.

Previously, I was using constructors to ensure obligatory properties were set. However, this method increased the complexity and maintainability of my code. Now, with the help of the required modifier, this is easier.

public class Book
{
    public required string Title { get; set; }
    public required string Author { get; set; }
    public int? Pages { get; set; }
}

// This will compile
var solito = new Book { Author = "Javier Zamora", Title = "Solito: A Memoir" };

// This will not compile
var solitoError = new Book { Author = "Javier Zamora" };

You will also see the required properties on IntelliSense.

3 - Auto Default Structs

The C# 11 compiler ensures that all fields of a struct type are initialized to their default value as part of executing a constructor.

public struct Coordinate
{
    public double Longitude { get; set; }
    public double Latitude { get; set; }

    public override string ToString()
    {
        return $"Longitude : {Longitude}, Latitude : {Latitude}";
    }
}

Console.WriteLine(new Coordinate());

// Output is as below
// Longitude : 0, Latitude : 0

4 - File Local Type

Beginning in C# 11, you can use the file access modifier to create a type whose visibility is scoped to the source file in which it is declared. This feature helps source generator authors avoid naming collisions.

5 - Generic Attributes

You can declare a generic class whose base class is System.Attribute. This feature provides a more convenient syntax for attributes that require a System.Type parameter.

public class GenericAttribute<T> : Attribute {
    public T Name { get; private set; }

    public GenericAttribute(T name)
    {
        Name = name;
    }
}

[Generic<int>(10)]
public class GenericClass1
{
}

[Generic<string>("Hello World")]
public class GenericClass2
{
}


// Below will not compile
[Generic<T>()]
public class GenericClass3<T>
{
}

6 - List Patterns

In previous versions of C#, pattern matching was introduced. In C#11 pattern matching was extended to use lists and arrays.

int[] numbers = { 1, 2, 3 };

Console.WriteLine(numbers is [1, 2, 3]);  // True
Console.WriteLine(numbers is [1, 2, 4]);  // False
Console.WriteLine(numbers is [1, 2, 3, 4]);  // False
Console.WriteLine(numbers is [0 or 1, <= 2, >= 3]);  // True

// Discard pattern "_"
// Slice pattern ".."
Console.WriteLine(new[] { 1, 2, 3, 4, 5 } is [> 0, > 0, ..]);  // True
Console.WriteLine(new[] { 1, 1 } is [_, _, ..]);  // True
Console.WriteLine(new[] { 0, 1, 2, 3, 4 } is [> 0, > 0, ..]);  // False
Console.WriteLine(new[] { 1 } is [1, 2, ..]);  // False

Console.WriteLine(new[] { 1, 2, 3, 4 } is [.., > 0, > 0]);  // True
Console.WriteLine(new[] { 2, 4 } is [.., > 0, 2, 4]);  // False
Console.WriteLine(new[] { 2, 4 } is [.., 2, 4]);  // True

Console.WriteLine(new[] { 1, 2, 3, 4 } is [>= 0, .., 2 or 4]);  // True
Console.WriteLine(new[] { 1, 0, 0, 1 } is [1, 0, .., 0, 1]);  // True
Console.WriteLine(new[] { 1, 0, 1 } is [1, 0, .., 0, 1]);  // False

7 - Utf8 String Literals

You can specify the u8 suffix on a string literal to specify UTF-8 character encoding. If your application needs UTF-8 strings for HTTP string constants or similar text protocols, you can use this feature to simplify the creation of UTF-8 strings.

string s1 = "hello"u8;             // Error
var s2 = "hello"u8;                // Okay and type is ReadOnlySpan<byte>
ReadOnlySpan<byte> s3 = "hello"u8; // Okay.
byte[] s4 = "hello"u8;             // Error - Cannot implicitly convert type 'System.ReadOnlySpan<byte>' to 'byte[]'.
byte[] s5 = "hello"u8.ToArray();   // Okay.
Span<byte> s6 = "hello"u8;         // Error - Cannot implicitly convert type 'System.ReadOnlySpan<byte>' to 'System.Span<byte>'.

Conclusion

These are several features of C# 11. If you want to learn more, you can go to "What's new in C# 11".

Happy Coding!

References

• https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-11

• https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/struct#struct-initialization-and-default-values

• https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/file

• https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/patterns

• https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/strings

• https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-11.0/utf8-string-literals