C#

https://learn.microsoft.com/en-us/dotnet/csharp/
Admin
C# is a modern, object-oriented programming language for building web, cloud, mobile, desktop,...
Tokens:1,556,212
Snippets:14,436
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Setup for XML documentation file generation

Source: https://learn.microsoft.com/en-us/dotnet/csharp/misc/cs1569

This example demonstrates the initial setup for generating an XML documentation file using the /doc compiler flag and setting the file to read-only.

```csharp
// 1569a.cs  
// compile with: /doc:CS1569.xml  
// post-build command: attrib +r CS1569.xml  
class Test  
{  
   /// <summary>Test.</summary>  
   public static void Main() {}  
}  
```

--------------------------------

### Complete Program.cs Example

Source: https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/cancel-async-tasks-after-a-period-of-time

The full source code for the Program.cs file, including the HttpClient setup and the asynchronous URL processing logic.

```csharp
using System.Diagnostics;

class Program
{
    static readonly CancellationTokenSource s_cts = new CancellationTokenSource();

    static readonly HttpClient s_client = new HttpClient
    {
        MaxResponseContentBufferSize = 1_000_000
    };

    static readonly IEnumerable<string> s_urlList = new string[]
    {
            "https://learn.microsoft.com",
            "https://learn.microsoft.com/aspnet/core",
            "https://learn.microsoft.com/azure",
            "https://learn.microsoft.com/azure/devops",
            "https://learn.microsoft.com/dotnet",
            "https://learn.microsoft.com/dynamics365",
            "https://learn.microsoft.com/education",
            "https://learn.microsoft.com/enterprise-mobility-security",
            "https://learn.microsoft.com/gaming",
            "https://learn.microsoft.com/graph",
            "https://learn.microsoft.com/microsoft-365",
            "https://learn.microsoft.com/office",
            "https://learn.microsoft.com/powershell",
            "https://learn.microsoft.com/sql",
            "https://learn.microsoft.com/surface",
            "https://learn.microsoft.com/system-center",
            "https://learn.microsoft.com/visualstudio",
            "https://learn.microsoft.com/windows",
            "https://learn.microsoft.com/maui"
    };

    static async Task Main()
    {
        Console.WriteLine("Application started.");

        try
        {
            s_cts.CancelAfter(3500);

            await SumPageSizesAsync();
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("\nTasks cancelled: timed out.\n");
        }
        finally
        {
            s_cts.Dispose();
        }

        Console.WriteLine("Application ending.");
    }

    static async Task SumPageSizesAsync()
    {
        var stopwatch = Stopwatch.StartNew();

        int total = 0;
        foreach (string url in s_urlList)
        {
            int contentLength = await ProcessUrlAsync(url, s_client, s_cts.Token);
            total += contentLength;
        }

        stopwatch.Stop();

        Console.WriteLine($"\nTotal bytes returned:  {total:#,#}");
        Console.WriteLine($"Elapsed time:          {stopwatch.Elapsed}\n");
    }

    static async Task<int> ProcessUrlAsync(string url, HttpClient client, CancellationToken token)
    {
        HttpResponseMessage response = await client.GetAsync(url, token);
        byte[] content = await response.Content.ReadAsByteArrayAsync(token);
        Console.WriteLine($"{url,-60} {content.Length,10:#,#}");

        return content.Length;
    }
}
```

--------------------------------

### C# Simulation Baseline Setup

Source: https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/performance/ref-tutorial

Initializes the room and gathers baseline data before starting the main simulation loop.

```csharp
Console.WriteLine("Press <return> to start simulation");
Console.ReadLine();
var room = new Room("gallery");
var r = new Random();

int counter = 0;

room.TakeMeasurements(
    m =>
    {
        Console.WriteLine(room.Debounce);
        Console.WriteLine(room.Average);
        Console.WriteLine();
        counter++;
        return counter < 20000;
    });

```

--------------------------------

### Providing examples with <example>

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/xmldoc/recommended-tags

The <example> tag is used to provide a usage example for a library member, typically containing a <code> block.

```XML
<example>
This shows how to increment an integer.
<code>
    var index = 5;
    index++;
</code>
</example>
```

--------------------------------

### stackalloc usage examples

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/expressions

Examples demonstrating stack allocation with initialization, type inference, and implicit conversions.

```C#
// Memory uninitialized
Span<int> span1 = stackalloc int[3];
// Memory initialized
Span<int> span2 = stackalloc int[3] { -10, -15, -30 };
// Type int is inferred
Span<int> span3 = stackalloc[] { 11, 12, 13 };
// Error; result is int*, not allowed in a safe context
var span4 = stackalloc[] { 11, 12, 13 };
// Error; no conversion from Span<int> to Span<long>
Span<long> span5 = stackalloc[] { 11, 12, 13 };
// Converts 11 and 13, and returns Span<long> 
Span<long> span6 = stackalloc[] { 11, 12L, 13 };
// Converts all and returns Span<long>
Span<long> span7 = stackalloc long[] { 11, 12, 13 };
// Implicit conversion of Span<T>
ReadOnlySpan<int> span8 = stackalloc int[] { 10, 22, 30 };
// Implicit conversion of Span<T>
Widget<double> span9 = stackalloc double[] { 1.2, 5.6 };

public class Widget<T>
{
    public static implicit operator Widget<T>(Span<double> sp) { return null; }
}
```

--------------------------------

### Math.Divide XML Documentation Example

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/xmldoc/examples

