C#高级编程9 第17章 使用VS2013-C#特性

C#高级编程9 第17章 使用VS2013程序员

编辑定位到web

 

若是默认勾选了这项,请去掉勾选,由于勾选以后解决方案的目录会根据当前文件选中。express

 能够设置项目并行生成数编程

 

版本控制软件设置c#

全部文本编辑器行号显示windows

 

启用编辑继续数组

 收集调试信息,将影响性能缓存

 

 Code Compare这是扩展与更新里面的插件,安装以后才会显示,用来比较代码是否相同安全

 nuget包源配置,提供了nuget更新的数据源框架

 目标框架的设置影响到项目基础框架的引用,不一样目标框架的项目之间不能互相引用。

 不安全代码和警告等级可能会影响生成

特定页指定了项目运行的起始页面,URL指定了端口号和虚拟目录,必须建立虚拟目录以后才能运行项目,调试器通常使用asp.net

 项目发布通常只须要运行所需的文件

 windows服务项目能够选择启用本机调试,若是出现没法写入内存的错误时。

web发布

 

 

 

 

 

 

 

VS2015....VS2017...

 

C#6.0特性:

    1. NameOf表达式。曾几什么时候,咱们一直在hardcode各类参数异常,譬如: 
      void ThrowArgumentNullException(string firstVersionArgumentName) 

        threw new ArgumentNullException(“firstVersionArgumentName”, “can not be null”); 

      很悲催的是第二版说不定PM就说:“这个参数名字不合适,咱改改吧”,得益于IDE的重构功能,这个很容易,直接F2更名而后回车,签入代码;若干天后,测试找上门来,说你的参数名字是变了,可是异常信息没变。好吧,原来这里的hardcode字符组,这个是不会随着重构功能改变的! 
      再来看看新的Nameof表达式给我带来什么,一样的功能,代码以下: 
      void ThrowArgumentNullException(string firstVersionArgumentName) 

        threw new ArgumentNullException(nameof(firstVersionArgumentName), “can not be null”); 

      在回到IDE中,再次按F2触发重构更名,你会发现异常信息也能一块儿改变了。
    2. 空值判断操做符(Null-conditional operators),又一个重量级代码提高,直接上示例代码: 
      public static string Tuncate(this string value, int length) 

        if(!string.IsNullOrEmpty(value)) 
        { 
          return value.Substring(0, Math.Min(value.Length, length)); 
        } 
        return value; 

      这只是一个很小的折影,在开发过程当中咱们有无数这样的方法,无数次重复为空判断,可是这对代码的可读性和业务处理没有任何提高,反而增长了代码复杂度,让咱们更难理解当初的设计初衷。显然,C#6.0使用null-conditional operators来向前推动了一大步: 
      public static string Tuncate(this string value, int length) 

        return value?.Substring(0, Math.Min(value.Length, length)); 

      是否是更加简洁明了,并且能突出业务核心逻辑!
    3. 字符串嵌入值(string interpolation),终于能够摆脱长长的string.Format函数了,以下代码就能够轻松改写了: 
      var fullName = string.Format(“FirstName is {0}, LastName is {1}”, customer.FirstName, customer.LastName); 
      使用新特性以后代码: 
      var fullName = “FirstName is \{customer.FirstName}, LastName is \{customer.LastName}”;
    4. Lambda表达式函数和仅get的属性。对于那些只有一两句话的函数,能够省掉一些废话了,这个新功能能够大大节省人力: 
      public override string ToString() => “\{FirstName} \{LastName}”; 
      public override int GetHashcode() => (FirstName.GetHashcode()^8) & (LastName.GetHashcode()); 
      public DateTime TimeStamp { get; } => DateTime.UtcNow;
    5. 自动属性(auto-property)和索引初始化(Index initializers),终于能够像变量同样给属性赋初值了,大大提高代码可读性。 
      public string FirstName { get; set; } = “John”; 
      public string LastName { get; set; } = “Lennon”; 
      private Dictionary<int, string> _dicts = new Dictionary<int, string> { [3] = “third”, [8] = “eight” }; 
      public string FullName { get; } 
      pubic MyClass ()  

        FullName = “\{FirstName} \{LastName}”; 
      }
    6. 异常过滤器(Exception filter),回想曾经的错误处理,为了提示不一样的错误,咱们不得不定义多个自定义异常,有了异常过滤器以后,咱们能够经过给异常添加一个简单的额外属性就能够解决了: 
      try { … } 
      catach ( CustomException ex ) if ( CheckException(ex) ) 
      { … }  
      想一想这个还有一个好处,好比严重异常日志,在这个过滤器里咱们能够最简单的判断,发现若果是严重的问题,能够直接作更早的提醒。
    7. 引用静态类(using static),懒人必备,想一想某大仙在前面定义了一个超级无敌的静态类和辅助方法,你有超级多的地方须要用,而后你就得一遍一遍的敲这个静态类名和方法名,万一这个静态类名字很长就更悲催了,拷贝吧,最后老是看着大段大段重复内心很不爽(程序员大部分都有代码洁癖),好吧,这个应用静态类就能很好的解决了: 
      using GrapeCity.Demo.LongLongNameStaticClass; 
      void AnotherMethod() 

        UtilA(…) // no LongLongNameStaticClass.UtilA(…) 
      }
    8. Await加强,终于能够把await放到catch和finally块中了,典型的用例是像IO资源操做之类能够简单整洁的处理关闭了: 
      Resource res = null; 
      try 

        res = await Resource.OpenAsync(…); //一直均可以并且一直这么作的 
        ... 

      catch(ResourceException ex) 

        await Resource.LogAsync(res, ex); //写日志吧,不阻塞 

      finally 

        res?.CloseAsync(); //结合空值判断操做符更简洁明了 
      }

