|
| 1 | +--- |
| 2 | +title: C#14:New Features Explained |
| 3 | +date: 2025-12-19 |
| 4 | +category: Unity |
| 5 | +description: An easy-to-understand, example-driven explanation of notable features introduced in C# 14. |
| 6 | +tags: [unity, csharp] |
| 7 | +recommended: true |
| 8 | +thumbnail: assets/img/csharp_icon.png |
| 9 | +--- |
| 10 | + |
| 11 | +Hello! I'm Pan-kun. |
| 12 | + |
| 13 | +This time I'd like to pick up and introduce several features from the C# 14 documentation that was published at the end of last month. |
| 14 | +Official reference: |
| 15 | +[!CARD](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-14) |
| 16 | + |
| 17 | +## C# 14 — New Features |
| 18 | + |
| 19 | +### The `field` keyword |
| 20 | + |
| 21 | +Many developers commonly use fields and properties in patterns like the following. The main purpose, as you know, is encapsulation. With this new feature, you can now write: |
| 22 | + |
| 23 | +```csharp |
| 24 | +// before |
| 25 | +private string m_foo; |
| 26 | +public string Foo |
| 27 | +{ |
| 28 | + get => m_foo; |
| 29 | + private set => m_foo = value; |
| 30 | + // If you wanted to add a null check: |
| 31 | + // ?? throw new ArgumentNullException(nameof(value)) |
| 32 | +} |
| 33 | + |
| 34 | +// after |
| 35 | +public string Foo |
| 36 | +{ |
| 37 | + get; |
| 38 | + set => field = value; |
| 39 | +} |
| 40 | +``` |
| 41 | + |
| 42 | +For developers using an IDE with IntelliSense, many type `m_` and rely on completion, so whether this is helpful depends on coding style. If you group members with regions or care about explicit naming for readability, you might prefer the traditional pattern. For teams with well-defined coding conventions, choose whichever fits your workflow. |
| 43 | + |
| 44 | +The docs also explain how to handle naming conflicts with existing symbols named `field`. However, if you find a symbol actually named `field` in a codebase, consider running `git blame` to see who added it and proceed cautiously. |
| 45 | + |
| 46 | +> Reading code of a type that contains a symbol named `field` can cause breaking changes or confusion. |
| 47 | +> You can disambiguate between the `field` keyword and an identifier by using `@field` or `this.field`, or rename the current `field` symbol to make distinctions clearer. |
| 48 | +
|
| 49 | +[!CARD](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-14#the-field-keyword) |
| 50 | + |
| 51 | +### Extension members |
| 52 | + |
| 53 | +This is the feature related to the familiar `this ClassName valueName` extension-method parameter syntax. |
| 54 | + |
| 55 | +```csharp |
| 56 | +public class Foo |
| 57 | +{ |
| 58 | + public int hoge = 1; |
| 59 | +} |
| 60 | + |
| 61 | +// before |
| 62 | +public static class FooExtensions |
| 63 | +{ |
| 64 | + public static int BeforeExtension(this Foo foo) => foo.hoge; |
| 65 | +} |
| 66 | + |
| 67 | +// after |
| 68 | +public static class FooExtensions |
| 69 | +{ |
| 70 | + extension(Foo foo) |
| 71 | + { |
| 72 | + public int AfterExtension() => foo.hoge; |
| 73 | + } |
| 74 | +} |
| 75 | +``` |
| 76 | + |
| 77 | +Benefits: |
| 78 | + |
| 79 | +- You no longer need to explicitly declare the instance parameter for each extension member. |
| 80 | +- Placing members inside an `extension` block makes the code visually clearer. |
| 81 | +- You can declare extension properties. |
| 82 | +- You can also declare extension operators. |
| 83 | + |
| 84 | +For more details, see the official docs: |
| 85 | +[!CARD](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-14#extension-members) |
| 86 | + |
| 87 | +### Null-conditional assignment |
| 88 | + |
| 89 | +```csharp |
| 90 | +public class Hoge |
| 91 | +{ |
| 92 | + public string? Name { get; set; } = null; |
| 93 | +} |
| 94 | + |
| 95 | +string GetName() => "Pankun"; |
| 96 | + |
| 97 | +void Foo(Hoge? hoge) |
| 98 | +{ |
| 99 | + // before |
| 100 | + if (hoge is not null) // Null check can be simplified (IDE0031) |
| 101 | + hoge.Name = GetName(); |
| 102 | + |
| 103 | + // after |
| 104 | + hoge?.Name = GetName(); |
| 105 | +} |
| 106 | +``` |
| 107 | + |
| 108 | +Benefits: |
| 109 | + |
| 110 | +- Reduces nesting. |
| 111 | +- Improves readability. |
| 112 | + |
| 113 | +### Partial members |
| 114 | + |
| 115 | +```csharp |
| 116 | +// Foo.cs |
| 117 | +public partial class Foo |
| 118 | +{ |
| 119 | + // constructor implementation |
| 120 | + public partial Foo() |
| 121 | + { |
| 122 | + Hoge(); |
| 123 | + } |
| 124 | + |
| 125 | + // add member implementation |
| 126 | + private partial void Hoge() => Console.WriteLine("Partial Hoge"); |
| 127 | +} |
| 128 | + |
| 129 | +// Foo.members.cs |
| 130 | +public partial class Foo |
| 131 | +{ |
| 132 | + // You can add declarations here: |
| 133 | + // constructor declaration |
| 134 | + // static is not supported |
| 135 | + public partial Foo(); // Success |
| 136 | + private partial void Hoge(); // Success |
| 137 | +} |
| 138 | +``` |
| 139 | + |
| 140 | +This helps avoid the "How is this call valid when there's no definition here?" confusion. |
| 141 | + |
| 142 | +### nameof support for unbound generic types |
| 143 | + |
| 144 | +```csharp |
| 145 | +public static void ShowExample() |
| 146 | +{ |
| 147 | + // Before |
| 148 | + Console.WriteLine(nameof(List<int>)); // List<int> |
| 149 | + |
| 150 | + // After |
| 151 | + // The argument to nameof can be an unbound generic type. |
| 152 | + Console.WriteLine(nameof(List<>)); // List |
| 153 | + // NOTE: Use unbound generic type (IDE0340) |
| 154 | + Console.WriteLine(nameof(List<int>)); // List<int> |
| 155 | +} |
| 156 | +``` |
| 157 | + |
| 158 | +This allows broader kinds of name-based checks. (I also learned that a generic type without its type arguments specified is called an "unbound generic type".) |
| 159 | + |
| 160 | +## .NET 10 |
| 161 | + |
| 162 | +There are other features added in C# 14, but .NET also received several improvements recently, so I'll briefly touch on one of them. |
| 163 | + |
| 164 | +For details, see: |
| 165 | +[!CARD](https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-10/overview) |
| 166 | + |
| 167 | +### Shebang |
| 168 | + |
| 169 | +You can now add a shebang to run a file as a script. This eliminates the need to create a project or write a Main method for quick scripts. |
| 170 | + |
| 171 | +```csharp |
| 172 | +#!/usr/bin/env -S dotnet run |
| 173 | +Console.WriteLine("Hoge"); |
| 174 | +``` |
| 175 | + |
| 176 | +I also heard there were improvements in Blazor. |
| 177 | + |
| 178 | +## Conclusion |
| 179 | + |
| 180 | +Although still in preview, these features seem quite promising for private and experimental coding. I expect to use many of them frequently — give them a try! |
0 commit comments