免费精品网站模板,哪些网站做婚纱摄影,怎么做公众号小程序,自适应网站建设模板目录 5类和继承
5.1类继承
5.2访问继承的成员
5.3屏蔽基类的成员
5.4访问基类的成员
5.5虚方法与覆写方法
5.6构造函数的执行顺序
5.7成员访问修饰符
5.8抽象类
5.9密封类与静态类
6.表达式与运算符
6.1运算符和重载
7.结构
7.1结构体的感念。
7.2结构构造函数与…目录 5类和继承
5.1类继承
5.2访问继承的成员
5.3屏蔽基类的成员
5.4访问基类的成员
5.5虚方法与覆写方法
5.6构造函数的执行顺序
5.7成员访问修饰符
5.8抽象类
5.9密封类与静态类
6.表达式与运算符
6.1运算符和重载
7.结构
7.1结构体的感念。
7.2结构构造函数与析构函数
7.3属性与字段初始化语句
8.枚举
8.1枚举
8.2设置底层类型和显示值
8.3关于位标识
9.委托
9.1委托的概念[请把委托看成一个类型安全的C的函数指针但有所不同]
9.2 声明委托类型
9.3创建委托变量
9.4组合委托
9.5为委托添加方法
9.6 为委托移除方法
9.7调用委托
9.8
9.9匿名方法以及Lambda表达式
Lambda表达式 5类和继承
5.1类继承
继承的优点就不更多的赘述在这里主要说他的用法
通过继承可以定义一个新类新类纳入一个已经声明的类并进行扩展。
可以使用一个已经存在的类作为新类的基础。已存在的类称为基类(base class)新类称为派生类(derived class)。派生类成员的组成如下
1本身声明中的成员
2基类的成员。
要声明一个派生类需要在类名后加入基类规格说明。基类规格说明由冒号和用作基类的类名称组成。派生类直接继承自列出的基类。
1派生类扩展它的基类因为它包含了基类的成员还有它本身声明中的新增功能。
2派生类不能删除它所继承的任何成员。
例如下面展示了名为 OtherClass 的类的声明它继承自名为SomeClass的类
class OtherClass : SomeClass //基类规格说明
{
....
}5.2访问继承的成员
using System;
class SomeClass//基类
{public string Field1 base class field;public void Method1(string value){Console.WriteLine($Base class--Methodi:{value});}
}
class OtherClass : SomeClass
{//派生类public string Field2derived class field;public void Method2(string value){Console.WriteLine($Derived class--Method 2:{value});}
}
class Program
{static void Main(){OtherClass oc new OtherClass();oc.Method1(oc.Field1);//以基类字段为参数的基类方法oc.Method1(oc.Field2);//以派生字段为参数的基类方法oc.Method2(oc.Field1);//以基类字段为参数的派生方法oc.Method2(oc.Field2);//以派生字段为参数的派生方法}
}5.3屏蔽基类的成员
虽然派生类不能删除它继承的任何成员但可以用与基类成员名称相同的成员来屏蔽(mask)基类成员。这是继承的主要功能之一非常实用。
例如我们要继承包含某个特殊方法的基类。该方法虽然适合声明它的类但不一定适合派生类。在这种情况下我们希望在派生类中声明新成员以屏蔽基类中的方法。在派生类中屏蔽基类成员的一些要点如下。
1要屏蔽一个继承的数据成员需要声明一个新的相同类型的成员并使用相同的名称。
2通过在派生类中声明新的带有相同签名的函数成员可以屏蔽继承的函数成员。
请记住签名由名称和参数列表组成不包括返回类型。
3要让编译器知道你在故意屏蔽继承的成员可使用new修饰符。
否则程序可以成功编译但编译器会警告你隐藏了一个继承的成员。
4也可以屏蔽静态成员。
5使用new关键字以显式地告诉编译器屏蔽基类成员。
代码展示
using System;
class SomeClass//基类
{public string Field1 SomeClass Field1;public void Method1(string value){Console.WriteLine($SomeClass.Method1:{value}); }
}
class OtherClass : SomeClass//派生类
{new public string Field1 OtherClass Field1;//屏蔽基类成员new public void Method1(string value)//屏蔽基类成员{ Console.WriteLine($OtherClass.Method1:{value}); }}
class Program
{static void Main(){OtherClass oc new OtherClass();//使用屏蔽成员oc.Method1(oc.Field1);//使用屏蔽成员}
}运行结果 Image 5.4访问基类的成员
如果派生类必须访问被隐藏的继承成员可以使用基类访问表达式。基类访问表达式由关键字base后面跟着一个点和成员的名称组成如下所示
Console. WriteLine({0}, base. Field 1);基类访问代码 在下面的代码中派生类 OtherClass 隐藏了基类中的Field1但可以使用基类访问表达式访问它。
using System;
class SomeClass
{public string Field1 Field1--In the base class;
}
class OtherClass : SomeClass
{//派生类new public string Field1Field1--In the derived class;public void PrintField1(){ Console.WriteLine(Field1);//访问派生类Console. Writeline(base. Field 1);//访问基类}
}
class Program
{static void Main(){OtherClass oc new OtherClass();oc.PrintField1();}
}5.5虚方法与覆写方法
5.5.1在开始之前首先介绍一些使用基类的引用的知识 派生类的实例由基类的实例和派生类的新增成员组成。派生类的引用指向整个类的对象包括基类部分
如果有一个派生类对象的引用就可以获取该对象基类部分的引用(使用类型转换运算得该引用转换为基类类型)。类型转换运算符放置在对象引用的前面由圆括号括起的要被转换的类名组成。类型转换将在以后阐述。将派生类对象强制转换为基类对象的作用是产生的量只能访问基类的成员(在被覆写方法中除外稍后会讨论)。
这里直接看下面的代码
using System;
class MyBaseClass
{public void Print(){Console.WriteLine(This is the base class.);}
}class MyDerivedClass : MyBaseClass
{public int var1;new public void Print(){Console.WriteLine(This is derived class);}
}
class Program
{static void Main(){MyDerivedClass derived new MyDerivedClass();MyBaseClass mybc (MyBaseClass)derived;derived.Print();mybc.Print();//mybc.var1 1;//错误基类的引用无法访问派生类成员}
}运行结果 Image 5.5.2虚方法与覆写
其实虚方法与覆写就相当于给一个机会给派生类去实现比如说你有一个动物类作为你的基类它其中有一个方法是睡眠你以动物类为基类派生了一个狮子类狮子类的睡眠就与动物类的睡眠方法一致就不用在派生类中再重新书写睡眠这个方法。而你写一个蛇类作为动物类的派生我们知道蛇类的睡眠肯定与动物类的有所区别因为蛇在冬天要冬眠。在这样的情况下。我们就可以运用虚方法与腹泻方法有助于程序的可读性
当使用基类引用访问派生类对象时得到的是基类的成员。虚方法可以使基类的引用访问“升至”派生类内。 可以使用基类引用调用派生类的方法只需满足下面的条件。
1派生类的方法和基类的方法有相同的签名和返回类型。
2基类的方法使用virtual标注。
3派生类的方法使用override标注。
代码示例
using System;class MyBaseClass
{virtual public void Print(){Console.WriteLine(This is the base class.);}
}class MyDerivedClass : MyBaseClass
{public int var1;override public void Print(){Console.WriteLine(This is derived class);}
}
class Program
{static void Main(){MyDerivedClass derived new MyDerivedClass();MyBaseClass mybc new MyBaseClass();derived.Print();mybc.Print();}
}运行结果 Image using System;
class MyBaseClass
{virtual public void Print(){Console.WriteLine(This is the base class.);}
}class MyDerivedClass : MyBaseClass
{public int var1;override public void Print(){Console.WriteLine(This is derived class);}
}
class Program
{static void Main(){MyDerivedClass derived new MyDerivedClass();MyBaseClass mybc (MyBaseClass)derived;derived.Print();mybc.Print();}
}运行结果 Image virtual和override方法代码说明
注意和上一种情况(用new隐藏基类成员)相比在行为上的区别。
当使用基类引用(mybc)调用Print方法时方法调用被传递到派生类并执行因为基类的方法被标记为virtual在派生类中有匹配的override方法。
覆写方法可以在继承的任何层次出现
当使用对象基类部分的引用调用一个被覆写的方法时方法的调用被沿派生层次上溯执行一直到标记为override的方法的最高派生(most-derived)版本。如果在更高的派生级别有该方法的其他声明但没有被标记为override那么它们不会8被调用。
5.6构造函数的执行顺序
这一块不详细介绍有需要可以看看别人写的我感觉自己才疏学浅写出来的东西生涩难懂不如去看看别人写的
http://t.zoukankan.com/TJessica-p-6366066.html
5.7成员访问修饰符
这部分基本是纯定义部分直接贴图C#图解教程QWQ其实是自己懒 图片有点不清楚了等我回去重新拍
5.8抽象类
5.8.1抽象成员
抽象成员是指设计为被覆写的函数成员。抽象成员有以下特征。
1必须是一个函数成员。也就是说字段和常量不能为抽象成员。
2必须用abstract修饰符标记。
3不能有实现代码块。抽象成员的代码用分号表示。
例如、下面取自一个类定义的代码声明了两个抽象成员一个名为 PrintStuff 的抽象方法和一个名为 MyProperty 的抽象属性。注意在实现块位置的分号。
关键字分号替换实现
abstract public void PrintStuff (string s);
abstract public int MyProperty
{
get 一分号替换实现
set 一分号替换实现
}抽象成员只可以在抽象类中声明下一节中会讨论。一共有4种类型的成员可以声明为抽象的方法属性事件索引器。 关于抽象成员的其他重要事项如下。
1尽管抽象成员必须在派生类中用相应的成员覆写但不能把 virtual修饰符附加abstract修饰符。
2类似于虚成员派生类中抽象成员的实现必须指定override修饰符
5.8.2抽象类
抽象类是指设计为被继承的类。抽象类只能被用作其他类的基类。不能创建抽象类的实例。 抽象类使用abstract修饰符声明。
abstract class MyClass
{}抽象类可以包含抽象成员或普通的非抽象成员。抽象类的成员可以是抽象成员和普通带实现的成员的任意组合。 抽象类自己可以派生自另一个抽象类。
任何派生自抽象类的类必须使用override关键字实现该类所有的抽象成员除非派生类自己也是抽象类。
5.9密封类与静态类
密封类
密封类只能被用作独立的类它不能被用作基类。
密封类使用sealed修饰符标注。
例如下面的类是一个密封类。将它用作其他类的基类会产生编译错误。
关键字
sealed class MyClass
{
---
}静态类
静态类中所有成员都是静态的。静态类用于存放不受实例数据影响的数据和函数。静态类的一个常见用途可能是创建一个包含一组数学方法和值的数学库。
关于静态类需要了解的重要事项如下。
1类本身必须标记为static。
2类的所有成员必须是静态的。
3类可以有一个静态构造函数但不能有实例构造函数因为不能创建该类的实例。口4静态类是隐式密封的也就是说不能继承静态类。
可以使用类名和成员名像访问其他静态成员那样访问静态类的成员。从C#6.0开始也可以通过使用using static指令来访问静态类的成员而不必使用类名。
6.表达式与运算符
这一章的其他内容不过多赘述跟C几乎一致
6.1运算符和重载
C#运算符被定义为使用预定义类型作为操作数来工作。如果面对一个用户定义类型运算符完全不知道如何处理它。运算符重载允许你定义C#运算符应该如何操作自定义类型的操作数。
1运算符重载只能用于类和结构。
2为类或结构重载一个运算符x可以声明一个名称为operator x的方法并实现它的行为(例如operator和operator-等)。
一元运算符的重载方法带一个单独的class或struct类型的参数。
二元运算符的重载方法带两个参数其中至少有一个必须是class或struct类型。
形如
public static LimitedInt operator-( LimitedIntx )//一元
public static LimitedInt operator( LimitedIntx , double y)//二元
运算符重载的方法声明需要
1声明必须同时使用static和public的修饰符
2运算符必须是要操作的类或结构的成员。
例如下面的代码展示了类Limited Int的两个重载的运算符加运算符和减运算符。你可以说它是负数而不是减法因为运算符重载方法只有一个单独的参数因此是一元的而减法运算符是二元的。
public static LimitedInt operator ( LimitedIntx , double y)//二元必需的 类型 关键字运算符 操作数代码展示
using System;
class LimitedInt
{const int MaxValue 100;const int MinValue 0;public static LimitedInt operator -(LimitedInt x){LimitedInt li new LimitedInt();li.TheValue 0;return li;}public static LimitedInt operator -(LimitedInt x,LimitedInt y){LimitedInt li new LimitedInt();li.TheValue x.TheValue - y.TheValue;return li;}public static LimitedInt operator (LimitedInt x, double y){LimitedInt li new LimitedInt();li.TheValue x.TheValue (int)y;return li;}private int _theValue 0;public int TheValue{get { return _theValue; }set{if (value MinValue)_theValue 0;else_theValue value MaxValue ? MaxValue : value;}}
}class Program
{static void Main(){LimitedInt li1 new LimitedInt();LimitedInt li2 new LimitedInt();LimitedInt li3 new LimitedInt();li1.TheValue 10;li2.TheValue 26;Console.WriteLine($li1:{li1.TheValue}, li 2:{li2.TheValue});li3 -li1;Console.WriteLine($-{li1.TheValue}{li3.TheValue});li3 li2 - li1;Console.WriteLine(${li2.TheValue}-{li1.TheValue}{li3.TheValue});li3 li1 - li2;Console.WriteLine(${li1.TheValue}-{li2.TheValue}{li3.TheValue});}
}代码运行结果 Image 7.结构
7.1结构体的感念。
结构是程序员定义的数据类型与类非常类似。它们有数据成员和函数成员。虽然与类相似但是结构有许多重要的区别。最重要的区别是
1类是引用类型而结构是值类型
2结构是隐式密封的这意味着不能从它们派生其他结构。
声明结构的语法与声明类相似。
关键字
struct StructName
{
MemberDeclarations
}
代码如下
using System;
class Program
{struct Point{public int x;public int y;}static void Main(){Point node;node.x 1; node.y 1;Console.WriteLine($frist point:({node.x},{node.y}));}
}7.2结构构造函数与析构函数
跟类的构造函数基本一致但要注意要调用构造函数则必须要使用new运算符
直接上代码
using System;
class Program
{struct Point{public int x;public int y;public Point(int _x 0 ,int _y 0){x _x;y _y;}}static void Main(){Point node1;Point node2 new Point();node1.x 1; node1.y 1;Console.WriteLine($frist point:({node1.x},{node1.y}));Console.WriteLine($second point:({node2.x},{node2.y}));}
}运行结果 Image 7.3属性与字段初始化语句
在声明结构体时不允许使用实例属性和字段初始化语句如下所示。
struct Simple
{public int x40;//编译错误public int y10;//编译错误public int prop1{get;set;}5;//编译错误
}但是结构体的静态属性和静态字段都可以在声明结构体时进行初始化即使结构体本身不 是静态的.
8.枚举
8.1枚举
枚举是由程序员定义的类型与类或结构一样。
1与结构一样枚举是值类型因此直接存储它们的数据而不是分开存储成引用和数
据。 2枚举只有一种类型的成员命名的整数值常量。
下面的代码展示了一个示例声明了一个名称为 Traffictight 的新枚举类型它含有3个成 员。注意成员声明列表是逗号分隔的列表在枚举声明中没有分号。 关键字枚举名称
enum Trafficlight
{Green, //逗号分隔没有分号Yellow, //逗号分隔没有分号Red
}每个枚举类型都有一个底层整数类型默认为int。这里跟C一致
1每个枚举成员都被赋予一个底层类型的常量值。
2在默认情况下编译器对第一个成员赋值为0对每一个后续成员赋的值都比前一个
成员多1。
8.2设置底层类型和显示值
可以把冒号和类型名放在枚举名之后这样就可以使用int以外的整数类型。类型可以是任 何整数类型。所有成员常量都属于枚举的底层类型。
enum TrafficLight : ulong
{……
}成员常量的值可以是底层类型的任何值。要显式地设置一个成员的值在枚举声明中的变量 名之后使用初始化表达式。尽管不能有重复的名称但可以有重复的值如下所示。
enum TrafficLight
{
Green10,
Yellow15,
Red15//重复的值
}8.3关于位标识
一般用法 * 确定需要多少个位标志并选择一种有足够多位的无符号类型来保存它。
确定每个位位置代表什么并给它们一个名称。 声明一个选中的整数类型的枚举 每个成员由一个位位置表示。使用按位或 | 运算符设置保持该位标志的字中适当的位。使用按位与 运算符 或 HasFlag 方法解开位标志。
例可以使用HasFlag()函数可以判断标志字是否包含特定位标志会对结果真假的bool值
class Program
{[Flags]enum MarkTest{first 0x01, second 0x02, third 0x04, fourth 0x08}static void Main(){MarkTest ops MarkTest.second | MarkTest.third;bool useSecond ops.HasFlag(MarkTest.second);bool useFourth ops.HasFlag(MarkTest.fourth);MarkTest testFlag MarkTest.second MarkTest.third;bool useSecondAndThird ops.HasFlag(testFlag);WriteLine(useSecondAndThird);WriteLine(useSecond);WriteLine(useFourth);}
}9.委托
9.1委托的概念[请把委托看成一个类型安全的C的函数指针但有所不同]
可以认为委托是持有一个或多个方法的对象。当然一般情况下你不会想要“执行”一个对象 但委托与典型的对象不同。可以执行委托这时委托会执行它所“持有”的方法。同时委托是 引用类型。
下面来看细节。委托和类一样是一种用户定义类型。但类表示的是数据和方法的集合而 委托则持有一个或多个方法以及一系列预定义操作。可以通过以下操作步骤来使用委托。
1声明一个委托类型。委托声明看上去和方法声明相似只是没有实现块。
2使用该委托类型声明一个委托变量。
3创建一个委托类型的对象并把它赋值给委托变量。新的委托对象包含指向某个方法的引用这个方法的签名和返回类型必须跟第一步中定义的委托类型一致。
4你可以选择为委托对象添加其他方法。这些方法的签名和返回类型必须与第一步中定义的委托类型相同。
5在代码中你可以像调用方法一样调用委托。在调用委托的时候其包含的每一个方法 都会被执行。
你可以把delegate看作一个包含有序方法列表的对象这些方法具有相同的签名和返回类 型
1方法的列表称为调用列表。
2委托持有的方法可以来自任何类或结构只要它们在下面两方面匹配
委托的返回类型
委托的签名(包括ref和out修饰符)。
调用列表中的方法可以是实例方法也可以是静态方法。
3在调用委托的时候会执行其调用列表中的所有方法。
我们将从下面的示例代码开始。
1代码开始部分声明了一个委托类型MyDel(没错是委托类型不是委托对象。我们很快 就会介绍这一点)。
2Program类声明了3个方法PrintLow、PrintHigh和Main。接下来要创建的委托对象 将持有PrintLow或PrintHigh方法但到底使用哪个要到运行时才能确定。
3Main声明了一个局部变量del它将持有一个Mybel类型的委托对象的引用。这并不 会创建对象只是创建持有委托对象引用的变量在几行之后便会创建这个委托对象并将 其赋值给这个变量。
4Main创建了一个Random类的对象Random是一个随机数生成器类。接着程序调用 该对象的Next方法将99作为方法的输入参数。这会返回一个介于0到99之间的随机整 数并将这个值保存在局部变量 randomValue 中。
5下面一行检查返回并存储的随机值是否小于50。(注意我们使用三元条件运算符来返 回两个委托之一。)如果该值小于50就创建一个MyDel委托对象并初始化让它持有 PrintLow方法的引用。否则就创建一个持有PrintHigh方法的引用的MyDel委托对象。
6最后Main执行委托对象del这将执行它持有的方法(Printlow或 PrintHight )。
代码
using System;delegate void MyDel(int value);class Program
{void PrintLow(int value){Console.WriteLine(${value} - Low Value);}void PrintHigh(int value){Console.WriteLine(${value} - High Value);}static void Main(){Program program new Program();MyDel del;Random rand new Random();int randomValue rand.Next(99);del randomValue 50 ? new MyDel(program.PrintLow) : new MyDel(program.PrintHigh);del(randomValue);}
}运行结果 Image 9.2 声明委托类型
委托类型必须在被用来创建变量以及类型的对象之前声明。如下示例代码声明了委托类型。
形如
delegate void MyDel (int x);
关键字 签名注虽然委托类型声明看上去和方法的声明一样但它不需要在类内部声明因为它是类型声明。
9.3创建委托变量
委托是引用类型、因此有引用和对象。在委托类型声明之后我们可以声明变量并创建类型的对象。如下代码演示了委托类型的变量声明
形如
MyDel delVar;
委托类型 变量有两种创建委托对象的方式第一种是使用带new运算符的对象创建表达式如下面的代码所示。new运算符的操作数的组成如下。 1委托类型名。 2一组圆括号其中包含作为调用列表中第一个成员的方法的名称。 该方法可以是实例方法或静态方法。
形如
delVar new MyDel( myInstObj.MyM1 );//创建委托并保存引用
dVarnew MyDel (SClass.OtherM2);//创建委托并保存引用
静态方法
我们还可以使用快捷语法它仅由方法说明符构成如下面的代码所示。这段代码和之前的代码是等价的。这种快捷语法能够工作是因为在方法名称和其相应的委托类型之间存在隐式转换。 形如
delVarmyInstObj.MyM1;//创建委托并保存引用
dVar SClass.0therM2;//创建委托并保存引用
9.4组合委托
委托可以使用额外的运算得来“组合”。这个运算最终会创建一个新的委托其调用列表连接了作为操作数的两个委托的调用列表副本。
例如
MyDel delAmyInstObj.MyM1;
MyDel delBSClass.OtherM2;
MyDel delC delA delB;//组合调用列表尽管术语组合委托(combining delegate)让我们觉得好像操作数委托被修改了但其实它们并没有被修改。事实上委托是恒定的。委托对象被创建后不能再被改变。
9.5为委托添加方法
C#提供了看上去可以为委托添加方法的语法即使用运算符。
MyDel delVar inst.MyM1;delVar SC1.m3;delVar X.Act;在使用运算符时实际发生的是创建了一个新的委托其调用列表是左边的委托加上右边方法的组合。然后将这个新的委托赋值给delVar。
你可以为委托添加多个方法。每次添加都会在调用列表中创建一个新的元素。
9.6 为委托移除方法
可以使用-运算符从委托移除方法。如下代码演示了--运算符的使用
与为委托添加方法一样其实是创建了一个新的委托。新的委托是旧委托的副本——只是没有了已经被移除方法的引用。
如下是移除委托时需要记住的一些事项。
1如果在调用列表中的方法有多个实例-运算符将从列表最后开始搜索并且移除第一个与方法匹配的实例。
2试图删除委托中不存在的方法将无效。
3试图调用空委托会抛出异常。可以通过将委托和null进行比较来判断委托的调用列表是否为空。如果调用列表为空则委托是null。
代码
using System;delegate void MyDel(int value);class Program
{void PrintLow(int value){Console.WriteLine(${value} - Low Value);}void PrintHigh(int value){Console.WriteLine(${value} - High Value);}static void Main(){Program program new Program();MyDel del new MyDel(program.PrintHigh);int randomValue 121;del program.PrintLow;del - program.PrintHigh;del(randomValue);}
}运行结果 Image 9.7调用委托
1可以通过两种方式调用委托。一种是像调用方法一样调用委托另一种是使用委托的Invoke方法。
2如下面的代码块所示可以将参数放在调用的圆括号内。用于调用委托的参数作用于调用列表中的每个方法(除非其中一个参数是输出参数稍后将介绍)。
3如果一个方法在调用列表中多次出现则在调用委托时每次在列表中遇到该方法时都会调用它。
4调用时委托不能为空(null)否则将引发异常。可以使用if语句进行检查也可以使用空条件运算符和Invoke方法。
9.8
剩下包括带返回值的委托带引用参数的委托的使用方法与上面一致
9.9匿名方法以及Lambda表达式
匿名方法样例
using System;delegate void MyDel(ref int value);
class Program
{void add_10_1(ref int x){x 10;}static void Main(){Program program new Program();MyDel del delegate (ref int x) { x 10; };int num 0;Console.WriteLine($number is {num});program.add_10_1(ref num);Console.WriteLine($number is {num});del(ref num);Console.WriteLine($number is {num});}
}我们可以在如下地方使用匿名方法。
1声明委托变量时作为初始化表达式。
2组合委托时在赋值语句的右边。
3为委托增加事件时在赋值语句的右边。第15章会介绍事件。
匿名方法表达式的语法包含如下组成部分。
1delegate类型关键字。
2参数列表如果语句块没有使用任何参数则可以省略。
3语句块它包含了匿名方法的代码。
delegate ( Parameters ){ ImplementationCode }
关键字参数列表 语句块
返回类型 匿名方法不会显式声明返回值。然而实现代码本身的行为必须通过返回一个与委托的返回类型相同的值来匹配委托的返回类型。如果委托有void类型的返回值匿名方法就不能返回值。
Lambda表达式
C#3.0引入了Lambda表达式
简化了匿名方法的语法从而避免包含这些多余的信息。我们可能会希望使用Lambda表达式来替代匿名方法。其实如果先引入了Lambda表达式那么就不会有匿名方法。
在匿名方法的语法中delegate关键字有点多余因为编译器已经知道我们在将方法赋值给委托。我们可以很容易地通过如下步骤把匿名方法转换为Lambda表达式
1删除delegate关键字
2在参数列表和匿名方法主体之间放置Lambda运算符。Lambda运算符读作“goes to”。
如下代码演示了这种转换。第一行演示了将匿名方法赋值给变量del。第二行演示了同样的匿名方法在被转换成Lambda表达式之后赋值给了变量let。
MyDel del delegate(int x){{return x1;};//匿名方法
MyDel let (int x){ return x 1;} ;//Lambda表达式
这种简单的转换少了一些多余的东西看上去更简洁了但是只省了6个字符。然而编译器可以推断更多信息所以我们可以进一步简化Lambda表达式如下面的代码所示。
1编译器还可以从委托的声明中知道委托参数的类型因此Lambda表达式允许省略类型参数如le2的赋值代码所示。
带有类型的参数列表称为显式类型。
省略类型的参数列表称为隐式类型。
2如果只有一个隐式类型参数我们可以省略两端的圆括号如le3的赋值代码所示。3最后Lambda表达式允许表达式的主体是语句块或表达式。如果语句块包含了一个返回 语句我们可以将语句块替换为return关键字后的表达式如le4的赋值代码所示。
MyDel deldelegate(int x){return x1;};...//匿名方法
MyDel le1 (int x){ return x1;}; //Lambda表达式
MyDel le2 (x) {return x1;} ; //Lambda表达式
MyDel le3 x {return x 1;} ; //Lambda表达式
MyDel le4 x x 1; //Lambda表达式
