A Simple Analogy

.NET 8 is like a car getting better brakes, faster engine, and smoother ride. All the parts work together for better performance and developer experience.

---

Key Features

| Feature | Benefit | |---------|---------| | Native AOT | Publish as native executable | | Performance | 15-20% faster than .NET 7 | | AI Integration | Built-in support for LLMs | | MAUI | Mature cross-platform UI | | Entity Framework | JSON columns, better queries |

---

Collection Expressions

// Old way
var numbers = new List<int> { 1, 2, 3, 4, 5 };
var array = numbers.ToArray();

// .NET 8 way
int[] array = [1, 2, 3, 4, 5];

// Spread operator
int[] array1 = [1, 2, 3];
int[] array2 = [0, ..array1, 4, 5];  // [0, 1, 2, 3, 4, 5]

// Works with collections too
List<int> list = [1, 2, 3];
Dictionary<string, int> dict = [("a", 1), ("b", 2)];

---

Primary Constructors

// Old way
public class Order
{
    public string OrderId { get; }
    public string CustomerId { get; }
    
    public Order(string orderId, string customerId)
    {
        OrderId = orderId;
        CustomerId = customerId;
    }
}

// .NET 8 way
public class Order(string OrderId, string CustomerId)
{
    // OrderId and CustomerId automatically created as properties
}

// With validation
public class Order(string orderId, string customerId)
{
    public string OrderId
    {
        get => _orderId;
        init
        {
            ArgumentException.ThrowIfNullOrEmpty(value);
            _orderId = value;
        }
    }
    
    private string _orderId = orderId;
}

---

Native AOT

// Publish as native executable
// dotnet publish -c Release -r win-x64 -p:PublishAot=true

// Results in single .exe (no .NET runtime needed!)
// Startup: 5-50ms (vs 500ms+ with JIT)
// Size: 30-40MB (vs 200+ with dependencies)

var app = builder.Build();

// Must be AOT-compatible (no reflection at runtime)
app.MapGet("/api/hello", () => new { Message = "Hello, World!" })
    .WithOpenApi();

app.Run();

---

Performance Improvements

// SIMD improvements
using System.Runtime.Intrinsics;

public class VectorMath
{
    public static void MultiplyVectors(float[] a, float[] b, float[] result)
    {
        for (int i = 0; i < a.Length; i += Vector256<float>.Count)
        {
            var va = Vector256.Create(a, i);
            var vb = Vector256.Create(b, i);
            var vc = va * vb;
            vc.Store(result, i);
        }
    }
}

// UTF-8 improvements
string myString = "Hello";
Utf8String utf8 = new Utf8String(myString);  // More efficient

---

AI/OpenAI Integration

// Using new AI libraries
using OpenAI;

var client = new OpenAIClient("your-api-key");

var message = await client.GetChatCompletionsAsync(
    "gpt-4",
    new ChatCompletionsOptions
    {
        Messages =
        {
            new ChatMessage(ChatRole.User, "What is async/await in C#?")
        }
    });

Console.WriteLine(message.Value.Choices[0].Message.Content);

---

C# 12 Features

// Property patterns
public bool IsAdult(Person person) => person is { Age: >= 18 };

// Inline arrays
[System.Runtime.CompilerServices.InlineArray(10)]
public struct Buffer
{
    private int _element0;
}

var buffer = new Buffer();
buffer[0] = 1;
buffer[9] = 10;

// Lambdas with default parameters
Func<int, int> square = (int x = 5) => x * x;
Console.WriteLine(square());  // 25

---

Best Practices

1. Update carefully: Review breaking changes
2. Use new features: Improve code clarity
3. Test AOT: If using Native AOT
4. Performance tune: Take advantage of improvements
5. Upgrade dependencies: Ensure compatibility

---

Related Concepts

• C# language features
• Performance optimization
• Cloud-native development
• Microservices with .NET 8

---

Summary

.NET 8 brings significant performance improvements, new language features, and AI integration. Adopt features that improve code clarity while maintaining compatibility.