An example of using XML documentation tags like <summary>, <returns>, <example>, and <exception> within a C# method.

```csharp
        // Divides a double by another and returns the result
        /// <summary>
        /// Divides a double <paramref name="a"/> by another double
        /// <paramref name="b"/> and returns the result.
        /// </summary>
        /// <returns>
        /// The quotient of two doubles.
        /// </returns>
        /// <example>
        /// <code>
        /// double c = Math.Divide(4.5, 5.4);
        /// if (c > 1.0)
        /// {
        ///     Console.WriteLine(c);
        /// }
        /// </code>
        /// </example>
        /// <exception cref="System.DivideByZeroException">
        /// Thrown when <paramref name="b"/> is equal to 0.
        /// </exception>
        /// See <see cref="Math.Divide(int, int)"/> to divide integers.
        /// <seealso cref="Math.Add(double, double)"/>
        /// <seealso cref="Math.Subtract(double, double)"/>
        /// <seealso cref="Math.Multiply(double, double)"/>
        /// <param name="a">A double precision dividend.</param>
        /// <param name="b">A double precision divisor.</param>
        public static double Divide(double a, double b)
        {
            return a / b;
        }
    }
}
```

--------------------------------

### Create the sample solution using .NET CLI

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/closed-hierarchies

Commands to initialize the solution, create the class libraries and console application, and set up project references.

```bash
dotnet new sln -n TelemetryMonitor
dotnet new classlib --langversion preview -n SmartHome.Core
dotnet new classlib --langversion preview -n SmartHome.Extensions
dotnet new console --langversion preview -n SmartHome.App
dotnet sln add SmartHome.Core SmartHome.Extensions SmartHome.App
dotnet add SmartHome.Extensions reference SmartHome.Core
dotnet add SmartHome.App reference SmartHome.Core SmartHome.Extensions
```

--------------------------------

### Property with get accessor and field

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-14.0/field-keyword

Example of a property using the field keyword within a get accessor block.

```csharp
public string LazilyComputed { get => field ??= Compute(); }
```

--------------------------------

### Slice pattern matching examples

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/patterns

Various examples demonstrating how slice patterns match elements at the start, end, or middle of an array.

```C#
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
```

--------------------------------

### Run the C# list example via .NET CLI

Source: https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/tutorials/list-collection

Commands to navigate to the tutorials directory and execute the C# file.

```bash
cd tutorials
dotnet lists.cs
```

--------------------------------

### Complete Office Interop Walkthrough

Source: https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/interop/how-to-access-office-interop-objects

A full example demonstrating creating a list of accounts, displaying them in Excel, and linking them to a Word document.

```C#
using System.Collections.Generic;
using Excel = Microsoft.Office.Interop.Excel;
using Word = Microsoft.Office.Interop.Word;

namespace OfficeProgrammingWalkthruComplete
{
    class Walkthrough
    {
        static void Main(string[] args)
        {
            // Create a list of accounts.
            var bankAccounts = new List<Account>
            {
                new Account {
                              ID = 345678,
                              Balance = 541.27
                            },
                new Account {
                              ID = 1230221,
                              Balance = -127.44
                            }
            };

            // Display the list in an Excel spreadsheet.
            DisplayInExcel(bankAccounts);

            // Create a Word document that contains an icon that links to
            // the spreadsheet.
            CreateIconInWordDoc();
        }

        static void DisplayInExcel(IEnumerable<Account> accounts)
        {
            var excelApp = new Excel.Application();
            // Make the object visible.
            excelApp.Visible = true;

            // Create a new, empty workbook and add it to the collection returned
            // by property Workbooks. The new workbook becomes the active workbook.
            // Add has an optional parameter for specifying a particular template.
            // Because no argument is sent in this example, Add creates a new workbook.
            excelApp.Workbooks.Add();

            // This example uses a single workSheet.
            Excel._Worksheet workSheet = excelApp.ActiveSheet;

            // Earlier versions of C# require explicit casting.
            //Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet;

            // Establish column headings in cells A1 and B1.
            workSheet.Cells[1, "A"] = "ID Number";
            workSheet.Cells[1, "B"] = "Current Balance";

            var row = 1;
            foreach (var acct in accounts)
            {
                row++;
                workSheet.Cells[row, "A"] = acct.ID;
                workSheet.Cells[row, "B"] = acct.Balance;
            }

            workSheet.Columns[1].AutoFit();
            workSheet.Columns[2].AutoFit();

            // Call to AutoFormat in Visual C#. This statement replaces the
            // two calls to AutoFit.
            workSheet.Range["A1", "B3"].AutoFormat(
                Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);

            // Put the spreadsheet contents on the clipboard. The Copy method has one
            // optional parameter for specifying a destination. Because no argument
            // is sent, the destination is the Clipboard.
            workSheet.Range["A1:B3"].Copy();
        }

        static void CreateIconInWordDoc()
        {
            var wordApp = new Word.Application();
            wordApp.Visible = true;

            // The Add method has four reference parameters, all of which are
            // optional. Visual C# allows you to omit arguments for them if
            // the default values are what you want.
            wordApp.Documents.Add();

            // PasteSpecial has seven reference parameters, all of which are
            // optional. This example uses named arguments to specify values
            // for two of the parameters. Although these are reference
            // parameters, you do not need to use the ref keyword, or to create
            // variables to send in as arguments. You can send the values directly.
            wordApp.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);
        }
    }

    public class Account
    {
        public int ID { get; set; }
        public double Balance { get; set; }
    }
}
```