C#7.0特性

    

1. out-variables(Out变量)

之前,咱们使用out变量的时候,须要在外部先申明,而后才能传入方法,相似以下:

string ddd = ""; //先申明变量
ccc.StringOut(out ddd);
Console.WriteLine(ddd);

c#7.0中咱们能够没必要申明,直接在参数传递的同时申明它,以下:

 StringOut(out string ddd); //传递的同时申明
Console.WriteLine(ddd);
Console.ReadLine();

 

2.Tuples(元组)

曾今在.NET4.0中,微软对多个返回值给了咱们一个解决方案叫元组,相似代码以下:

 static void Main(string[] args)
 {
            var data = GetFullName();
            Console.WriteLine(data.Item1);
            Console.WriteLine(data.Item2);
            Console.WriteLine(data.Item3);
            Console.ReadLine();
}
static Tuple<string, string, string> GetFullName() 
{
           return  new Tuple<string, string, string>("a", "b", "c");
}

上面代码展现了一个方法,返回含有3个字符串的元组,然而当咱们获取到值,使用的时候 心已经炸了,Item1,Item2,Item3是什么鬼,虽然达到了咱们的要求,可是实在不优雅

那么,在C#7.0中,微软提供了更优雅的方案:(注意:须要经过nuget引用System.ValueTuple)以下:

        static void Main(string[] args)
        {
            var data=GetFullName();
            Console.WriteLine(data.a); //可用命名获取到值
            Console.WriteLine(data.b);
            Console.WriteLine(data.c);
            Console.ReadLine();

        }


        //方法定义为多个返回值,并命名
        private static (string a,string b,string c) GetFullName()
        {
            return ("a","b","c");
        }

解构元组,有的时候咱们不想用var匿名来获取,那么如何获取abc呢?咱们能够以下:

 static void Main(string[] args)
        {
           //定义解构元组
            (string a, string b, string c) = GetFullName();

            Console.WriteLine(a);
            Console.WriteLine(b);
            Console.WriteLine(c);
            Console.ReadLine();

        }

        private static (string a,string b,string c) GetFullName()
        {
            return ("a","b","c");
        }

 

3. Pattern Matching(匹配模式)

在C#7.0中,引入了匹配模式的玩法,先举个老栗子.一个object类型,咱们想判断他是否为int若是是int咱们就加10,而后输出,须要以下:

