What is new in C# 7,8,9,10

[What's new in C# 7](# 7)

[C# 7 in Visual Studio 2017](# 7 in Visual Studio 2017)

[Out Variables](#Out Variables)

[Pattern Matching](#Pattern Matching)

[Tuples （System.ValueTuple）](#Tuples （System.ValueTuple）)

Deconstruct解构

[Local Functions](#Local Functions)

[Ref Returns and Locals](#Ref Returns and Locals)

[Expression Bodied Members](#Expression Bodied Members)

[Throw Expressions](#Throw Expressions)

[Generated Async Return Types](#Generated Async Return Types)

[Literal Improvements](#Literal Improvements)

[C# 7.1 in Visual Studio 2017.3](# 7.1 in Visual Studio 2017.3)

Compilation Issues (how to switch to C#7.1))

[Async Main](#Async Main)

[Default Expressions](#Default Expressions)

[Ref Assemblies](#Ref Assemblies)

[Infer Tuple Names](#Infer Tuple Names)

[Pattern-Matching with Generics](#Pattern-Matching with Generics)

[C# 7.2 in Visual Studio 2017 15.5](# 7.2 in Visual Studio 2017 15.5)

[Leading Digit Separators](#Leading Digit Separators)

['Private Protected' Access Modifier](#'Private Protected' Access Modifier)

[Non-Trailing Named Arguments](#Non-Trailing Named Arguments)

[Reference Semantics on Value Types值类型的引用语义](#Reference Semantics on Value Types值类型的引用语义)

[C# 7.3 in Visual Studio 2017 15.5](# 7.3 in Visual Studio 2017 15.5)

[Performance Improvement](#Performance Improvement)

[Features Enhancements](#Features Enhancements)

[Extensioned expression variables in initializers](#Extensioned expression variables in initializers)

[New Compiler Features](#New Compiler Features)

[What's new in C# 8](# 8)

[Nullable Reference Types](#Nullable Reference Types)

[Method 1: 通过引用ReSharper.Annotations](#Method 1: 通过引用ReSharper.Annotations)

[Method 2: 通过使用string?](#Method 2: 通过使用string?)

[Override Null Checks](#Override Null Checks)

[Diable nullable check](#Diable nullable check)

[Enable nullable check](#Enable nullable check)

[Index and Range](#Index and Range)

[Default Interface Members](#Default Interface Members)

[Extension to create Default function in Interface](#Extension to create Default function in Interface)

[Default function in iterface](#Default function in iterface)

[Pattern Matching](#Pattern Matching)

[What's new in C# 9 (. NET 5)](# 9 (. NET 5))

[Record Types](#Record Types)

浅拷贝with

[Top-level Calls](#Top-level Calls)

[Initial Setters](#Initial Setters)

[Pttern Matching Improvement](#Pttern Matching Improvement)

[Target-Typed New](#Target-Typed New)

[Source Generators](#Source Generators)

[Partial Method Syntax and Modules Initializers(部分方法语法和模块初始化器)](#Partial Method Syntax and Modules Initializers(部分方法语法和模块初始化器))

[What's new in C# 10 (. NET 6)](# 10 (. NET 6))

[Record Structs](#Record Structs)

[Global Using Directives](#Global Using Directives)

[File-Scoped Namespace Declarations](#File-Scoped Namespace Declarations)

[Extended Property Patterns](#Extended Property Patterns)

[Generic Attributes通用属性](#Generic Attributes通用属性)

[Lambda Improvements，提高很多](#Lambda Improvements，提高很多)

[Enhanced #line directives](#line directives)

What's new in C# 7

C# 7 in Visual Studio 2017

Out Variables

cs 复制代码

using System;
using static System.Console;

namespace CSharp7Demos
{
  class OutVariables
  {
    static void MainOV(string[] args)
    {
      DateTime dt; // struct
      if (DateTime.TryParse("01/01/2017", out dt))
      {
        WriteLine($"Old-fashioned parse: {dt}");
      }

      // variable declaration is an expression, not a statement
      if (DateTime.TryParse("02/02/2016", out /*DateTime*/ var dt2))
      {
        WriteLine($"New parse: {dt2}");
      }

      // the scope of dt2 extends outside the if block
      WriteLine($"I can use dt2 here: {dt2}");

      // what if the parse fails?
      int.TryParse("abc", out var i);
      WriteLine($"i = {i}"); // default value
    }
  }
}

Pattern Matching

cs 复制代码

using static System.Console;

namespace CSharp7Demos
{
  public class Shape
  {
    
  }
  

  public class Rectangle : Shape
  {
    public int Width, Height;
  }

  public class Circle : Shape
  {
    public int Diameter;
  }

  public class PatternMatching
  {
    public void DisplayShape(Shape shape)
    {
      if (shape is Rectangle)
      {
        var rc = (Rectangle) shape;

      } else if (shape is Circle)
      {
        // ...
      }


      var rect = shape as Rectangle;
      if (rect != null) // nonnull
      {
        //...
      }

      if (shape is Rectangle r)
      {
        // use r
      }

      // can also do the invserse
      if (!(shape is Circle cc))
      {
        // not a circle!
      }


      switch (shape)
      {
        case Circle c:
          // use c
          break;
        case Rectangle sq when (sq.Width == sq.Height):
          // square!
          break;
        case Rectangle rr:
          // use rr
          break;
      }

      var z = (23, 32);

      //switch (z)
      //{
      //  case (0, 0):
      //    WriteLine("origin");
      //}
    }

    static void Main(string[] args)
    {
      
    }
  }
}

Tuples （System.ValueTuple）

cs 复制代码

using System;
using System.Linq;
using Microsoft.SqlServer.Server;
using static System.Console;

namespace CSharp7Demos
{
  public class Point
  {
    public int X, Y;

    public void Deconstruct(out string s)
    {
      s = $"{X}-{Y}";
    }

    public void Deconstruct(out int x, out int y)
    {
      x = X;
      y = Y;
    }
  }

  public class Tuples
  {
    static Tuple<double, double> SumAndProduct(double a, double b)
    {
      return Tuple.Create(a + b, a * b);
    }

    // requires ValueTuple nuget package
    // originally with no names
    static (double sum, double product) NewSumAndProduct(double a, double b)
    {
      return (a+b,a*b);
    }

    static void MainT(string[] args)
    {
      // New
      var sp = SumAndProduct(2, 5);
      // sp.Item1 ugly
      WriteLine($"sum = {sp.Item1}, product = {sp.Item2}");

      var sp2 = NewSumAndProduct(2, 5);
      WriteLine($"new sum = {sp2.sum}, product = {sp2.product}");
      WriteLine($"Item1 = {sp2.Item1}");
      WriteLine(sp2.GetType());

      // converting to valuetuple loses all info
      var vt = sp2;
      // back to Item1, Item2, etc...
      var item1 = vt.Item1; // :(

      // can use var below
      //(double sum, var product) = NewSumAndProduct(3, 5);
      var (sum, product) = NewSumAndProduct(3, 5);

      // note! var works but double doesn't
      // double (s, p) = NewSumAndProduct(3, 4);
      (double s, double p) = NewSumAndProduct(3, 4);//This can work
      WriteLine($"sum = {sum}, product = {product}");
      WriteLine(sum.GetType());

      // also assignment
      double s, p;
      (s, p) = NewSumAndProduct(1, 10);

      // tuple declarations with names
      //var me = new {name = "Evan", age = 37}; // AnonymousType
      var me = (name: "Evan", age: 37);
      WriteLine(me);
      WriteLine(me.GetType());//Print is System.ValueTuple

      // names are not part of the type:
      WriteLine("Fields: " + string.Join(",", me.GetType().GetFields().Select(pr => pr.Name)));
      WriteLine("Properties: " + string.Join(",", me.GetType().GetProperties().Select(pr => pr.Name)));

      WriteLine($"My name is {me.name} and I am {me.age} years old");
      // proceed to show return: TupleElementNames in dotPeek (internally, Item1 etc. are used everywhere)

      // unfortunately, tuple names only propagate out of a function if they're in the signature
      var snp = new Func<double, double, (double sum, double product)>((a, b) => (sum: a + b, product: a * b));
      var result = snp(1, 2);
      // there's no result.sum unless you add it to signature
      WriteLine($"sum = {result.sum}");
      
     
    }
  }
}

Deconstruct解构

cs 复制代码

// deconstruction
Point pt = new Point {X = 2, Y = 3};
var (x,y) = pt; // interesting error here
Console.WriteLine($"Got a point x = {x}, y = {y}");
      
// can also discard values
(int z, _) = pt;

Local Functions

CalculateDiscriminant可以放在方法SolveQuadratic体内，或者方法体外，放在方法体内是，所在的位置可以在调用前或者调用后面。

建议放在前面，方便代码维护。

cs 复制代码

  public class Employee
  {
      public int Id { get; set; }

      public string FirstName { get; set; }
      public string LastName { get; set; }
      public string MiddleName { get; set; }
       //normal ctor
      //public Employee(string firstName, string lastName, string middleName)
      //{
      //    FirstName = firstName;
      //    LastName = lastName;
      //    MiddleName = middleName;
      //}
        //lambda ctor
      public Employee(string firstName, string lastName, string middleName) => (FirstName, LastName, MiddleName) = (firstName, lastName, middleName);

  }

cs 复制代码

using System;

namespace CSharpDemos
{
  public class EquationSolver
  {
    //private Func<double, double, double, double> CalculateDiscriminant = (aa, bb, cc) => bb * bb - 4 * aa * cc;
    
    //Quadratic 二次方程
    public static Tuple<double, double> SolveQuadratic(double a, double b, double c)
    {
      //var CalculateDiscriminant = new Func<double, double, double, double>((aa, bb, cc) => bb * bb - 4 * aa * cc);

      //double CalculateDiscriminant(double aa, double bb, double cc)
      //{
      //  return bb * bb - 4 * aa * cc;
      //}
      //double CalculateDiscriminant(double aa, double bb, double cc) => bb * bb - 4 * aa * cc;
      //double CalculateDiscriminant() => b * b - 4 * a * c;

      //var disc = CalculateDiscriminant(a, b, c);
      var disc = CalculateDiscriminant();

      var rootDisc = Math.Sqrt(disc);
      return Tuple.Create(
        (-b + rootDisc) / (2 * a),
        (-b - rootDisc) / (2 * a)
      );

      // can place here
      double CalculateDiscriminant() => b * b - 4 * a * c;
    }

    //private static double CalculateDiscriminant(double a, double b, double c)
    //{
    //  return b * b - 4 * a * c;
    //}
  }

  public class LocalFunctions
  {
    static void MainT(string[] args)
    {
      var result = EquationSolver.SolveQuadratic(1, 10, 16);
      Console.WriteLine(result);
    }
  }
}

Ref Returns and Locals

cs 复制代码

using System;
using System.Collections.Generic;
using static System.Console;

namespace CSharpDemos
{
  public class RefReturnsAndLocals
  {
    static ref int Find(int[] numbers, int value)
    {
      for (int i = 0; i < numbers.Length; i++)
      {
        if (numbers[i] == value)
          return ref numbers[i];
      }

      // cannot do by value return
      //return -1;

      // cannot return a local
      //int fail = -1;
      //return ref fail;

      throw new ArgumentException("meh");
    }

    static ref int Min(ref int x, ref int y)
    {
      //return x < y ? (ref x) : (ref) y;
      //return ref (x < y ? x : y);
      if (x < y) return ref x;
      return ref y;
    }

    static void MainRRL(string[] args)
    {
      // reference to a local element
      int[] numbers = { 1, 2, 3 };
      ref int refToSecond = ref numbers[1];
      var valueOfSecond = refToSecond;

      // cannot rebind
      // refToSecond = ref numbers[0];

      refToSecond = 123;
      WriteLine(string.Join(",", numbers)); // 1, 123, 3

      // reference persists even after the array is resized
      Array.Resize(ref numbers, 1);
      WriteLine($"second = {refToSecond}, array size is {numbers.Length}");
      refToSecond = 321;
      WriteLine($"second = {refToSecond}, array size is {numbers.Length}");
      //numbers.SetValue(321, 1); // will throw

      // won't work with lists
      var numberList = new List<int> {1, 2, 3};
      //ref int second = ref numberList[1]; // property or indexer cannot be out


      int[] moreNumbers = {10, 20, 30};
      //ref int refToThirty = ref Find(moreNumbers, 30);
      //refToThirty = 1000;

      // disgusting use of language
      Find(moreNumbers, 30) = 1000;

      WriteLine(string.Join(",",moreNumbers));

      // too many references:
      int a = 1, b = 2;
      ref var minRef = ref Min(ref a, ref b);

      // non-ref call just gets the value
      int minValue = Min(ref a, ref b);
      WriteLine($"min is {minValue}");
    }
  }
}

Expression Bodied Members

cs 复制代码

using System.Collections.Generic;

namespace CSharpDemos
{
  // community contributed feature
  public class Person
  {
    private int id;

    private static readonly Dictionary<int, string> names = new Dictionary<int, string>();

    public Person(int id, string name) => names.Add(id, name);
    ~Person() => names.Remove(id);

    public string Name
    {
      get => names[id];
      set => names[id] = value;
    }
  }
}

Throw Expressions

cs 复制代码

using System;
using static System.Console;

namespace CSharpDemos
{
  public class ThrowExpressions
  {
    public string Name { get; set; }

    public ThrowExpressions(string name)
    {
      Name = name ?? throw new ArgumentNullException(paramName: nameof(name));
    }

    int GetValue(int n)
    {
      return n > 0 ? n + 1 : throw new Exception();
    }

    static void MainTE(string[] args)
    {
      int v = -1;
      try
      {
        var te = new ThrowExpressions("");
        v = te.GetValue(-1); // does not get defaulted!
      }
      catch (Exception e)
      {
        Console.WriteLine(e);
      }
      finally
      {
        WriteLine(v);
      }
    }
  }
}

Generated Async Return Types

cs 复制代码

using System;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Threading.Tasks;

namespace CSharpDemos
{
  public class GeneralizedAsyncReturnTypes
  {
    public static async Task<long> GetDirSize(string dir)
    {
      if (!Directory.EnumerateFileSystemEntries(dir).Any())
        return 0;

      // Task<long> is return type so it still needs to be instantiated

      return await Task.Run(() => Directory.GetFiles(dir, "*.*", SearchOption.AllDirectories)
        .Sum(f => new FileInfo(f).Length));
    }

    // C# 7 lets us define custom return types on async methods
    // main requirement is to implement GetAwaiter() method

    // ValueTask is a good example

      // need nuget package
    public static async ValueTask<long> NewGetDirSize(string dir)
    {
      if (!Directory.EnumerateFileSystemEntries(dir).Any())
        return 0;

      // Task<long> is return type so it still needs to be instantiated

      return await Task.Run(() => Directory.GetFiles(dir, "*.*", SearchOption.AllDirectories)
        .Sum(f => new FileInfo(f).Length));
    }

    static void MainGART(string[] args)
    {
      // async methods used to require void, Task or Task<T>

      // C# 7 allows other types such as ValueType<T> - prevent
      // allocation of a task when the result is already available
      // at the time of awaiting

      Console.WriteLine(NewGetDirSize(@"c:\temp").Result);
    }
  }
}

Literal Improvements

cs 复制代码

namespace CSharpDemos
{
  public class LiteralImprovements
  {
    static void MainLI(string[] args)
    {
      int a = 123_321;
      int b = 123_321______123;

      // cannot do trailing
      //int c = 1_2_3___; // R# remove

      // also works for hex
      long h = 0xAB_BC_D123EF;

      // also binay
      var bin = 0b1110_0010_0011;
    }
  }
}

C# 7.1 in Visual Studio 2017.3

Compilation Issues (how to switch to C#7.1)

以下内码在vs2017.3中会报编译错误，你可以从Solution Explore右击Project-->Properties-->Build --> Advance去更改C#版本到7.1去解决编译错误。

cs 复制代码

static async Task Main(string[] args)
    {

      Console.WriteLine("ABC");
    }

Async Main

cs 复制代码

using System;
using System.Net.Http;
using System.Threading.Tasks;

namespace CSharpDemos
{
  internal class Program
  {
    // used to be the case that your demo
    // would have to reside in a separate
    // body

    private static string url = "http://google.com/robots.txt";

    //private static async Task MainAsync(string s)
    //{
    //  // blah
    //  Console.WriteLine(await new HttpClient().GetStringAsync(s));
    //}

    //public static void Main(string[] args)
    //{
    //  // fine
    //  MainAsync(url).GetAwaiter().GetResult();
    //}

    
    // there is no async void, it's

    // Task Main
    // Task<int> Main if you need to return
    static async Task Main(string[] args)
    {
      Console.WriteLine(await new HttpClient().GetStringAsync(url));
    }
  }
}

Default Expressions

cs 复制代码

using System;
using System.Collections.Generic;
using static System.Console;

namespace CSharpDemos
{
  public class DefaultLiteral
  {
    // allowed in argument names
    // only upside: switching from ref to value type

    // VS Action 'Simplify Default Expression'
    public DateTime GetTimestamps(List<int> items = default(List<int>))
    {
      // ...
      return default;
    }

    /// <summary>
    /// Default literal, one of the slightly meaningless features.
    /// </summary>
    static void Main()
    {
      // Simplify default expression here
      int a = default(int);
      WriteLine(a);
      int av = default;//same as above, 0 is int default value
      WriteLine(av);
 
      int b = default;
      WriteLine(b);

      // constants are ok if the inferred type is suitable
      const int c = default;
      WriteLine(c);

      // will not work here
      // const int? d = default; // oops

      // cannot leave defaults on their own
      var e = new[] {default, 33, default};
      WriteLine(string.Join(",", e));

      // rather silly way of doing things; null is shorter
      string s = default;
      WriteLine(s == null);

      // comparison with default is OK if type can be inferred
      if (s == default)
      {
        WriteLine("Yes, s is default/null");
      }

      // ternary operations
      var x = a > 0 ? default : 1.5;
      WriteLine(x.GetType().Name);
    }
  }
}

Ref Assemblies

利用Refelection反编译后，代码实现部分只有null返回，其他部分被隐藏了。

Infer Tuple Names

cs 复制代码

using System;
using System.Linq;

namespace CSharpDemos
{
  using static System.Console;

  public class InferTupleNames
  {
    // Tuple projection initializers
    public static void Main(string[] args)
    {
      // reminder: tuples
      var me = (name: "Evan", age: 37);
      WriteLine(me);

      var alsoMe = (me.age, me.name);
      WriteLine(alsoMe.Item1); // typical
      WriteLine(alsoMe.name); // new

      var result = new[] {"March", "April", "May"} // explicit name not required
        .Select(m => (
          /*Length:*/ m/*?*/.Length, // optionally nullable
          FirstChar: m[0])) // some names (e.g., ToString) disallowed
        .Where(t => t.Length == 5); // note how .Length is available here
      WriteLine(string.Join(",", result));

      // tuples produced by deconstruction
      var now = DateTime.UtcNow;
      var u = (now.Hour, now.Minute);
      var v = ((u.Hour, u.Minute) = (11, 12));
      WriteLine(v.Minute);
    }
  }
}

Pattern-Matching with Generics

cs 复制代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpDemos
{
  using static System.Console;

  public class Animal
  {

  }

  public class Pig : Animal
  {

  }

  public class PatternMatchingWithGenerics
  {
    public static void Cook<T>(T animal)
      where T : Animal
    {
      // note the red squiggly!
      // cast is redundant here
      if ((object)animal is Pig pig)
      {
        // cook and eat it
        Write("We cooked and ate the pig...");
      }

      switch (/*(object)*/animal)
      {
        case Pig pork:
          WriteLine(" and it tastes delicious!");
          break;
      }
    }

    /// <summary>
    /// Need to fall back to C# 7 for this.
    /// </summary>
    static void Main(string[] args)
    {
      var pig = new Pig();
      Cook(pig);
    }
  }
}

C# 7.2 in Visual Studio 2017 15.5

Leading Digit Separators

cs 复制代码

  class LeadingUnderscoresNumericSeparators
  {
    static void Main(string[] args)
    {
      // binary
      var x = 0b_1111_0000;

      // hex
      var y = 0x_baad_f00d;
    }
  }

'Private Protected' Access Modifier

cs 复制代码

public class Base
  {
    private int a;
    protected internal int b; // derived classes or classes in same assembly
    private protected int c;  // containing class or derived classes in same assembly only 
  }

  class Derived : Base
  {
    public Derived()
    {
      c = 333; // fine

      b = 3; // no
    }
  }

  class Foo
  {
    static void Main(string[] args)
    {
      Base pp = new Base();
      var d = new Derived();
      d.b = 3;
      // d.c is a no-go
    }
  }

Non-Trailing Named Arguments

cs 复制代码

static void doSomething(int foo, int bar)
    {

    }

    static void Main(string[] args)
    {
      doSomething(foo: 33, 44);

      // still illegal
      //doSomething(33, foo:44)
    }

Reference Semantics on Value Types值类型的引用语义

'In' Parameters

'Ref Readonly' Variables

'Ref Struct' and Span

cs 复制代码

struct Point
  {
    public double X, Y;

    public Point(double x, double y)
    {
      X = x;
      Y = y;
    }

    public void Reset()
    {
      X = Y = 0;
    }

    // we don't want to recreate origin as new Point(), so...
    private static Point origin = new Point();
    public static ref readonly Point Origin => ref origin;

    public override string ToString()
    {
      return $"({X},{Y})";
    }
  }

  public class RefSemanticsValueTypes
  {
    // IN PARAMETERS

    void changeMe(ref Point p)
    {
      p.X++;
    }

    // structs are passed by reference (i.e. address, so 32 or 64 bits)
    // 'in' is effectively by-ref and read-only
    double MeasureDistance(in Point p1, in Point p2)
    {
      // cannot assign to in parameter
      // p1 = new Point();

      // cannot pass as ref or out method
      // obvious
      // changeMe(ref p2);

      p2.Reset(); // instance operations happen on a copy!

      var dx = p1.X - p2.X;
      var dy = p1.Y - p2.Y;
      return Math.Sqrt(dx * dx + dy * dy);
    }

    // cannot create overloads that differ only in presence?
    // yeah you can, but
    //double MeasureDistance(Point p1, Point p2)
    //{
    //  return 0.0;
    //}

    

    public RefSemanticsValueTypes()
    {
      var p1 = new Point(1, 1);
      var p2 = new Point(4, 5);

      var distance = MeasureDistance(p1, p2);
      //             ^^^^ call ambiguous
      Console.WriteLine($"Distance between {p1} and {p2} is {distance}");

      // can also pass in temporaries
      var distFromOrigin = MeasureDistance(p1, new Point());

      var alsoDistanceFromOrigin = MeasureDistance(p2, Point.Origin);

      // REF READONLY RETURNS

      // make an ordinary by-value copy
      Point copyOfOrigin = Point.Origin;

      // it's readonly, you cannot do a ref!
      //ref var messWithOrigin = ref Point.Origin;

      ref readonly var originRef = ref Point.Origin;
      // won't work
      //originRef.X = 123;
    }

    // REF STRUCTS

    // a value type that MUST be stack-allocated
    // can never be created on the heap
    // created specifically for Span<T>
    
    class CannotDoThis
    {
      Span<byte> stuff;
    }

    static void Main(string[] args)
    {
      new RefSemanticsValueTypes();

      unsafe
      {
        // managed
        byte* ptr = stackalloc byte[100];
        Span<byte> memory = new Span<byte>(ptr, 100);

        // unmanaged
        IntPtr unmanagedPtr = Marshal.AllocHGlobal(123);
        Span<byte> unmanagedMemory = new Span<byte>(unmanagedPtr.ToPointer(), 123);
        Marshal.FreeHGlobal(unmanagedPtr);
      }

      // implicit cast
      char[] stuff = "hello".ToCharArray();
      Span<char> arrayMemory = stuff;

      // string is immutable so we can make a readonly span
      ReadOnlySpan<char> more = "hi there!".AsSpan();

      Console.WriteLine($"Our span has {more.Length} elements");

      arrayMemory.Fill('x');
      Console.WriteLine(stuff);
      arrayMemory.Clear();
      Console.WriteLine(stuff);
    }
  }

C# 7.3 in Visual Studio 2017 15.5

Performance Improvement

- Fixed-sized buffers
- Ref local variables maybe reassigned
- stackalloc arrays support initializers
cs 复制代码
```
int* pArr1=stackalloc int[3]{1,2,3}
int* pArr2=stackalloc int[]{1,2,3}
```

Features Enhancements

Attributes on backing fields of auto-props (auto-props的后置字段上的属性)

cs 复制代码

[field:SomeCleverAttribute]
public float SomeProperty{get;set;}

Extensioned expression variables in initializers

cs 复制代码

public class B
{
    public B(int i,out int j)
    {
        j=i;    
    }
}
public class D:B
{
    public D(int i):B(i,out var j)
    {
        Console.WriteLine($"j = {j}}");  
    }
}

- Tutple support == and !=
- Imrpove overload resolution rules for method groups