--------------------------------

### CS0271 Error Generation Example

Source: https://learn.microsoft.com/en-us/dotnet/csharp/misc/cs0271

This example demonstrates the CS0271 error by attempting to access a property with a private get accessor. Property2 is included as a valid comparison.

```csharp
// CS0271.cs  
public class MyClass  
{  
   public int Property  
   {  
      private get { return 0; }  
      set { }  
   }  
  
   public int Property2  
   {  
      get { return 0; }  
      set { }  
   }  
}  
  
public class Test  
{  
   public static void Main(string[] args)
   {  
      MyClass c = new MyClass();  
      int a = c.Property;   // CS0271  
      int b = c.Property2;   // OK  
   }  
}  
```

--------------------------------

### Run the patterns tutorial

Source: https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/tutorials/pattern-matching

Commands to navigate to the tutorials directory and execute the patterns.cs file.

```bash
cd tutorials
dotnet patterns.cs
```

--------------------------------

### Implement a Contact class with get and private set accessors

Source: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/how-to-implement-a-lightweight-class-with-auto-implemented-properties

This example demonstrates the difference between a property with only a get accessor and one with a get and private set accessor. The Name property is immutable after construction, while the Address property can be modified within the class.

```csharp
class Contact
{
    public string Name { get; }
    public string Address { get; private set; }

    public Contact(string contactName, string contactAddress)
    {
        // Both properties are accessible in the constructor.
        Name = contactName;
        Address = contactAddress;
    }

    // Name isn't assignable here. This will generate a compile error.
    //public void ChangeName(string newName) => Name = newName;

    // Address is assignable here.
    public void ChangeAddress(string newAddress) => Address = newAddress;
}
```

--------------------------------

### Complete project example with output

Source: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/knowing-when-to-use-override-and-new-keywords

A full C# program demonstrating the behavior of override and new keywords across multiple test scenarios.

```csharp
using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace OverrideAndNew2  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            // Declare objects of the derived classes and test which version  
            // of ShowDetails is run, base or derived.  
            TestCars1();  
  
            // Declare objects of the base class, instantiated with the  
            // derived classes, and repeat the tests.  
            TestCars2();  
  
            // Declare objects of the derived classes and call ShowDetails  
            // directly.  
            TestCars3();  
  
            // Declare objects of the base class, instantiated with the  
            // derived classes, and repeat the tests.  
            TestCars4();  
        }  
  
        public static void TestCars1()  
        {  
            System.Console.WriteLine("\nTestCars1");  
            System.Console.WriteLine("----------");  
  
            Car car1 = new Car();  
            car1.DescribeCar();  
            System.Console.WriteLine("----------");  
  
            // Notice the output from this test case. The new modifier is  
            // used in the definition of ShowDetails in the ConvertibleCar  
            // class.
            ConvertibleCar car2 = new ConvertibleCar();  
            car2.DescribeCar();  
            System.Console.WriteLine("----------");  
  
            Minivan car3 = new Minivan();  
            car3.DescribeCar();  
            System.Console.WriteLine("----------");  
        }  
        // Output:  
        // TestCars1  
        // ----------  
        // Four wheels and an engine.  
        // Standard transportation.  
        // ----------  
        // Four wheels and an engine.  
        // Standard transportation.  
        // ----------  
        // Four wheels and an engine.  
        // Carries seven people.  
        // ----------  
  
        public static void TestCars2()  
        {  
            System.Console.WriteLine("\nTestCars2");  
            System.Console.WriteLine("----------");  
  
            var cars = new List<Car> { new Car(), new ConvertibleCar(),
                new Minivan() };  
  
            foreach (var car in cars)  
            {  
                car.DescribeCar();  
                System.Console.WriteLine("----------");  
            }  
        }  
        // Output:  
        // TestCars2  
        // ----------  
        // Four wheels and an engine.  
        // Standard transportation.  
        // ----------  
        // Four wheels and an engine.  
        // Standard transportation.  
        // ----------  
        // Four wheels and an engine.  
        // Carries seven people.  
        // ----------  
  
        public static void TestCars3()  
        {  
            System.Console.WriteLine("\nTestCars3");  
            System.Console.WriteLine("----------");  
            ConvertibleCar car2 = new ConvertibleCar();  
            Minivan car3 = new Minivan();  
            car2.ShowDetails();  
            car3.ShowDetails();  
        }  
        // Output:  
        // TestCars3  
        // ----------  
        // A roof that opens up.  
        // Carries seven people.  
  
        public static void TestCars4()  
        {  
            System.Console.WriteLine("\nTestCars4");  
            System.Console.WriteLine("----------");  
            Car car2 = new ConvertibleCar();  
            Car car3 = new Minivan();  
            car2.ShowDetails();  
            car3.ShowDetails();  
        }  
        // Output:  
        // TestCars4  
        // ----------  
        // Standard transportation.  
```

--------------------------------

### Fixing a string instance

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/unsafe-code

Example showing the start of a class definition involving a string instance.

```csharp
class Test
{
    static string name = "xx";
```

--------------------------------

### Raw string interpolation whitespace error

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%207

Example of raw string interpolation that was erroneously allowed in .NET SDK 7.0.100 or earlier.

```C#
var x = $"""
    Hello
{1 + 1}
    World
    """;
```

--------------------------------

### Workaround for struct field initializer error

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%207

