.NET Core Information & C# Evolution

Classes and Objects

Basic object-oriented programming foundation

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Inheritance

Single inheritance with base classes

public class Employee : Person
{
    public decimal Salary { get; set; }
}

Properties and Methods

Encapsulation with getters and setters

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

Interfaces

Contract-based programming

public interface IDrawable
{
    void Draw();
}

Generics

Type-safe collections and methods

List<string> names = new List<string>();
Dictionary<int, string> lookup = new Dictionary<int, string>();

Partial Classes

Split class definition across multiple files

// File1.cs
public partial class MyClass
{
    public void Method1() { }
}

// File2.cs
public partial class MyClass
{
    public void Method2() { }
}

Nullable Types

Value types that can be null

int? nullableInt = null;
if (nullableInt.HasValue)
{
    Console.WriteLine(nullableInt.Value);
}

Anonymous Methods

Inline method definitions

button.Click += delegate { 
    MessageBox.Show("Clicked!"); 
};

LINQ

Language Integrated Query

var adults = people.Where(p => p.Age >= 18)
                  .OrderBy(p => p.Name)
                  .Select(p => p.Name);

Lambda Expressions

Concise anonymous functions

var numbers = new[] { 1, 2, 3, 4, 5 };
var evens = numbers.Where(x => x % 2 == 0);

var Keyword

Type inference for local variables

var name = "John"; // string
var age = 25;      // int
var list = new List<string>();

Object Initializers

Initialize objects with property syntax

var person = new Person 
{ 
    Name = "John", 
    Age = 25 
};

Dynamic Type

Runtime type resolution

dynamic obj = GetObject();
obj.SomeMethod(); // Resolved at runtime

Optional Parameters

Default parameter values

public void Method(string name, int age = 0)
{
    // age is optional with default value 0
}

Named Arguments

Specify parameters by name

Method(age: 25, name: "John");

Generic Variance

Covariance and contravariance

IEnumerable<string> strings = new List<string>();
IEnumerable<object> objects = strings; // Covariant

async/await

Asynchronous programming made simple

public async Task<string> GetDataAsync()
{
    var data = await httpClient.GetStringAsync(url);
    return data;
}

Caller Information

Automatic caller information attributes

public void Log(string message,
    [CallerMemberName] string member = "",
    [CallerFilePath] string file = "",
    [CallerLineNumber] int line = 0)

Async Main

Main method can be async

static async Task Main(string[] args)
{
    await DoWorkAsync();
}

String Interpolation

Embed expressions in strings

var message = $"Hello {name}, you are {age} years old";

Null-Conditional Operators

Safe navigation with ?. and ?[]

var length = person?.Name?.Length ?? 0;
var firstItem = list?[0];

Expression-Bodied Members

Concise method and property syntax

public string FullName => $"{FirstName} {LastName}";
public int GetAge() => DateTime.Now.Year - BirthYear;

nameof Operator

Get string representation of identifiers

throw new ArgumentNullException(nameof(parameter));

Tuples

Lightweight data structures

var person = (Name: "John", Age: 25);
var (name, age) = person;

Pattern Matching

Type and value pattern matching

switch (obj)
{
    case string s when s.Length > 0:
        return s.ToUpper();
    case int i:
        return i.ToString();
    default:
        return "Unknown";
}

Local Functions

Functions defined inside other functions

public int Calculate(int x, int y)
{
    return Add(x, y);
    
    int Add(int a, int b) => a + b;
}

out Variables

Declare out variables inline

if (int.TryParse(input, out int result))
{
    Console.WriteLine(result);
}

Records

Immutable data types with value-based equality

public record Person(string FirstName, string LastName)
{
    public string FullName => $"{FirstName} {LastName}";
}

Init-Only Properties

Properties that can only be set during initialization

public class Person
{
    public string Name { get; init; }
    public int Age { get; init; }
}

Pattern Matching Enhancements

Relational patterns and logical patterns

var grade = score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    _ => "F"
};

Target-Typed new Expressions

Type inference for new expressions

List<string> list = new();
Dictionary<string, int> dict = new();

File-Scoped Namespaces

Eliminate namespace indentation for entire files

namespace MyApp.Services;

public class UserService
{
    // No indentation needed
}

Global Using Statements

Common using statements applied globally

// GlobalUsings.cs
global using System;
global using System.Collections.Generic;

Record Structs

Value-type records for better performance

public record struct Point(int X, int Y)
{
    public double Distance => Math.Sqrt(X * X + Y * Y);
}

Improved Interpolated Strings

Better performance and constant string interpolation

const string format = $"Hello {name}!"; // Compile-time constant

Raw String Literals

Multi-line strings without escape sequences

var json = """
{
    "name": "John",
    "age": 30,
    "city": "New York"
}
""";

Required Members

Ensure properties are initialized

public class Person
{
    public required string Name { get; set; }
    public required int Age { get; set; }
}

Generic Math

Generic constraints for numeric types

public static T Add<T>(T a, T b) where T : INumber<T>
{
    return a + b;
}

List Patterns

Pattern matching for lists and arrays

var result = list switch
{
    [var first, ..] => first,
    [] => 0,
    _ => -1
};

Primary Constructors

Concise constructor syntax for classes and structs

public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; } = age;
}

Collection Expressions

Unified syntax for creating collections

int[] numbers = [1, 2, 3, 4, 5];
List<string> names = ["Alice", "Bob", "Charlie"];

Alias Any Type

Create aliases for any type, not just namespaces

using Point = (int X, int Y);
using StringList = List<string>;

Lambda Expression Improvements

Better type inference and optional parameters

var process = (string input, int count = 1) => 
    input.Repeat(count);