Whats's New in .NET Core 10 and C# 14

Introduction

With the release of .NET 10 and C# 14, developers are gaining access to a host of modern features that enhance performance, security, and developer productivity. These updates bring meaningful improvements across the entire .NET ecosystem—from deeper span-based performance optimizations in the base libraries to smarter serialization in web APIs and language enhancements that make your code cleaner and more expressive.

C# 14 Language Enhancements

C# 14 introduces several powerful language features focused on performance, flexibility, and developer convenience. Here are the key updates:

Implicit Span Conversions

C# 14 offers first-class support for the System.Span<T> and System.ReadOnlySpan<T>. These types are designed for high-performance, memory-safe manipulation of contiguous data. C# 14 introduces implicit conversions between.

• T[ ] → Span<T>
• T[ ] → ReadOnlySpan<T>
• Span<T> → ReadOnlySpan<T>

This means you can now write APIs that accept spans and call them with arrays, reducing the need for explicit casts and avoiding unnecessary allocations.

void Print(ReadOnlySpan<char> data)
{
    foreach (var ch in data)
        Console.Write(ch);
    Console.WriteLine();
}

char[] buffer = { 'H', 'e', 'l', 'l', 'o' };
// Implicitly converts char[] to ReadOnlySpan<char>
Print(buffer);

C#

Copy

Benefits

• Zero allocations
• Type safety
• Improved performance for memory-intensive operations

Unbound Generic Types in the nameof

Before C# 14, you could only use closed generic types with nameof, such as nameof(List<int>). With C# 14, you can now reference unbound generics in the nameof, enabling cleaner and more flexible metadata or logging scenarios.

Console.WriteLine(nameof(Dictionary<,>));
Console.WriteLine(nameof(List<>));

C#

Copy

Output

• Dictionary
• List

Simple Lambda Parameters with Modifiers

C# 14 allows you to use modifiers like ref, out, in, scoped, and ref readonly in lambda parameters, even without specifying the type. Previously, you had to provide full-type declarations to use modifiers.

delegate bool TryParse<T>(string text, out T result);
private static void LambdaParameterModifiersExample()
{
  TryParse<int> tryParse = (text, out result) => int.TryParse(text, out result);

  if (tryParse("123", out var num))
  Console.WriteLine($"Parsed: {num}");
  else
  Console.WriteLine("Failed to parse");
}

C#

Copy

Benefits

• Cleaner syntax
• Better support for modern API design
• Enhanced lambda expressiveness

.NET 10 Library Enhancements

.NET 10 introduces powerful enhancements to its base-class libraries. Here's a breakdown of the most impactful additions.

Finding Certificates by Thumbprint (SHA-2 & SHA-3)

Before .NET 10: Only SHA-1 hash thumbprints were supported, limiting security standards. Now, you can use secure hashing algorithms like SHA-256 or SHA-3 directly.

X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly);

string thumbprint = "ABCD1234...";
X509Certificate2Collection certs = store.Certificates.FindByThumbprint(HashAlgorithmName.SHA256, thumbprint);

if (certs.Count == 1)
{
    Console.WriteLine("Certificate found: " + certs[0].Subject);
}

C#

Copy

Benefits: Stronger certificate validation in secure systems.

Improved PEM File Parsing (UTF-8)

Initially, manual encoding conversion was needed to read UTF-8 PEM files. Now, Native support for UTF-8 parsing simplifies the process.

byte[] pemData = File.ReadAllBytes("key.pem");
PemFields pemFields = PemEncoding.FindUtf8(pemData);
string label = Encoding.UTF8.GetString(pemData[pemFields.Label]);
byte[] keyData = Convert.FromBase64String(Encoding.UTF8.GetString(pemData[pemFields.Base64Data]));

C#

Copy

Benefits: Faster, cleaner handling of standard security file formats.

Numeric String Comparison

Earlier, strings sorted lexically, so "File10" came before "File2". Now, natural numeric ordering is built-in.

var versions = new[] { "File1", "File10", "File2" };
Array.Sort(versions, StringComparer.Create(CultureInfo.InvariantCulture, CompareOptions.NumericString));

Console.WriteLine(string.Join(", ", versions)); // File1, File2, File10

C#

Copy

Benefits: Sorting UI lists, filenames, and version numbers.

TimeSpan.FromMilliseconds Overloads

Earlier, Ambiguity with LINQ and long arrays. Now, cleaner LINQ integration.

long[] delays = { 200, 400, 800 };
var spans = delays.Select(TimeSpan.FromMilliseconds);

foreach (var span in spans)
    Console.WriteLine(span);

C#

Copy

Benefits: Simplifies time-related functional code.

OrderedDictionary Enhancements

Earlier, limited index handling APIs. Now, you can update values directly using index-aware methods.

var counts = new OrderedDictionary<string, int>();
if (!counts.TryAdd("bananas", 1, out int idx))
{
    counts.SetAt(idx, counts.GetAt(idx).Value + 1);
}
Console.WriteLine(counts.GetAt(0));

C#

Copy

Benefits: Frequency tracking, ordered logs, quick updates.

ReferenceHandler Support in JSON Source Generators

Earlier, serializing object graphs with cycles caused stack overflows. Now, the Preserve option supports circular references.

public class Category
{
    public string Name { get; set; }
    public Category? Parent { get; set; }
}
[JsonSourceGenerationOptions(ReferenceHandler = JsonKnownReferenceHandler.Preserve)]
[JsonSerializable(typeof(Category))]
internal partial class JsonCtx : JsonSerializerContext { }
var node = new Category { Name = "Root" };
node.Parent = node;
string output = JsonSerializer.Serialize(node, JsonCtx.Default.Category);
Console.WriteLine(output);

C#

Copy

Benefits: Enables safe serialization for complex graphs.

Wrapping Up

The combination of C# 14 and the new base library capabilities in .NET 10 presents a compelling platform for modern developers. With enhancements in API design, runtime performance, and language expressiveness, this release solidifies .NET as a top-tier development framework. I have added one demo project with the article. Please feel free to explore that as well.

Thank You, and Stay Tuned for More!

Reference

• What's new in .NET 10

More Articles from my Account

• Migrate Azure Function from In-Process to Isolation Model
• Server-to-Server Authentication in Zoom Using .NET Core
• Authenticate .NET Applications With Azure Services
• How to Create an App Configuration Store