C#新特性记录

C#6.0新特性笔记

Getter专属赋值

可以在构造函数中，给只有get的属性赋初始值。

class Point
    {
        public int x { get; }
        public Point()
        {
            x = 1;
        }
    }

自动属性初始化

可以给自动属性，赋初始化值

class Point
    {
        public int x { get; set; } = 1;
    }

全局静态

可以设置全局静态，然后直接写静态类的方法。

using static System.Console;

namespace FxApp
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            Read();
        }
    }
}

全局枚举

可以设置全局枚举，然后直接写枚举属性

using static System.ConsoleColor;

namespace FxApp
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var color = Red;
        }
    }
}

字符串插入

可以使用$来进行字符串插入，替代string.format。全局变量或参数都可插入

internal class Program
    {
        public static int x { get; set; }
        private static void Main(string[] args)
        {
            string text = $"{x},{args}";
        }
    }

Expression bodied

可以使用箭头表达式来给方法或属性提供表达式体。注意，表达式体不能有括号。

 internal class Program
    {
        public string Name => "Chenxy";
        public int Sum(int x, int y) => x + y;
        private static void Main(string[] args)
        {
            Program po = new Program();
            Console.WriteLine(po.Name); //Chenxy
            Console.WriteLine(po.Sum(1, 2)); //3
            Console.Read();
        }
    }

索引值初始化

可以给集合赋初始化值

internal class Program
    {
        IDictionary<int, string> dict = new Dictionary<int, string>()
        {
            [1] = "first",
            [2] = "second"
        };
        private static void Main(string[] args)
        {
            Program po = new Program();
            foreach (var item in po.dict)
            {
                Console.WriteLine(item.Value);
            }
            Console.Read();
        }
    }

?.运算符

空值运算符，可以简化判断null的工作

public class Point
    {
        public int x { get; } = 1;
    }
    internal class Program
    {
        public static void Main(string[] args)
        {
            Point po = null;
            //C# 5.0 写法
            if (po != null)
            {
                Console.WriteLine(po.x);
            }
            //C# 6.0 写法
            Console.WriteLine(po?.x);
            Console.Read();
        }
    }

nameof表达式

为了防止重构时忘记修改，可以使用nameof来将一个常量和变量绑定。变量改变时，常量随之改变

internal class Program
    {
        public static void Main(string[] args)
        {
            string error = string.Empty;
            //C# 5.0
            Console.WriteLine("error"); //error
            //C# 6.0
            Console.WriteLine(nameof(error)); //error

            Console.Read();
        }
    }

在此代码中，如果改变 error名称，但不修改nameof(error)名称。则会在编译时提示

异常过滤器

可以在try catch中进行判断，来控制是否进入catch。如果hideError为false，则不会进入catch。

public static void Main(string[] args)
        {
            bool hideError = false;
            try
            {
                throw new Exception();
            }
            catch (Exception ex) when (hideError)
            {
                Console.WriteLine("异常已抛出");
            }

            Console.Read();
        }

catch和finally中使用await

可以在catch 和 finally中，使用await。

internal class Program
    {
        public async static void Main(string[] args)
        {
            HttpClient client = null;
            try
            {
                var result = await client.GetAsync("");
            }
            catch (Exception ex)
            {
                var result = await client.GetAsync("");
            }
            finally
            {
                var result = await client.GetAsync("");
            }

            Console.Read();
        }
    }

Visual Studio 2017

https://zhuanlan.zhihu.com/p/25626653

C#7.0新特性笔记

Out

原先代码中，如果使用Out参数，需要预先定义变量。而C#7中，则可以直接在输出参数中定义变量。

我们也可以直接在参数中，定义var隐式变量。

//VS2015
static void Main(string[] args)
        {
            int x;
            OutMethod(out x);
            WriteLine($"X：{x}");
            Read();
        }

//VS2017
static void Main(string[] args)
        {
            OutMethod(out int x);
            WriteLine($"X：{x}");
            Read();
        }

解构

在调用函数中，可以将参数组合封装到一个类的构造函数中。但是无法通过对象解构成各个组成部分。

通过解构函数，则可以完成这个事情。解构函数可以返回对象的具体确定组件。

例如，我们模拟一个参数组合

public class PathInfo {
        public string DirectoryName { get; set; }
        public string FileName { get; set; }
        public string Extension { get; set; }
        public PathInfo(string dname, string fname, string extension)
        {
            DirectoryName = dname;
            FileName = fname;
            Extension = extension;
        }
    }

我们需要从nuget加载 System.ValueTuple这样，才可以使用元组进行解构。

我们如果要使用解构，就需要先定义一个解构函数：Desconstruct

public void Deconstruct(out string dname, out string fname, out string extension)
        {
            dname = DirectoryName;
            fname = FileName;
            extension = Extension;
        }

需要注意的是，必须使用out，名称可以不一样，他是按照参数顺序返回的。

接下来，现在我们使用解构函数来调用。我们展示三种示例，来进行调用测试。

class Program
    {
        static void Main(string[] args)
        {
            PathInfo info = new PathInfo("d", "f", "e");

            //示例一：参数内声明。也可以使用var
            (string dname, string fname, string extension) = info;
            WriteLine($"{dname},{fname},{extension}");

            //示例二：声明值初始化。分配现有变量
            string dname1, fname1, extension1 = null;
            (dname1, fname1, extension1) = info;
            WriteLine($"{dname1},{fname1},{extension1}");

            //示例三：隐式变量声明
            var (dname2, fname2, extension2) = info;
            WriteLine($"{dname2},{fname2},{extension2}");
            Read();
        }
    }

跟元组类似的写法，会给每个值进行赋值，只要顺序对应即可。

