C#高级语法-白红宇

C#高级语法

阅读量：4583 次

发布时间：2019-06-09

本文共 19556 字，大约阅读时间需要 65 分钟。

委托

委托就是指针函数，委托的定义与类的属性定义类似都必须在类的方法体进行。

委托的定义：    class Program        {            //定义委托:委托不能在方法体内定义。            public delegate string PrintSomething(string data);            static void Main(string[] args)            {                 }        }         使用委托：            static void Main(string[] args)            {                //HelloWorld级别的委托                PrintSomething PrintFruit = new PrintSomething(Do_1);                Console.WriteLine(PrintFruit("123"));    }         执行结果：    you want to print the data:123

委托数组

class Program    {            //定义委托数组        public delegate void BlukPrintSomething();                        static void Main(string[] args)        {            //委托数组            BlukPrintSomething[] bluckPrintSomething = new BlukPrintSomething[3]{            BlukPrintSomething_1,BlukPrintSomething_2,BlukPrintSomething_3            };                foreach (BlukPrintSomething bps in bluckPrintSomething)            {                bps();            }                Console.ReadKey();            }            static void BlukPrintSomething_1()        {            Console.WriteLine("Apple");        }            static void BlukPrintSomething_2()        {            Console.WriteLine("Orange");        }            static void BlukPrintSomething_3()        {            Console.WriteLine("Banana");        }        }

委托数组

Action<T>和Func<T>

这两个类型可以理解为便捷委托，Action<T>代表没返回值的委托。Func<T>代表有返回值的委托。

class Program        {            static void Main(string[] args)            {                //Action
      
        和Func
       
         委托                //Action
        
          就是一个便捷类型，让我们省去了定义一个委托类型的步骤               //Action
         
           tmp 等效于delegate void myDelegate(string,    string)     Do_2(Do_3);                     //Func
          
           也是一个便捷类型，只不过该类型能具有返回值                //Func
           
            等效与 delegate string myDelegate(int) Console.WriteLine(Do_4(Do_5)); Console.ReadKey(); } static string Do_1(string data) { return "you want to print the data:" + data; } static void Do_2(Action
            
              data) { data("1", "2", "3", "4"); } static void Do_3(string d1, string d2, string d3, string d4) { Console.WriteLine(d1 + d2 + d3 + d4); } static string Do_4(Func
             
               data) { return data("1", "2", "3", "4"); } static string Do_5(string d1, string d2, string d3, string d4) { return d1 + "|" + d2 + "|" + d3 + "|" + d4; } }//class

Action Func

多播委托

一个函数委托绑定多个实现函数，调用一个委托则可以调用绑定在该委托上的所有实现函数

class Program        {            static void Main(string[] args)            {                BlukPrintSomething bluckPrintSomething = new BlukPrintSomething(BlukPrintSomething_1);                bluckPrintSomething += BlukPrintSomething_2;                bluckPrintSomething += BlukPrintSomething_3;                bluckPrintSomething();                     Console.ReadKey();                             }                 static void BlukPrintSomething_1()            {                Console.WriteLine("Apple");            }                 static void BlukPrintSomething_2()            {                Console.WriteLine("Orange");            }                 static void BlukPrintSomething_3()            {                Console.WriteLine("Banana");            }                    }         执行结果：    Apple    Orange    Banana

匿名方法

不长期保存的方法，也许只能使用一次。对那些只使用一次的方法，主要用来解决程序在运行时的需求。

class Program        {                 public delegate void BlukPrintSomething();                 static void Main(string[] args)            {                BlukPrintSomething bluk = delegate()                {                    Console.WriteLine("niming func!");                };                     bluk();                Console.ReadKey();            }                   }         执行结果：    niming func!

Lambada表达式

Lambada表达式就是一个便捷的匿名函数。"=>"箭头左边是传进匿名函数的参数，而右边则是处理参数的逻辑。

class Program        {                 public delegate string PrintSomething(string data);                 static void Main(string[] args)            {                PrintSomething printSomething = a => string.Format("this data:{0} if from Lambada", a);                Console.WriteLine(printSomething("GB"));                     Console.ReadKey();                          }                   }         执行结果：    this data:GB if from Lambada

事件

事件与委托类似，不同的是事件会将调用则及调用环境作为参数传递给绑定的处理程序。

class Program        {            //定义事件    //不接受参数的事件            public static event EventHandler NotifyAnyone;         //接受一个参数的事件            public static event EventHandler
      
        NotifyAnyone2;                static void Main(string[] args)            {                //事件                //为事件添加订阅者,这个是匿名的订阅者                NotifyAnyone += delegate(object sender, EventArgs e)                {                    Console.WriteLine("NotifyAnyone event is trigger!");                };                NotifyAnyone(new object(),new EventArgs());                                     //添加订阅或取消订阅。这里.Net已经将观察者模式很好的结合起来了。                                NotifyAnyone += NotifyAnyoneNoParam_1;                NotifyAnyone += NotifyAnyoneNoParam_2;                NotifyAnyone += NotifyAnyoneNoParam_3;                NotifyAnyone(new object(), new EventArgs());                Console.WriteLine();                NotifyAnyone -= NotifyAnyoneNoParam_3;                NotifyAnyone(new object(), new EventArgs());                                     //带参数的事件订阅与取消                                GhostEventArgs e1 = new GhostEventArgs();                e1.FireTime = DateTime.Now;                     NotifyAnyone2 += NotifyAnyoneHaveParam_1;                NotifyAnyone2 += NotifyAnyoneHaveParam_2;                NotifyAnyone2 += NotifyAnyoneHaveParam_3;                NotifyAnyone2(new object(), e1);                Console.WriteLine();                NotifyAnyone2 -= NotifyAnyoneHaveParam_3;                NotifyAnyone2(new object(), e1);                     Console.ReadKey();            }                 static void NotifyAnyoneNoParam_1(object sender, EventArgs e)            {                Console.WriteLine(" Event NotifyAnyoneNoParam_1 Was Trigger!");            }                 static void NotifyAnyoneNoParam_2(object sender, EventArgs e)            {                Console.WriteLine(" Event NotifyAnyoneNoParam_2 Was Trigger!");            }                 static void NotifyAnyoneNoParam_3(object sender, EventArgs e)            {                Console.WriteLine(" Event NotifyAnyoneNoParam_3 Was Trigger!");            }                 static void NotifyAnyoneHaveParam_1(object sender, GhostEventArgs e)            {                Console.WriteLine(string.Format("this event is trigger on {0}", e.FireTime));            }                 static void NotifyAnyoneHaveParam_2(object sender, GhostEventArgs e)            {                Console.WriteLine(string.Format("this event is trigger on {0}", e.FireTime));            }                 static void NotifyAnyoneHaveParam_3(object sender, GhostEventArgs e)            {                Console.WriteLine(string.Format("this event is trigger on {0}", e.FireTime.ToString()));            }                   }         GhostEventArgs：        class GhostEventArgs:EventArgs        {            public DateTime FireTime { get; set; }        }         执行结果：    NotifyAnyone event is trigger!    NotifyAnyone event is trigger!     Event NotifyAnyoneNoParam_1 Was Trigger!     Event NotifyAnyoneNoParam_2 Was Trigger!     Event NotifyAnyoneNoParam_3 Was Trigger!         NotifyAnyone event is trigger!     Event NotifyAnyoneNoParam_1 Was Trigger!     Event NotifyAnyoneNoParam_2 Was Trigger!    this event is trigger on 2012/2/23 15:50:22    this event is trigger on 2012/2/23 15:50:22    this event is trigger on 2012/2/23 15:50:22         this event is trigger on 2012/2/23 15:50:22    this event is trigger on 2012/2/23 15:50:22

事件

动态语言（DynamicObject）

Var类型与dynamic类型的区别：Var类型在为其赋值前类型不确定，但赋值后类型则定下来了不能进行修改。而Dynamic类型却没有这样的限制，可以在任何时候存放任何类型的东西。

var data = "this is a string";        Console.WriteLine(data);        //data = 1;//这句无法通过        Console.WriteLine(data);              dynamic data2 = "this is a string";        Console.WriteLine(data2);        data2 = 1;        Console.WriteLine(data2);        data2 = new Object();        Console.WriteLine(data2);         执行结果：    this is a string    this is a string         this is a string    1    System.Object

ExpandoObject（扩展对象）

这个类型的对象与中的变量类似，可以动态的扩展。

dynamic data = new ExpandoObject();             data.FirstAttribute = "FirstAttribute";        data.SecondAttribute = "SecondAttribute";        data.ThirdAttribute = "ThirdAttribute";             ArrayList nums = new ArrayList();        for (int i = 1; i <= 10; i++)        {            nums.Add(i);        }             data.Nums = nums;        foreach (int tmp in data.Nums)        {            Console.WriteLine(tmp);        }             Console.WriteLine(data.FirstAttribute);        Console.WriteLine(data.SecondAttribute);        Console.WriteLine(data.ThirdAttribute);             Action GB = delegate() { GhostBear2(); };        data.MyMethod2 = GB;        data.MyMethod2();             Action
      
        GhostBear = a => Console.WriteLine(a);        data.MyMethod = GhostBear;        data.MyMethod("Go!Go!Fighting!");                            //被调用的方法体        public static void GhostBear2()        {            Console.WriteLine("This is dynamic method.");        }                   执行结果：    1    2    3    4    5    6    7    8    9    10    FirstAttribute    SecondAttribute    ThirdAttribute    This is dynamic method.    Go!Go!Fighting!

扩展对象

DynamicObject（实现自己的可扩展类型）

自己也可以实现扩展类型，但没有系统自带的扩展类型（ExpandoObject）好用。

1 using System;    2     3 using System.Collections.Generic;    4     5 using System.Linq;    6     7 using System.Text;    8     9     10    11 using System.Dynamic;   12    13     14    15 namespace chapter12   16    17 {   18    19     class MyDynamicObject:DynamicObject   20    21     {   22    23         Dictionary
      
        data = new Dictionary
       
        ();   24    25     26    27         /// 
           28    29         ///    30    31         /// 
   32    33         /// 
        传进来的参数，包含了调用信息   34    35         /// 
        返回包含的对象   36    37         /// 
        
         返回是否成功
           38    39         public override bool TryGetMember(GetMemberBinder binder, out object result)   40    41         {   42    43             bool isContain = false;   44    45             if (data.ContainsKey(binder.Name))   46    47             {   48    49                 result = data[binder.Name];   50    51                 isContain = true;   52    53             }   54    55             else   56    57             {   58    59                 result = "Not Find";   60    61             }   62    63             return isContain;   64    65         }   66    67     68    69         /// 
           70    71         ///    72    73         /// 
   74    75         /// 
        传进来的参数，包含了调用信息   76    77         /// 
        传进来的参数，包含了调用信息   78    79         /// 
           80    81         public override bool TrySetMember(SetMemberBinder binder, object value)   82    83         {   84    85             bool result = false;   86    87             if (!data.ContainsKey(binder.Name))   88    89             {   90    91                 data[binder.Name] = value;   92    93                 result = true;   94    95     96    97             }   98    99             return result;  100   101         }  102   103    104   105         /// 
          106   107         ///   108   109         /// 
  110   111         /// 
        传进来的参数，包含了调用信息  112   113         /// 
        传进来的参数，包含了调用信息  114   115         /// 
        方法体执行后返回的结果  116   117         /// 
        
         调用是否成功
          118   119         public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)  120   121         {  122   123             dynamic tmp = data[binder.Name];  124   125             result = null;  126   127    128   129             tmp((string)args[0]);  130   131              132   133             return true;  134   135         }  136   137     }  138   139 }  140   141    142   143 调用代码：  144   145     dynamic myDynamicObject = new MyDynamicObject();  146   147               148   149     myDynamicObject.FirstAttribute = "FirstAttribute";  150   151               152   153     Action
        
          myMethod = a => Console.WriteLine(a);  154   155     myDynamicObject.myMethod = myMethod;  156   157    158   159     Console.WriteLine(myDynamicObject.FirstAttribute);  160   161     myDynamicObject.myMethod("this is Dynamic Object");  162   163    164   165 执行结果：  166   167 FirstAttribute  168   169 this is Dynamic Object

DynamicObject（实现自己的可扩展类型）

反射

反射在日常开发中用的很少，也很难用。我至今也没找到在什么地方使用这项技术会有意想不到的效果。下面贴个小例子，简单了描述下反射。

1 using System;   2    3 using System.Collections.Generic;   4    5 using System.Linq;   6    7 using System.Text;   8    9    10   11 using System.IO;  12   13 using System.Reflection;  14   15    16   17 namespace chapter14  18   19 {  20   21     [AttributeUsage(AttributeTargets.All,AllowMultiple=true,Inherited=true)]  22   23     public class MemoAttribute:Attribute  24   25     {  26   27         public MemoAttribute() { }  28   29         public string MemoTime { get; set; }  30   31         public string MemoContent { get; set; }  32   33         public void WriteSomething(string path)   34   35         {  36   37             File.WriteAllText(path, MemoContent + MemoTime.ToString());  38   39         }   40   41     }  42   43 }

特性类

1 using System;    2     3 using System.Collections.Generic;    4     5 using System.Linq;    6     7 using System.Text;    8     9     10    11 [assembly: chapter14.Memo(MemoContent = "创建", MemoTime = "2011.11.1")]   12    13     14    15 namespace chapter14   16    17 {   18    19     20    21       22    23     [Memo(MemoContent="创建",MemoTime="2011.11.1")]   24    25     class Robot   26    27     {   28    29     30    31         public string Name { get; set; }   32    33         [Memo(MemoContent="修改",MemoTime="2011.11.2")]   34    35         public string Detail { get; set; }   36    37     38    39         [Memo(MemoContent="修改",MemoTime="2011.11.4")]   40    41         [Memo(MemoContent="修改",MemoTime="2011.11.3")]   42    43         [Memo(MemoContent="创建",MemoTime="2011.11.1")]   44    45         public void CreateBomb()   46    47         {   48    49             Console.WriteLine("CreateBomb");   50    51         }   52    53     54    55         public void LayBomb()   56    57         {   58    59             Console.WriteLine("LayBomb");   60    61         }   62    63     64    65         public void Kill()   66    67         {   68    69             Console.WriteLine("Kill");   70    71         }   72    73     74    75         public void Save()   76    77         {   78    79             Console.WriteLine("Save");   80    81         }   82    83     84    85         public void Escape()   86    87         {   88    89             Console.WriteLine("Escape");   90    91         }   92    93     94    95         public void Kill(string name)   96    97         {   98    99             Console.WriteLine(name + " was dead.");  100   101         }  102   103    104   105         public string GetInfomation()  106   107         {  108   109             return DateTime.Now.ToString();  110   111         }  112   113     }  114   115 }

调用特性类的类型

//简单的获取在类上定义的“特性类”MemoAttribute                 Type robot = typeof(Robot);        object[] attributes = robot.GetCustomAttributes(true);             foreach (object tmp in attributes)        {            MemoAttribute memo = tmp as MemoAttribute;            if (memo == null)            {                continue;            }            Console.WriteLine(string.Format("Content:{0},DateTime:{1}", memo.MemoContent, memo.MemoTime));        }         执行结果：    Content:创建,DateTime:2011.11.1

执行代码（获取定义在robot类上的特性标记“[Memo(MemoContent="创建",MemoTime="2011.11.1")]”）

Type robot = typeof(Robot);        MemberInfo[] members = robot.GetMembers();        object[] tmp;        MemoAttribute memo;                  foreach (MemberInfo member in members)        {            int indent = 0;//添加缩进            Console.WriteLine(string.Format("Name:{0},Type:{1}", member.Name, member.MemberType));            indent++;            tmp = member.GetCustomAttributes(typeof(MemoAttribute), true);            foreach (object o in tmp)            {                memo = o as MemoAttribute;                if (o == null)                {                    continue;                }                Console.WriteLine(string.Format("{0}content:{1},datetime:{2}", "".PadLeft(indent * 5, ' '), memo.MemoContent, memo.MemoTime));                 }             }         执行结果：    Name:get_Name,Type:Method    Name:set_Name,Type:Method    Name:get_Detail,Type:Method    Name:set_Detail,Type:Method    Name:CreateBomb,Type:Method         content:创建,datetime:2011.11.1         content:修改,datetime:2011.11.4         content:修改,datetime:2011.11.3    Name:LayBomb,Type:Method    Name:Kill,Type:Method    Name:Save,Type:Method    Name:Escape,Type:Method    Name:Kill,Type:Method    Name:GetInfomation,Type:Method    Name:ToString,Type:Method    Name:Equals,Type:Method    Name:GetHashCode,Type:Method    Name:GetType,Type:Method    Name:.ctor,Type:Constructor    Name:Name,Type:Property    Name:Detail,Type:Property         content:修改,datetime:2011.11.2

调用代码（打印出标记在robot类型内的所有MemoAttribute特性类的值：方法，属性等）

通过反射在运行时调用方法

也就是在程序运行后更具某些情况来决定调用定义在类型上的某个方法，真正的解耦

Type robot = typeof(Robot);        MemberInfo[] members = robot.GetMembers();        object[] tmp;        MemoAttribute memo;             //动态调用方法   插件编程        foreach (MemberInfo member in members)        {       if (member.MemberType == MemberTypes.Method && member.Name.ToLower()                               =="createbomb")         {            //构造函数            object tmpRobot = robot.InvokeMember(null, BindingFlags.DeclaredOnly |                                                             BindingFlags.Public |                                                          BindingFlags.NonPublic |                                                           BindingFlags.Instance |                                                      BindingFlags.CreateInstance    , null, null, null);                robot.InvokeMember("CreateBomb", BindingFlags.InvokeMethod    , null, tmpRobot, null);           robot.InvokeMember("Kill", BindingFlags.InvokeMethod    , null, tmpRobot, new object[] { "秦萱" });           Console.WriteLine((string)robot.InvokeMember("GetInfomation",                                  BindingFlags.InvokeMethod, null, tmpRobot, null));            }             }         执行结果：    CreateBomb    秦萱 was dead.    2012/2/23 20:03:55

应用在程序集上的反射

这个例子获取的是定义在程序集“robot”上的MemoAttribute特性。

//加载程序集        Assembly chapter14 = Assembly.GetAssembly(typeof(Robot));        object[] attributes = chapter14.GetCustomAttributes(typeof(MemoAttribute), true);        MemoAttribute memo;             foreach (object attribute in attributes)        {            memo = attribute as MemoAttribute;            if (memo == null)            {                continue;            }            Console.WriteLine(string.Format("Content:{0},DateTime:{1}", memo.MemoContent, memo.MemoTime));        }             Console.WriteLine();             Console.ReadKey();         执行结果：    Content:创建,DateTime:2011.11.1

转载于:https://www.cnblogs.com/NotEnough/p/7426853.html

你可能感兴趣的文章