This example shows the required fix by adding an explicit constructor to the struct to ensure field initializers are executed.

```csharp
struct S
{
    int X = 1;
    int Y;

    public S() { Y = 0; } // ok
}
```

--------------------------------

### Indexer initialization with interpolated string handlers

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%207

This example demonstrates an invalid scenario where an indexer initializer uses an interpolated string handler that references the instance being indexed, resulting in a compiler error.

```csharp
using System.Runtime.CompilerServices;

// error: Interpolated string handler conversions that reference
// the instance being indexed cannot be used in indexer member initializers.
var c = new C { [$""] = 1 }; 

class C
{
    public int this[[InterpolatedStringHandlerArgument("")] CustomHandler c]
    {
        get => ...;
        set => ...;
    }
}

[InterpolatedStringHandler]
class CustomHandler
{
    // The constructor of the string handler takes a "C" instance:
    public CustomHandler(int literalLength, int formattedCount, C c) {}
}
```

--------------------------------

### Non-negative Length and Count pattern matching

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%207

Example demonstrating how checking for negative 'Count' or 'Length' values in switch expressions or pattern matching now results in a compiler error.

```csharp
string SampleSizeMessage<T>(IList<T> samples)
{
    return samples switch
    {
        // This switch arm prevents a warning before 17.1, but will never happen in practice.
        // Starting with 17.1, this switch arm produces a compiler error.
        // Removing it won't introduce a warning.
        { Count: < 0 }    => throw new InvalidOperationException(),
        { Count:  0 }     => "Empty collection",
        { Count: < 5 }    => "Too small",
        { Count: < 20 }   => "reasonable for the first pass",
        { Count: < 100 }  => "reasonable",
        { Count: >= 100 } => "fine",
    };
}

void M(int[] i)
{
    if (i is { Length: -1 }) {} // error: impossible under assumption of non-negative length
}
```

--------------------------------

### Create the solution and projects via .NET CLI

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/unions

Commands to initialize a solution, a class library, and a console application with preview language features enabled.

```bash
dotnet new sln -n TelemetryMonitor
dotnet new classlib --langVersion preview -n SmartHome.Core
dotnet new console --langVersion preview -n SmartHome.App
dotnet sln add SmartHome.Core SmartHome.App
dotnet add SmartHome.App reference SmartHome.Core
```

--------------------------------

### Example generating CS0154

Source: https://learn.microsoft.com/en-us/dotnet/csharp/misc/cs0154

This example demonstrates the CS0154 error by attempting to access a property 'i' that only defines a 'set' accessor. The error occurs at the line 'int j = myClass2.i;' because the 'get' accessor is missing.

```csharp
// CS0154.cs  
public class MyClass2  
{  
    public int i  
    {  
        set  
        {  
        }  
        // uncomment the get method to resolve this error  
        /*  
        get  
        {  
            return 0;  
        }  
        */  
    }  
}  
  
public class MyClass  
{  
    public static void Main()  
    {  
        MyClass2 myClass2 = new MyClass2();  
        int j = myClass2.i;   // CS0154, no get method  
    }  
}  
```

--------------------------------

### Ref struct escape analysis error examples

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%207

Demonstrates how ref struct return values are restricted when ref or in arguments are passed, resulting in CS8347 errors.

```csharp
ref struct R { }

static R MayCaptureArg(ref int i) => new R();

static R MayCaptureDefaultArg(in int i = 0) => new R();

static R Create()
{
    int i = 0;
    // error CS8347: Cannot use a result of 'MayCaptureArg(ref int)' because it may expose
    // variables referenced by parameter 'i' outside of their declaration scope
    return MayCaptureArg(ref i);
}

static R CreateDefault()
{
    // error CS8347: Cannot use a result of 'MayCaptureDefaultArg(in int)' because it may expose
    // variables referenced by parameter 'i' outside of their declaration scope
    return MayCaptureDefaultArg();
}
```

--------------------------------

### Automatically implemented property

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/get

An example of using an automatically implemented property for simple get and set operations.

```csharp
class TimePeriod3
{
    public double Hours { get; set; }
}
```

--------------------------------

### ModuleInitializer Example Main Class

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general

The main entry point demonstrating the output of module initializers.

```csharp
using System;

internal class ModuleInitializerExampleMain
{
    public static void Main()
    {
        Console.WriteLine(ModuleInitializerExampleModule.Text);
        //output: Hello from Init1! Hello from Init2!
    }
}
```

--------------------------------

### Full example of declaring, instantiating, and using a delegate

Source: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/how-to-declare-instantiate-and-use-a-delegate

Demonstrates using a delegate to process paperback books in a database, separating the database logic from the processing logic.

