public class Person
{public string FirstName { get; set; }public string LastName { get; set; }public DateTime Birthday { get; set; }
}

如果我们要强制所有属性为可选属性怎么办？好吧，实际上从某种意义上讲，它们已经没有人强迫我们设置它们了。但是，让我们假设已经在本文中介绍了可空类型（它们将在以后介绍），我们所追求的是：

public class PartialPerson
{public string? FirstName { get; set; }public string? LastName { get; set; }public DateTime? Birthday { get; set; }
}

现在我们有一个问题。当第一个类更改后，我们还需要对第二个类进行一些更改。如果我们可以改成这样的话该怎么样：

public type PartialPerson = Partial<Person>;

这实际上就是TypeScript的工作方式。在TypeScript中，Partial<T>只是用于迭代所有属性并在每个属性上放置一个可选（?）的别名。

var PartialPersonType = Partial<Person>();

其中，Partial方法可以用更直接的方式实现。

public static Type Partial<T>()
{var type = typeof(T);var builder = GetTypeBuilder<T>();foreach (var property in type.GetProperties()){CreateProperty(builder, property);}return builder.CreateType();
}private static TypeBuilder GetTypeBuilder<T>()
{var name = $"Partial<{typeof(T).Name}>";var an = new AssemblyName(name);var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);var moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");return moduleBuilder.DefineType(name,TypeAttributes.Public |TypeAttributes.Class |TypeAttributes.AutoClass |TypeAttributes.AnsiClass |TypeAttributes.BeforeFieldInit |TypeAttributes.AutoLayout,null);
}private static void CreateProperty(TypeBuilder tb, PropertyInfo property, string? ignore = null)
{var propertyName = property.Name;var propertyType = property.PropertyType;var attributes = property.Attributes;var customAttributes = property.CustomAttributes;var addNullable = false;if (propertyType.IsInterface || propertyType.IsClass){// we require the custom attributeaddNullable = true;}else if (propertyType.IsValueType && (!propertyType.IsGenericType || propertyType.GetGenericTypeDefinition() != typeof(Nullable<>))){// for values there is no attribute but the Nullable type// we only apply it if its not yet wrapped in such a typepropertyType = typeof(Nullable<>).MakeGenericType(propertyType);}var fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);var propertyBuilder = tb.DefineProperty(propertyName, attributes, propertyType, null);foreach (var customAttribute in customAttributes){// Append all custom attributes (as beforehand) except the Nullable oneif (customAttribute.Constructor.ReflectedType.Name != "NullableAttribute"){AppendAttribute(customAttribute, propertyBuilder);}}// if the nullable attribute should be added we can abuse some magic ...if (addNullable){var customAttribute = MethodBase.GetCurrentMethod().GetParameters().Last().CustomAttributes.Last();AppendAttribute(customAttribute, propertyBuilder);}var getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);var getIl = getPropMthdBldr.GetILGenerator();getIl.Emit(OpCodes.Ldarg_0);getIl.Emit(OpCodes.Ldfld, fieldBuilder);getIl.Emit(OpCodes.Ret);var setPropMthdBldr = tb.DefineMethod("set_" + propertyName,MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,null, new[] { propertyType });var setIl = setPropMthdBldr.GetILGenerator();var modifyProperty = setIl.DefineLabel();var exitSet = setIl.DefineLabel();setIl.MarkLabel(modifyProperty);setIl.Emit(OpCodes.Ldarg_0);setIl.Emit(OpCodes.Ldarg_1);setIl.Emit(OpCodes.Stfld, fieldBuilder);setIl.Emit(OpCodes.Nop);setIl.MarkLabel(exitSet);setIl.Emit(OpCodes.Ret);propertyBuilder.SetGetMethod(getPropMthdBldr);propertyBuilder.SetSetMethod(setPropMthdBldr);
}private static void AppendAttribute(CustomAttributeData customAttribute, PropertyBuilder propertyBuilder)
{var args = customAttribute.ConstructorArguments.Select(m => m.Value).ToArray();var cab = new CustomAttributeBuilder(customAttribute.Constructor, args);propertyBuilder.SetCustomAttribute(cab);
}

虽然可以如上所示即时创建类型，但事实是这是一种运行时机制。这样，许多潜在的类型转换用例要么很难完成，要么不可能。

class MyEnumerable : IEnumerable<int>
{public IEnumerator<int> GetEnumerator() => new MyIterable();IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();class MyIterable : IEnumerator<int>{public int Current => current;object IEnumerator.Current => current;private int current = 0;public void Dispose() {}public bool MoveNext() => ++current < 4;public void Reset() => current = 0;}
}

C＃语言具有许多不错的功能来处理枚举器。当然，最常用的是foreach循环构造：

var enumerable = new MyEnumerable();foreach (var item in enumerable)
{item.Dump(); // 1, 2, 3
}

显然，这只是以下代码的语法糖：

var enumerable = new MyEnumerable();
var iterable = enumerable.GetEnumerator();while (iterable.MoveNext())
{var item = iterable.Current;item.Dump();
}

快速比较MSIL代码可以很容易地确认这一点。使用foreach循环的隐式版本如下所示：

IL_0000:  nop
IL_0001:  newobj      UserQuery+MyEnumerable..ctor
IL_0006:  stloc.0     // enumerable
IL_0007:  nop
IL_0008:  ldloc.0     // enumerable
IL_0009:  callvirt    UserQuery+MyEnumerable.GetEnumerator
IL_000E:  stloc.1
IL_000F:  br.s        IL_0021
IL_0011:  ldloc.1
IL_0012:  callvirt    System.Collections.Generic.IEnumerator<System.Int32>.get_Current
IL_0017:  stloc.2     // item
IL_0018:  nop
IL_0019:  ldloc.2     // item
IL_001A:  call        LINQPad.Extensions.Dump<Int32>
IL_001F:  pop
IL_0020:  nop
IL_0021:  ldloc.1
IL_0022:  callvirt    System.Collections.IEnumerator.MoveNext
IL_0027:  brtrue.s    IL_0011
IL_0029:  leave.s     IL_0036
IL_002B:  ldloc.1
IL_002C:  brfalse.s   IL_0035
IL_002E:  ldloc.1
IL_002F:  callvirt    System.IDisposable.Dispose
IL_0034:  nop
IL_0035:  endfinally
IL_0036:  ret

为了进行比较，显式版本编译为：

IL_0000:  nop
IL_0001:  newobj      UserQuery+MyEnumerable..ctor
IL_0006:  stloc.0     // enumerable
IL_0007:  ldloc.0     // enumerable
IL_0008:  callvirt    UserQuery+MyEnumerable.GetEnumerator
IL_000D:  stloc.1     // iterable
IL_000E:  br.s        IL_0020
IL_0010:  nop
IL_0011:  ldloc.1     // iterable
IL_0012:  callvirt    System.Collections.Generic.IEnumerator<System.Int32>.get_Current
IL_0017:  stloc.2     // item
IL_0018:  ldloc.2     // item
IL_0019:  call        LINQPad.Extensions.Dump<Int32>
IL_001E:  pop
IL_001F:  nop
IL_0020:  ldloc.1     // iterable
IL_0021:  callvirt    System.Collections.IEnumerator.MoveNext
IL_0026:  stloc.3
IL_0027:  ldloc.3
IL_0028:  brtrue.s    IL_0010
IL_002A:  ret

由于IEnumerator实现了IDisposable接口，我们还应该正确配置资源。foreach语法确实是为我们。始终使用生成的代码的另一个原因——通过做正确的事情而无需记住，这只会使我们的生活更轻松。

static IEnumerable<int> GetNumbers()
{var current = 0;while (++current < 4){yield return current;}
}

有趣的是，这小段代码已经代表了上面指定的完整迭代器。C＃编译器会生成所有必需的类型，以使我们能够正常工作。用法也一样，只是我们只是调用函数（GetNumbers()）而不是显式的构造函数调用（new MyEnumerable()）。

static void Main()
{2 + 3;
}

现在，这是一个奇怪的代码。它将计算2 + 3的结果，但不会执行任何操作。简而言之，要么编译器会优化该语句，要么我们只会浪费一些CPU周期。

static void Run(Action action)
{action ?? throw new ArgumentNullException(nameof(action));action();
}

这可能行不通。但可以执行以下操作：

static void Run(Action action)
{(action ?? throw new ArgumentNullException(nameof(action)))();
}

设计上认为调用表达式是OK的。显然，方法调用的副作用趋势非常高——特别是对于操作员的“不可能”等级。

static void Run(Action action)
{_ = action ?? throw new ArgumentNullException(nameof(action));action();
}

_是一种特殊的构造，可以在多种场合看到。假设我们有多项检查：

static void Run<T>(Action<T> action, T arg)where T : class
{_ = action ?? throw new ArgumentNullException(nameof(action));_ = arg ?? throw new ArgumentNullException(nameof(arg));action(arg);
}

很明显，类型action和arg将最有可能是不同的。无论如何，都可以接受分配。使用不必要的out参数也可以这样做：

if (int.TryParse(str, out _))
{// parsed successfully, but we don't care about the result
}

另一个有用的例子是“解雇”任务。在这之前，我通常介绍一种扩展方法，如下所示：

public static class TaskExtensions
{public static void Forget(this Task task){// Empty on purpose; maybe log something?}
}

这样做的好处是，现在我可以很容易地通知C#编译器，一个已用过的任务已经被故意不用了：

public Task StartTask()
{// ...
}public void OnClick()
{StartTask().Forget();
}

使用丢弃，我们不需要额外的扩展方法来传输此类信息。而且，用户已经知道任务会发生什么（提示：答案是“无”）。

public void OnClick()
{_ = StartTask();
}

我们还将在模式匹配部分中使用丢弃。

public interface IAsyncStateMachine
{void MoveNext();void SetStateMachine(IAsyncStateMachine stateMachine);
}

足够有趣的是，它具有与IEnumerator接口类似的MoveNext方法。实际上，我们可以使用一个特殊的IEnumerator版本来编写自己的async/ await实现。从JavaScript中，我们知道生成器（枚举器/yield语法糖的JavaScript名称）已经被（AB）用来在特性到达语言之前引入async/ await功能。即使在今天，polyfills仍使用此填充（或在生成器不可用的情况下，甚至再降一级）。

async static Task Run(Func<Task> action)
{await action();
}

这个小片段生成了一个类，如下所示：

IL_0000:  newobj      UserQuery+<Run>d__1..ctor
IL_0005:  stloc.0
IL_0006:  ldloc.0
IL_0007:  ldarg.0
IL_0008:  stfld       UserQuery<Run>d__1.action
IL_000D:  ldloc.0
IL_000E:  call        System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Create
IL_0013:  stfld       UserQuery+<Run>d__1.<>t__builder
IL_0018:  ldloc.0
IL_0019:  ldc.i4.m1
IL_001A:  stfld       UserQuery+<Run>d__1.<>1__state
IL_001F:  ldloc.0
IL_0020:  ldfld       UserQuery+<Run>d__1.<>t__builder
IL_0025:  stloc.1
IL_0026:  ldloca.s    01
IL_0028:  ldloca.s    00
IL_002A:  call        System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Start<<Run>d__1>
IL_002F:  ldloc.0
IL_0030:  ldflda      UserQuery+<Run>d__1.<>t__builder
IL_0035:  call        System.Runtime.CompilerServices.AsyncTaskMethodBuilder.get_Task
IL_003A:  ret

简而言之，我们实例化生成的类，存储使用的参数（捕获）并设置要在异步状态机内使用的状态。异步任务方法构建器的静态Create方法用于构建关联的构建器状态。然后，我们运行异步任务方法构建器以为此构造一个任务。最后，我们从构建器返回Task属性。

static Task Run(Func<Task> action)
{return action();
}

这两个变体并不完全等效。事先，我们返回了一个新生成的任务，“包装”了原始任务。现在，我们返回原始的。在性能方面，它们肯定是不同的。在此版本中，我们省略了完整的类生成。同样，用于运行该方法的MSIL相较而言非常短：

IL_0000:  nop
IL_0001:  ldarg.0
IL_0002:  callvirt    System.Func<System.Threading.Tasks.Task>.Invoke
IL_0007:  stloc.0
IL_0008:  br.s        IL_000A
IL_000A:  ldloc.0
IL_000B:  ret

显然，仅当我们具有多个await或复杂的结构（例如，仅await在某个if块中）时，才使用async方法。在任何其他情况下，我们都应尝试更轻量一些。编译时和运行时都将感谢我们更快的执行速度。

public Task<Task> GetNameAsync()
{// ...
}

如果我们已经知道名称，则可以直接将其返回，但是如何将其包装在任务中呢？最简单的情况是用async来修饰方法，但我们也可以使用Task.FromResult：

public Task<Task> GetNameAsync() => Task.FromResult("constant name");

根据经验，始终先寻找非生成的解决方案。

foreach (var item in await GetItems())
{// ...
}

潜在地，我们可以将流包装成：

foreach (var getNextItem in GetItems())
{var item = await getNextItem();// ...
}

但是，如果没有下一项？现在，我们放置一个回调。如果没有，我们可以接收null或引发异常。两种情况都有明显的缺点。因此，让我们来看一个自定义数据类型。

foreach (var getNextItem in GetItems())
{var state = await getNextItem();if (state.Finished){break;}var item = state.Current;// ...
}

仍然有些混乱，特别是从样板的角度来看。因此，我们现在有await foreach。可以与新IAsyncEnumerable接口结合使用。

public async IAsyncEnumerable<int> GetNumbersAsync()
{var current = 0;while (++current < 4){await Task.Delay(500);yield return current;}
}

现在，我想为您提供有关如何生成（以及究竟生成了什么）的详细信息，但是您可以猜测它与我们之前检查的结构类似。最后，它只是async/ await与迭代器结合的状态机。

public interface IAsyncEnumerator<out T> : IAsyncDisposable
{T Current { get; }ValueTask<bool> MoveNextAsync();
}

太好了，因此语法糖看起来如何？

await foreach (var item in GetNumbersAsync())
{// ...
}

太好了，所以现在这个距离也缩小了！async迭代器可以是超级强大尤其是对于事件流。

var element = node as IElement;if (element != null)
{// ...
}

但是有了is操作符的新功能，就不再需要此类片段/临时变量。我们可以编写能读得很好的代码。

if (node is IElement element)
{// ...
}

完美吧？无聊的。好吧，所以也许新的switch控制结构更符合您的口味。就个人而言，我希望看到一个新的match结构，但是，我可以看到为什么避免使用新的保留关键字，并且我喜欢渐进式方法。

switch (node)
{case IElement element:// ...break;
}

让我们检查为该构造生成的MSIL代码：

IL_0000:  nop
IL_0001:  ldarg.1
IL_0002:  stloc.3
IL_0003:  ldloc.3
IL_0004:  stloc.0
IL_0005:  ldloc.0
IL_0006:  brtrue.s    IL_000A
IL_0008:  br.s        IL_0016
IL_000A:  ldloc.0
IL_000B:  isinst      IElement
IL_0010:  dup
IL_0011:  stloc.1
IL_0012:  brfalse.s   IL_0016
IL_0014:  br.s        IL_0018
IL_0016:  br.s        IL_001E
IL_0018:  ldloc.1
IL_0019:  stloc.2     // element
IL_001A:  br.s        IL_001C
IL_001C:  br.s        IL_001E
IL_001E:  ret

好吧，这里没有魔术。几乎和我们写的一样：

if (node is IElement)
{var element = (IElement)node;// ...
}

虽然有一些细微的差异。最值得注意的是，我们以生成的MSIL形式进行了显式转换。使用前面提到的模式表达式，我们将更接近使用新switch结构生成的MSIL代码。因此，我们真的可以说switch纯粹是语法糖来避免重复。

switch (shape)
{case Square s when s.Side == 0:case Circle c when c.Radius == 0:return 0;case Square s:return s.Side * s.Side;case Circle c:return c.Radius * c.Radius * Math.PI;
}

这样很棒，我们避免了需要使用复杂函数goto或局部函数来避免重复的结构。

switch (shapeDescription)
{case "circle":return new Circle(2);case "square":return new Square(4);case "large-circle":return new Circle(12);case var o when (o?.Trim().Length ?? 0) == 0:return null;
}

因此，特定的空白情况使用隐式类型来触发使用when的其他检查。或者，我们可以写成case string o when。但是，var应该首选它，因为它在重构的情况下也会经受时间的考验。此外，它将传送给读者“嘿，我不想在这里检查演员表，我只想介绍更多条件”。毕竟，将意图传达给读者很重要。

var element = document.QuerySelector("a");
// element is of IElement, but can it be null ?

对于可为null的类型，每种类型T都是非 null。现在，这与值类型保持一致，这要求包装器（伪）可为空（T?或Nullable<T>）。对于引用类型，不存在这样的包装器，但是，信息是通过元数据传输的。

<LangVersion>8.0</LangVersion>
<Nullable>enable</Nullable>

现在，我们不仅可以返回类型，还可以使用问号来修饰它，以表示可能返回null。

var element = document.QuerySelector("a");
// element is of IElement?, we should introduce checks!

方法签名也是如此。让我们考虑以下签名：

public void Insert(IElement element);

IElement?不允许将方法与实例一起使用。相反，我们必须引入类型保护。

public void InsertMaybe(IElement? element)
{if (!(element is null)){// type transformed to IElement from IElement?Insert(element);}
}

长话短说：Nullable通过检测需要保护的地方和不需要保护的地方，使我们的生活更轻松。我们应该将违反可空性行为视为错误。