注意：在示例三种，我们在括号外面声明的var，这样括号内的三个变量类型必须一致。

解构函数，要求圆括号内至少有两个输出变量。如果只有一个是不起作用的，例如

(string dname) = info; //这样是不行的。Deconstruct，如果只有一个方法是不行的。

Deconstruct，可以进行重载。使用的时候，会自动找对应的重载方法。

元组

通过元组可以从一个方法中返回多个值。在C#7.0之前，我们会定义输出参数或者对象集合。

我们可以通过两种方式，来定义元祖。

1.不使用参数名，只填写参数类型。这样会返回 Item1,2,3

2.使用参数名，并填写参数类型。这样会返回Item.参数名

3.直接使用参数名。和2一个效果，但是方便一些。

class Program
    {
        static void Main(string[] args)
        {
            PathInfo info = new PathInfo();

            var item = info.getEmpInfo();
            WriteLine($"{item.Item1},{item.Item2},{item.Item3}");

            var item2 = info.getEmpInfo2();
            WriteLine($"{item2.a},{item2.b},{item2.c}");

            var item3 = info.getEmpInfo3();
            WriteLine($"{item3.a},{item3.b},{item3.c}");

            Read();
        }
    }

    public class PathInfo
    {
        // 不使用参数名，返回Item1,2,3
        public (string, string, string) getEmpInfo()
        {
            return ("a", "b", "c");
        }
        // 使用参数名，返回定义参数名
        public (string a, string b, string c) getEmpInfo2()
        {
            return ("a", "b", "c");
        }
        // 使用指定元素
        public (string a, string b, string c) getEmpInfo3()
        {
            return (a: "a", b: "b", c: "c");
        }
    }

模式匹配

有时候基类会派生一些子类。我们如果要对每个类实施Eject方法。可以使用多个选择来实现。

AS运算符

使用AS运算符转换并赋值

检查结果是否为null

执行Eject操作

IS运算符

使用IS运算符检查类型

转换类型并为其赋值

执行Eject操作

Cast

显示转换赋值

捕捉可能的异常

执行操作

上述这些方法存在的问题都是语法相当冗长，总要为转换的类提供多个语句

具有IS表达式的模式匹配

C#7.0提供模式匹配，用作一种将测试和赋值合并为单个操作方法。

举个例子，我们在C#7以前，进行类型转换如下。我们使用IS运算符

class Program
    {
        static void Main(string[] args)
        {
            Eject(new Woman());
            Read();
        }

        static void Eject(People peo)
        {
            if (peo is Woman)
            {
                Woman wo = (Woman)peo;
                wo.Con();
            }
        }
    }

    class People {}

    class Woman : People {
        public void Con() {
            WriteLine("This is Woman");
        }
    }

可以看出来，我们需要进行 is，然后进行转换。现在我们使用模式匹配来实现上面代码

static void Eject(People peo)
        {
            if (peo is Woman wo)
            {
                wo.Con();
            }
        }

模式匹配将测试和赋值合并成一个操作了。

Switch语句的模式匹配

使用Switch可以在多个可转换的兼容类型之间时更加重要。

如果我们想添加一个附加条件，可以使用when附加在case子句。

static void Eject(People peo)
        {
            switch (peo)
            {
                case Woman wo when wo != null:
                    wo.Con();
                    break;
                case People pe:
                    break;
                default:
                    break;
            }
        }

本地函数

C#7.0允许在一个成员内部完全声明本地函数。来替代Action和Func.

本地函数的作用于域，进在周围函数的内部。关于本地函数有以下几个注意点

1.不允许修饰符

2.不支持重载

3.本地函数可以访问所有变量，包括局部变量

4.本地函数存在整个方法范围内，声明不分前后

bool IsPalindrome(string text)
{
  if (string.IsNullOrWhiteSpace(text)) return false;
  bool LocalIsPalindrome(string target)
  {
    target = target.Trim();  // Start by removing any surrounding whitespace.
    if (target.Length <= 1) return true;
    else
    {
      return char.ToLower(target[0]) ==
        char.ToLower(target[target.Length - 1]) &&
        LocalIsPalindrome(
          target.Substring(1, target.Length - 2));
    }
  }
  return LocalIsPalindrome(text);
}

通过引用返回

通过ref可以将参数传递给函数来进行更新。

C#7.0除了ref参数外，还可以通过函数返回一个引用。

class Program
    {
        static void Main(string[] args)
        {
            int[] result = { 1, 2, 3 };
            ref int a = ref Find(result);
            a += 1;
            WriteLine(result[0]);
            Read();
        }

        static ref int Find(int[] sum)
        {
            return ref sum[0];
        }
    }

文本改进

C#7.0可以通过下划线来提高可读性。可以放在二进制、十进制、十六进制数字的任意位置

long LargestSquareNumberUsingAllDigits =
  0b0010_0100_1000_1111_0110_1101_1100_0010_0100;  // 9,814,072,356
long MaxInt64 { get; } =
  9_223_372_036_854_775_807;  // Equivalent to long.MaxValue

Throw表达式

可以在表达式中，直接抛出异常

public string getEmpInfo( string EmpName)
    {
        string[] empArr = EmpName.Split(",");
        return (empArr.Length > 0) ? empArr[0] : throw new Exception("Emp Info Not exist");
    }

异步返回类型

编译器不限制异步方法必须返回 void、Task、Task<T>。

任何可以继承 GetAwaiter   方法的都可以进行返回。

但是，此方法我验证不通过。故此暂时不考虑这个特性。

Expression bodied 增强

C#7.0里面把箭头函数表达式，进行了增强。

我们可以直接在构造函数、析构函数中使用

public class Point
    {
        public Point() => WriteLine("构造");

        ~Point() => WriteLine("释放");
    }

$