```csharp
using System;
using System.Collections.Generic;

// A set of classes for handling a bookstore:
namespace Bookstore;

// Describes a book in the book list:
public record struct Book(string Title, string Author, decimal Price, bool Paperback);

// Declare a delegate type for processing a book:
public delegate void ProcessBookCallback(Book book);

// Maintains a book database.
public class BookDB
{
    // List of all books in the database:
    List<Book> list = new();

    // Add a book to the database:
    public void AddBook(string title, string author, decimal price, bool paperBack) =>
        list.Add(new Book(title, author, price, paperBack));

    // Call a passed-in delegate on each paperback book to process it:
    public void ProcessPaperbackBooks(ProcessBookCallback processBook)
    {
        foreach (Book b in list)
        {
            if (b.Paperback)
            {
                // Calling the delegate:
                processBook(b);
            }
        }
    }
}

// Using the Bookstore classes:

// Class to total and average prices of books:
class PriceTotaller
{
    private int countBooks = 0;
    private decimal priceBooks = 0.0m;

    internal void AddBookToTotal(Book book)
    {
        countBooks += 1;
        priceBooks += book.Price;
    }

    internal decimal AveragePrice() => priceBooks / countBooks;
}

// Class to test the book database:
class Test
{
    // Print the title of the book.
    static void PrintTitle(Book b) => Console.WriteLine($"   {b.Title}");

    // Execution starts here.
    static void Main()
    {
        BookDB bookDB = new BookDB();

        // Initialize the database with some books:
        AddBooks(bookDB);

        // Print all the titles of paperbacks:
        Console.WriteLine("Paperback Book Titles:");

        // Create a new delegate object associated with the static
        // method Test.PrintTitle:
        bookDB.ProcessPaperbackBooks(PrintTitle);

        // Get the average price of a paperback by using
        // a PriceTotaller object:
        PriceTotaller totaller = new PriceTotaller();

        // Create a new delegate object associated with the nonstatic
        // method AddBookToTotal on the object totaller:
        bookDB.ProcessPaperbackBooks(totaller.AddBookToTotal);

        Console.WriteLine($"Average Paperback Book Price: ${totaller.AveragePrice():#.##}");
    }

    // Initialize the book database with some test books:
    static void AddBooks(BookDB bookDB)
    {
        bookDB.AddBook("The C Programming Language", "Brian W. Kernighan and Dennis M. Ritchie", 19.95m, true);
        bookDB.AddBook("The Unicode Standard 2.0", "The Unicode Consortium", 39.95m, true);
        bookDB.AddBook("The MS-DOS Encyclopedia", "Ray Duncan", 129.95m, false);
        bookDB.AddBook("Dogbert's Clues for the Clueless", "Scott Adams", 12.00m, true);
    }
}
/* Output:
Paperback Book Titles:
   The C Programming Language
   The Unicode Standard 2.0
   Dogbert's Clues for the Clueless
Average Paperback Book Price: $23.97
*/
```

--------------------------------

### Sample Response File Content

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/miscellaneous

Example content for a response file, where lines starting with # are treated as comments.

```console
# build the first output file
-target:exe -out:MyExe.exe source1.cs source2.cs
```

--------------------------------

### Pointer usage in unsafe contexts

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%207

Pointers must be explicitly marked with the unsafe modifier. Examples show updating a using alias and a method signature.

```csharp
using Alias = List<int*[]>; // should be changed to using unsafe Alias = List<int*[]>;
void Method(Alias a) ... // should be changed to unsafe void Method(Alias a) ...
```

--------------------------------

### Create a new console application

Source: https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/tutorials/nullable-reference-types

Use the .NET CLI to initialize a new console project named NullableIntroduction.

```bash
dotnet new console -n NullableIntroduction
cd NullableIntroduction
```

--------------------------------

### Store tasks for operations

Source: https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming

This example demonstrates storing Task objects for operations when they start, rather than immediately awaiting them.

```csharp
Coffee cup = PourCoffee();
Console.WriteLine("Coffee is ready");

Task<Egg> eggsTask = FryEggsAsync(2);
Egg eggs = await eggsTask;
Console.WriteLine("Eggs are ready");

Task<HashBrown> hashBrownTask = FryHashBrownsAsync(3);
HashBrown hashBrown = await hashBrownTask;
Console.WriteLine("Hash browns are ready");

Task<Toast> toastTask = ToastBreadAsync(2);
Toast toast = await toastTask;
ApplyButter(toast);
ApplyJam(toast);
Console.WriteLine("Toast is ready");

Juice oj = PourOJ();
Console.WriteLine("Oj is ready");
Console.WriteLine("Breakfast is ready!");
```

--------------------------------

### Escaping the 'file' type name

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%207

Starting in C# 11, 'file' is a reserved modifier. Use the '@' prefix to name a type 'file'.

```csharp
class file {} // Error CS9056
class @file {} // No error
```

--------------------------------

### UnmanagedCallersOnly method parameter and return restrictions

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%207

This example shows various method declarations using UnmanagedCallersOnly that are now invalid because they use ref, in, or out modifiers, which are not supported for unmanaged calls.

```csharp
using System.Runtime.InteropServices;
[UnmanagedCallersOnly]
static ref int M1() => throw null; // error CS8977: Cannot use 'ref', 'in', or 'out' in a method attributed with 'UnmanagedCallersOnly'.

[UnmanagedCallersOnly]
static ref readonly int M2() => throw null; // error CS8977: Cannot use 'ref', 'in', or 'out' in a method attributed with 'UnmanagedCallersOnly'.

[UnmanagedCallersOnly]
static void M3(ref int o) => throw null; // error CS8977: Cannot use 'ref', 'in', or 'out' in a method attributed with 'UnmanagedCallersOnly'.

[UnmanagedCallersOnly]
static void M4(in int o) => throw null; // error CS8977: Cannot use 'ref', 'in', or 'out' in a method attributed with 'UnmanagedCallersOnly'.

[UnmanagedCallersOnly]
static void M5(out int o) => throw null; // error CS8977: Cannot use 'ref', 'in', or 'out' in a method attributed with 'UnmanagedCallersOnly'.
```

--------------------------------

### Delegate type inference breaking change in .NET SDK 7.0.200

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%207