object a = 1;
if (a is int) //is判断
{
  int b = (int)a; //拆
  int d = b+10; //加10
  Console.WriteLine(d); //输出
}

那么在C#7.0中,首先就是对is的一个小扩展,咱们只须要这样写就好了,以下:

object a = 1;
if (a is int c) //这里,判断为int后就直接赋值给c
{
  int d = c + 10;
  Console.WriteLine(d);
}

这样是否是很方便?特别是常常用反射的同志们..

那么问题来了,挖掘机技术哪家强?!(咳咳,呸 开玩笑)

实际上是,若是有多种类型须要匹配,那怎么办?多个if else?固然没问题,不过,微软爸爸也提供了switch的新玩法,咱们来看看,以下:

咱们定义一个Add的方法,以Object做为参数,返回动态类型

        static dynamic Add(object a)
        {
            dynamic data;
            switch (a)
            {
                case int b:
                    data=b++;
                    break;
                case string c:
                    data= c + "aaa";
                    break;
                default:
                    data = null;
                    break;
            }
            return data;
        }

下面运行,传入int类型:

object a = 1;
var data= Add(a);
Console.WriteLine(data.GetType());
Console.WriteLine(data);

输出如图:

咱们传入String类型的参数,代码和输出以下:

object a = "bbbb";
var data= Add(a);
Console.WriteLine(data.GetType());
Console.WriteLine(data);

经过如上代码,咱们就能够体会到switch的新玩法是多么的顺畅和强大了.

匹配模式的Case When筛选

有的基友就要问了.既然咱们能够在Switch里面匹配类型了,那咱们能不能顺便筛选一下值?答案固然是确定的.

咱们把上面的Switch代码改一下,以下:

            switch (a)
            {
                case int b when b < 0:
                    data = b + 100;
                    break;
                case int b:
                    data=b++;
                    break;
                case string c:
                    data= c + "aaa";
                    break;
                default:
                    data = null;
                    break;
            }

在传入-1试试,看结果以下:

 

 

4.ref locals and returns(局部变量和引用返回)

 

首先咱们知道 ref关键字是将值传递变为引用传递

那么咱们先来看看ref locals(ref局部变量)

列子代码以下:

       static  void Main(string[] args)
        {

            int x = 3;
            ref int x1 = ref x;  //注意这里,咱们经过ref关键字 把x赋给了x1
            x1 = 2;
            Console.WriteLine($"改变后的变量 {nameof(x)} 值为: {x}");
            Console.ReadLine();

        }

这段代码最终输出 "2"

你们注意注释的部分,咱们经过ref关键字把x赋给了x1,若是是值类型的传递,那么对x将毫无影响 仍是输出3.

好处不言而喻,在某些特定的场合,咱们能够直接用ref来引用传递,减小了值传递所须要开辟的空间.

 

接下来咱们看看ref  returns (ref引用返回)

这个功能实际上是很是有用的,咱们能够把值类型看成引用类型来进行return

老规矩,咱们举个栗子,代码以下:

很简单的逻辑..获取指定数组的指定下标的值

static ref int GetByIndex(int[] arr, int ix) => ref arr[ix];  //获取指定数组的指定下标

咱们编写测试代码以下:

            int[] arr = { 1, 2, 3, 4, 5 };
            ref int x = ref GetByIndex(arr, 2); //调用刚才的方法
            x = 99;
            Console.WriteLine($"数组arr[2]的值为: {arr[2]}");
            Console.ReadLine();

咱们经过ref返回引用类型,在从新赋值, arr数组中的值,相应也改变了.

总结一下:ref关键字很早就存在了,可是他只能用于参数,此次C#7.0让他不只仅只能做为参数传递,还能做为本地变量和返回值了

 

5.Local Functions (局部函数)

嗯,这个就有点颠覆..你们都知道,局部变量是指:只在特定过程或函数中能够访问的变量。

那这个局部函数,顾名思义:只在特定的函数中能够访问的函数(妈蛋 好绕口)