Example showing how the new synthesized delegate type inference causes a compilation error when passed to a specific System.Action type.

```C#
void Method(int i = 0, params int[] xs) { }
var action = Method; // delegate void <anonymous delegate>(int arg1 = 0, params int[] arg2)
DoAction(action, 1); // error CS1503: Argument 1: cannot convert from '<anonymous delegate>' to 'System.Action<int, int[]>'
void DoAction(System.Action<int, int[]> a, int p) => a(p, new[] { p });
```

--------------------------------

### Struct field initializer error CS8983

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%207

This example demonstrates the compiler error CS8983 that occurs when a struct contains field initializers but lacks an explicitly declared constructor.

```csharp
struct S // error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
{
    int X = 1; 
    int Y;
}
```

--------------------------------

### Interface indexer declaration

Source: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/indexers/indexers-in-interfaces

An example showing the syntax for declaring an indexer within an interface, including both get and set accessors.

```csharp
public interface ISomeInterface
{
    //...

    // Indexer declaration:
    string this[int index]
    {
        get;
        set;
    }
}
```

--------------------------------

### Run the C# program

Source: https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/tutorials/tuples-and-types

Commands to navigate to the tutorial directory and execute the C# file.

```bash
cd tutorials
dotnet tuples.cs
```

--------------------------------

### Declare an interface property accessor

Source: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/interface-properties

This example demonstrates the syntax for declaring a property with both get and set accessors within an interface.

```csharp
public interface ISampleInterface
{
    // Property declaration:
    string Name
    {
        get;
        set;
    }
}
```

--------------------------------

### Demonstrate Extension Methods

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/extension-members

Example code demonstrating the usage of extension methods and basic arithmetic operations with System.Drawing.Point.

```csharp
using System.Drawing;
using System.Numerics;
using ExtensionMethods;

public static class ExtensionMethodsDemonstrations
{
    public static void TraditionalExtensionMethods()
    {
        OriginAsADataElement();
        ArithmeticWithPoints();
        DiscreteArithmeticWithPoints();
        ExtensionMethodsThis();
        MoreExamples();
    }

    static void OriginAsADataElement()
    {
        // Inline implementation since Point.Origin doesn't exist in ExtensionMethods
        Point origin = Point.Empty; // Equivalent to Point.Origin
        Console.WriteLine($"Point.Origin (inline): {origin}");
        Console.WriteLine($"Same as Point.Empty: {origin == Point.Empty}");
        Console.WriteLine();
    }

    static void ArithmeticWithPoints()
    {
        Point p1 = new Point(5, 3);
        Point p2 = new Point(2, 7);

        Console.WriteLine($"Point 1: {p1}");
        Console.WriteLine($"Point 2: {p2}");
        
        // Inline implementation since + and - operators don't exist in ExtensionMethods
        Point addition = new Point(p1.X + p2.X, p1.Y + p2.Y);
        Point subtraction1 = new Point(p1.X - p2.X, p1.Y - p2.Y);
        Point subtraction2 = new Point(p2.X - p1.X, p2.Y - p1.Y);
        
        Console.WriteLine($"Addition (p1 + p2): {addition}");
        Console.WriteLine($"Subtraction (p1 - p2): {subtraction1}");
        Console.WriteLine($"Subtraction (p2 - p1): {subtraction2}");
        Console.WriteLine();
    }

    static void DiscreteArithmeticWithPoints()
    {
        Point point = new Point(10, 8);
        int offsetX = 3;
        int offsetY = -2;
        int scaleX = 2;
        int scaleY = 3;
        int divisorX = 2;
        int divisorY = 4;

        Console.WriteLine($"Original point: {point}");
        Console.WriteLine($"Offset: ({offsetX}, {offsetY})");
        Console.WriteLine($"Scale: ({scaleX}, {scaleY})");
        Console.WriteLine($"Divisor: ({divisorX}, {divisorY})");
        Console.WriteLine();

        // Inline implementations since tuple operators don't exist in ExtensionMethods
        Point addedOffset = new Point(point.X + offsetX, point.Y + offsetY);
        Point subtractedOffset = new Point(point.X - offsetX, point.Y - offsetY);
        Point scaledPoint = new Point(point.X * scaleX, point.Y * scaleY);
        Point dividedPoint = new Point(point.X / divisorX, point.Y / divisorY);

        Console.WriteLine($"point + offset: {addedOffset}");
        Console.WriteLine($"point - offset: {subtractedOffset}");
        Console.WriteLine($"point * scale: {scaledPoint}");
        Console.WriteLine($"point / divisor: {dividedPoint}");
        Console.WriteLine();
    }
```

--------------------------------

### Example generating CS0596

Source: https://learn.microsoft.com/en-us/dotnet/csharp/misc/cs0596

This code demonstrates the error by applying the ComImport attribute to a class without a corresponding Guid attribute.

```csharp
// CS0596.cs  
using System.Runtime.InteropServices;  
  
namespace x  
{  
   [ComImport]   // CS0596  
   // try the following line to resolve this CS0596  
   // [ComImport, Guid("00000000-0000-0000-0000-000000000001")]  
   public class a  
   {  
   }  
  
   public class b  
   {  
      public static void Main()  
      {  
      }  
   }  
}  
```

--------------------------------

### Define a property with set accessor

Source: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/using-properties

Example of a Student class with a private backing field and a property using both get and set accessors.

```csharp
class Student
{
    private string _name;      // the name field
    public string Name         // the Name property
    {
        get => _name;
        set => _name = value;
    }
}
```

--------------------------------

### Instantiate FileLogger

Source: https://learn.microsoft.com/en-us/dotnet/csharp/delegates-patterns

Shows how to instantiate the FileLogger to begin logging to a specified file.

```csharp
var file = new FileLogger("log.txt");
```

--------------------------------

### CLI command examples

Source: https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/tutorials/system-command-line

Demonstrates the expected command-line interface usage for the task tracker application.

```console
dotnet TaskCli.cs -- add "Write documentation" --priority High --due 2026-04-01
dotnet TaskCli.cs -- list --all
dotnet TaskCli.cs -- complete 3
dotnet TaskCli.cs -- remove 3
dotnet TaskCli.cs -- --verbose list

```

--------------------------------

### Restricting set accessor accessibility

Source: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/restricting-accessor-accessibility

This example demonstrates a property where the get accessor is public, but the set accessor is restricted to protected access.

```csharp
private string _name = "Hello";

public string Name
{
    get
    {
        return _name;
    }
    protected set
    {
        _name = value;
    }
}
```

--------------------------------

### Configure StartupObject

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/advanced

Specifies the class containing the entry point when multiple Main methods exist in a project. The class name must be fully qualified.

```xml
<StartupObject>MyNamespace.Program</StartupObject>
```

--------------------------------

### Create a C/C++ style union with StructLayout

Source: https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/reflection-and-attributes/how-to-create-a-c-cpp-union-by-using-attributes

This example demonstrates a struct where all fields start at the same memory offset, effectively creating a union.

```csharp
[System.Runtime.InteropServices.StructLayout(LayoutKind.Explicit)]
struct TestUnion
{
    [System.Runtime.InteropServices.FieldOffset(0)]
    public int i;

    [System.Runtime.InteropServices.FieldOffset(0)]
    public double d;

    [System.Runtime.InteropServices.FieldOffset(0)]
    public char c;

    [System.Runtime.InteropServices.FieldOffset(0)]
    public byte b;
}
```

--------------------------------

### Program.cs entry point

Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/extension-members

The code to replace in Program.cs to execute the demonstration.

```csharp
ExtensionMethodsDemonstrations.TraditionalExtensionMethods();
```

--------------------------------

### Create a new console application using .NET CLI

Source: https://learn.microsoft.com/en-us/dotnet/csharp/linq/get-started/walkthrough-writing-queries-linq

Use this command to initialize a new C# console project named WalkthroughWritingLinqQueries.

```bash
dotnet new console -o WalkthroughWritingLinqQueries
```

--------------------------------

### Generating CS3008 Warning

Source: https://learn.microsoft.com/en-us/dotnet/csharp/misc/cs3008

This example demonstrates a public static field starting with an underscore, which triggers the CS3008 warning when the assembly is marked as CLS-compliant.

```csharp
// CS3008.cs  
  
using System;  
  
[assembly:CLSCompliant(true)]  
public class a  
{  
    public static int _a = 0;  // CS3008  
    // OK, private  
    // private static int _a1 = 0;  
  
    public static void Main()  
    {  
    }  
}  
```

--------------------------------

### Example generating CS8146

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/cs8146

This code sample triggers CS8146 because the property 'Number' uses an init accessor instead of a get accessor while returning by reference.

```csharp
// CS8146.cs (5,18)

public class C
{
    private ref int number;

    private ref int Number { init => number = value; }
}
```

--------------------------------

### Example application output

Source: https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/cancel-an-async-task-or-a-list-of-tasks

Sample console output showing the application processing URLs and responding to a cancellation request.

```text
Application started.
Press the ENTER key to cancel...

https://learn.microsoft.com                                       37,357
https://learn.microsoft.com/aspnet/core                           85,589
https://learn.microsoft.com/azure                                398,939
https://learn.microsoft.com/azure/devops                          73,663
https://learn.microsoft.com/dotnet                                67,452
https://learn.microsoft.com/dynamics365                           48,582
https://learn.microsoft.com/education                             22,924

ENTER key pressed: cancelling downloads.

Application ending.
```

--------------------------------

### Using StartsWith and EndsWith string methods

Source: https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/tutorials/hello-world

This example demonstrates how to check if a string starts or ends with specific substrings using the StartsWith and EndsWith methods.

```csharp
string songLyrics = "You say goodbye, and I say hello";
Console.WriteLine(songLyrics.StartsWith("You"));
Console.WriteLine(songLyrics.StartsWith("goodbye"));

Console.WriteLine(songLyrics.EndsWith("hello"));
Console.WriteLine(songLyrics.EndsWith("goodbye"));
```

--------------------------------

### Implement range checking with field keyword

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/field

This example demonstrates using the 'field' keyword in a 'set' accessor to validate that the value is non-negative, while keeping the 'get' accessor automatically implemented.

```csharp
class TimePeriod4
{
    public double Hours {
        get;
        set => field = (value >= 0)
            ? value
            : throw new ArgumentOutOfRangeException(nameof(value), "The value must not be negative");
    }
}
```

--------------------------------

### Implementing Collection Initializers with Add and Indexers

Source: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/object-and-collection-initializers

This example demonstrates a custom dictionary class that supports collection initialization using both Add methods with params and indexer syntax.