使用方法以下:

 

       public static void DoSomeing()
        {
            //调用Dosmeing2
            int data = Dosmeing2(100, 200);
            Console.WriteLine(data);
            //定义局部函数,Dosmeing2.
            int Dosmeing2(int a, int b)
            {
               return a + b;
            }
        }

呃,解释下来 大概就是在DoSomeing中定义了一个DoSomeing2的方法,..在前面调用了一下.(注:值得一提的是局部函数定义在方法的任何位置,均可以在方法内被调用,不用遵循逐行解析的方式)

 

6.More expression-bodied members(更多的函数成员的表达式体)

C#6.0中,提供了对于只有一条语句的方法体能够简写成表达式。

以下:

        public void CreateCaCheContext() => new CaCheContext();
        //等价于下面的代码
        public void CreateCaCheContext()
        {
            new CaCheContext();
        } 

可是,并不支持用于构造函数,析构函数,和属性访问器,那么C#7.0就支持了..代码以下:

// 构造函数的表达式写法
public CaCheContext(string label) => this.Label = label;

// 析构函数的表达式写法
~CaCheContext() => Console.Error.WriteLine("Finalized!");

private string label;

// Get/Set属性访问器的表达式写法
public string Label
{
    get => label;
    set => this.label = value ?? "Default label";
}

7.throw Expressions (异常表达式)

在C#7.0之前,咱们想判断一个字符串是否为null,若是为null则抛除异常,咱们须要这么写:

        public string IsNull()
        {
            string a = null;
            if (a == null)
            {
                throw new Exception("异常了!");
            }
            return a;
        }

 

这样,咱们就很不方便,特别是在三元表达式 或者非空表达式中,都没法抛除这个异常,须要写if语句.

那么咱们在C#7.0中,能够这样:

        public string IsNull()
        {
            string a = null;
            return a ?? throw new Exception("异常了!");
        }

 

8.Generalized async return types (通用异步返回类型)

嗯,这个,怎么说呢,其实我异步用的较少,因此对这个感受理解不深入,仍是以为然并卵,在某些特定的状况下应该是有用的.

我就直接翻译官方的原文了,实例代码也是官方的原文.

异步方法必须返回 void,Task 或 Task<T>,此次加入了新的ValueTask<T>,来防止异步运行的结果在等待时已可用的情境下,对 Task<T> 进行分配。对于许多示例中设计缓冲的异步场景,这能够大大减小分配的数量并显著地提高性能。

官方的实例展现的主要是意思是:一个数据,在已经缓存的状况下,可使用ValueTask来返回异步或者同步2种方案

    public class CaCheContext
    {
        public ValueTask<int> CachedFunc()
        {
            return (cache) ? new ValueTask<int>(cacheResult) : new ValueTask<int>(loadCache());
        }
        private bool cache = false;
        private int cacheResult;
        private async Task<int> loadCache()
        {
            // simulate async work:
            await Task.Delay(5000);
            cache = true;
            cacheResult = 100;
            return cacheResult;
        }
    }

调用的代码和结果以下:

        //main方法可不能用async修饰,因此用了委托.
        static  void Main(string[] args)
        {
            Action act = async () =>
            {
                CaCheContext cc = new CaCheContext();
                int data = await cc.CachedFunc();
                Console.WriteLine(data);
                int data2 = await cc.CachedFunc();
                Console.WriteLine(data2);
            };
            // 调用委托  
            act();
            Console.Read();

        }

上面的代码,咱们连续调用了2次,第一次,等待了5秒出现结果.第二次则没有等待直接出现结果和预期的效果一致.

 

9.Numeric literal syntax improvements(数值文字语法改进)

这个就纯粹的是..为了好看了.

在C#7.0中,容许数字中出现"_"这个分割符号.来提升可读性,举例以下:

            int a = 123_456;
            int b = 0xAB_CD_EF;
            int c = 123456;
            int d = 0xABCDEF;
            Console.WriteLine(a==c);
            Console.WriteLine(b==d);
            //如上代码会显示两个true,在数字中用"_"分隔符不会影响结果,只是为了提升可读性
   

固然,既然是数字类型的分隔符,那么 decimalfloat 和 double  都是能够这样被分割的..

相关文章
相关标签/搜索