```csharp
public class DictionaryExample
{
    class RudimentaryMultiValuedDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, List<TValue>>> where TKey : notnull
    {
        private Dictionary<TKey, List<TValue>> internalDictionary = new Dictionary<TKey, List<TValue>>();

        public IEnumerator<KeyValuePair<TKey, List<TValue>>> GetEnumerator() => internalDictionary.GetEnumerator();

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => internalDictionary.GetEnumerator();

        public List<TValue> this[TKey key]
        {
            get => internalDictionary[key];
            set => Add(key, value);
        }

        public void Add(TKey key, params TValue[] values) => Add(key, (IEnumerable<TValue>)values);

        public void Add(TKey key, IEnumerable<TValue> values)
        {
            if (!internalDictionary.TryGetValue(key, out List<TValue>? storedValues))
            {
                internalDictionary.Add(key, storedValues = new());
            }
            storedValues.AddRange(values);
        }
    }

    public static void Main()
    {
        RudimentaryMultiValuedDictionary<string, string> rudimentaryMultiValuedDictionary1
            = new RudimentaryMultiValuedDictionary<string, string>()
            {
                {"Group1", "Bob", "John", "Mary" },
                {"Group2", "Eric", "Emily", "Debbie", "Jesse" }
            };
        RudimentaryMultiValuedDictionary<string, string> rudimentaryMultiValuedDictionary2
            = new RudimentaryMultiValuedDictionary<string, string>()
            {
                ["Group1"] = new List<string>() { "Bob", "John", "Mary" },
                ["Group2"] = new List<string>() { "Eric", "Emily", "Debbie", "Jesse" }
            };
        RudimentaryMultiValuedDictionary<string, string> rudimentaryMultiValuedDictionary3
            = new RudimentaryMultiValuedDictionary<string, string>()
            {
                {"Group1", new string []{ "Bob", "John", "Mary" } },
                { "Group2", new string[]{ "Eric", "Emily", "Debbie", "Jesse" } }
            };

        Console.WriteLine("Using first multi-valued dictionary created with a collection initializer:");

        foreach (KeyValuePair<string, List<string>> group in rudimentaryMultiValuedDictionary1)
        {
            Console.WriteLine($"\r\nMembers of group {group.Key}: ");

            foreach (string member in group.Value)
            {
                Console.WriteLine(member);
            }
        }

        Console.WriteLine("\r\nUsing second multi-valued dictionary created with a collection initializer using indexing:");

        foreach (KeyValuePair<string, List<string>> group in rudimentaryMultiValuedDictionary2)
        {
            Console.WriteLine($"\r\nMembers of group {group.Key}: ");

            foreach (string member in group.Value)
            {
                Console.WriteLine(member);
            }
        }
        Console.WriteLine("\r\nUsing third multi-valued dictionary created with a collection initializer using indexing:");

        foreach (KeyValuePair<string, List<string>> group in rudimentaryMultiValuedDictionary3)
        {
            Console.WriteLine($"\r\nMembers of group {group.Key}: ");

            foreach (string member in group.Value)
            {
                Console.WriteLine(member);
            }
        }
    }

    /*
        * Prints:

        Using first multi-valued dictionary created with a collection initializer:

        Members of group Group1:
        Bob
        John
        Mary

        Members of group Group2:
        Eric
        Emily
        Debbie
        Jesse

        Using second multi-valued dictionary created with a collection initializer using indexing:

        Members of group Group1:
        Bob
        John
        Mary

        Members of group Group2:
        Eric
        Emily
        Debbie
        Jesse

        Using third multi-valued dictionary created with a collection initializer using indexing:

        Members of group Group1:
        Bob
        John
        Mary

        Members of group Group2:
        Eric
        Emily
        Debbie
        Jesse
        */
}
```

--------------------------------

### Declaring and using read/write properties in a Person class

Source: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/how-to-declare-and-use-read-write-properties

This example demonstrates a Person class with Name and Age properties using get and set accessors, along with a TestPerson class to manipulate these properties.

```csharp
class Person
{
    private string _name = "N/A";
    private int _age = 0;

    // Declare a Name property of type string:
    public string Name
    {
        get
        {
            return _name;
        }
        set
        {
            _name = value;
        }
    }

    // Declare an Age property of type int:
    public int Age
    {
        get
        {
            return _age;
        }

        set
        {
            _age = value;
        }
    }

    public override string ToString()
    {
        return "Name = " + Name + ", Age = " + Age;
    }
}

public class Wrapper
{
    private string _name = "N/A";
    public string Name
    {
        get
        {
            return _name;
        }
        private set
        {
            _name = value;
        }
    }

}

class TestPerson
{
    static void Main()
    {
        // Create a new Person object:
        Person person = new Person();

        // Print out the name and the age associated with the person:
        Console.WriteLine($"Person details - {person}");

        // Set some values on the person object:
        person.Name = "Joe";
        person.Age = 99;
        Console.WriteLine($"Person details - {person}");

        // Increment the Age property:
        person.Age += 1;
        Console.WriteLine($"Person details - {person}");

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    Person details - Name = N/A, Age = 0
    Person details - Name = Joe, Age = 99
    Person details - Name = Joe, Age = 100
*/
```

--------------------------------

### Group clause example

Source: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/expressions

Example of translating a group clause.

```C#
from c in customers
group c.Name by c.Country
```

```C#
(customers).GroupBy(c => c.Country, c => c.Name)
```

--------------------------------

### Run the Application

Source: https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/tutorials/nullable-reference-types

Executes the application using the .NET CLI.

```bash
dotnet run
```
Tokens:
Raw