委托的概念
委托是一种可以指向方法的数据类型(委托类型),可以声明委托类型的变量
数据类型指的是类似类的,前面提到过一切皆对象,委托就是将方法当作对象使用
声明委托
delegate 返回值类型 委托类型名称(参数);
创建委托
委托类型 变量 = new 委托类型(方法);
注:方法的参数必须与委托类型的参数一致,方法后面不需要括号,方法后面加括号是调用
简化创建委托
创建委托可以不使用new关键词
委托类型 变量 = 方法;
注:方法后面不可以加括号
注:委托是引用类型,可以为null,如果调用会抛出 NullReferenceException(空引用异常)
使用无返回值的委托
直接代码展示
class MainClass
{
public static void Main(string[] args)
{
MyDelegate del = new MyDelegate(UseDelegate); // 创建委托
del(); // 使用委托
}
public static void UseDelegate()
{
Console.WriteLine("使用无参委托");
}
}
delegate void MyDelegate();
下面同上面是一样的效果
class MainClass
{
public static void Main(string[] args)
{
MyDelegate del = UseDelegate; // 简写创建委托
del();
}
public static void UseDelegate()
{
Console.WriteLine("使用无参委托");
}
}
delegate void MyDelegate();
输出:
使用无参委托
委托相互赋值
class MainClass
{
public static void Main(string[] args)
{
// 委托赋值给委托 需要是同一个委托类型
MyDelegate del = UseDelegate;
MyDelegate my = null;
my = del;
my();
}
public static void UseDelegate()
{
Console.WriteLine("使用无参委托");
}
}
delegate void MyDelegate();
输出:
使用无参委托
有参委托
class MainClass
{
public static void Main(string[] args)
{
MyDelegate myDelegate = UseDelegate; // 创建委托,方法的参数必须与委托的参数一致
myDelegate("Tom-Cat"); // 调用委托
}
public static void UseDelegate(string name)
{
// $"" 里面可以直接写参数,但是需要使用 {参数名}
Console.WriteLine($"My Name Is {name}");
}
}
delegate void MyDelegate(string name);
使用有返回值的委托
class MainClass
{
public static void Main(string[] args)
{
MyDelegate myDelegate = UseDelegate;
int a = myDelegate("Tom-Cat");
Console.WriteLine("返回值: {0}",a);
}
public static int UseDelegate(string name)
{
Console.WriteLine($"My Name Is {name}");
return 1;
}
}
delegate int MyDelegate(string name);
输出:
My Name Is Tom-Cat
返回值: 1
泛型
泛型是用来替代不确定的数据类型,看下面代码
class MainClass
{
public static void Main(string[] args)
{
// 声明类的时候定义数据类型
Persion<string, int, double> p = new Persion<string, int, double>();
p.name = "Tom";
p.age = 10;
p.height = 170.50;
Console.WriteLine("p.name 的数据类型:{0},内容是:{1}",p.name.GetType(),p.name);
Console.WriteLine("p.age 的数据类型:{0},内容是:{1}", p.age.GetType(), p.age);
Console.WriteLine("p.height 的数据类型:{0},内容是:{1}", p.height.GetType(), p.height);
}
}
class Persion<T,T1,T2>
{
public T name;
public T1 age;
public T2 height;
}
输出:
p.name 的数据类型:System.String,内容是:Tom
p.age 的数据类型:System.Int32,内容是:10
p.height 的数据类型:System.Double,内容是:170.5
系统内置泛型委托
- Action 无返回值
class MainClass
{
delegate void A(int i);
public static void Main(string[] args)
{
Action<int> action = Print; // 等价于 下面这一条语句,相比之下不需要自己写 delegate void A(int)
A a = Print;
a(1);
action(1);
}
public static void Print(int i)
{
Console.WriteLine("true");
}
}
输出:
true
true
- Func 有返回值
class MainClass
{
delegate int A(int i);
public static void Main(string[] args)
{
// Func<参数类型1,....,参数类型8,返回值类型>
Func<int,int> action = Print;
A a = Print;
int aValue = a(1);
int bValue = action(9); // 调用的时候写需要进入方法的参数
Console.WriteLine("a(1)的返回值:{0},action(9)的返回值:{1}",aValue,bValue);
}
public static int Print(int i)
{
Console.WriteLine("true");
return i;
}
}
输出:
true
true
a(1)的返回值:1,action(9)的返回值:9
通过VS编译器中的程序集浏览器可以看到这两个委托
从下面这两幅图可以看到,Func是必须有一个返回值的参数,里面的参数可以最多可以有16个;Action可以没有参数,里面的参数最多也是16个
LINQ
LINQ:语言集成查询 (LINQ) 是一系列直接将查询功能集成到 C# 语言的技术统称。
LINQ源数据:从应用程序的角度来看,原始源数据的特定类型和结构并不重要。 应用程序始终将源数据视为 IEnumerable<T> 或 IQueryable<T> 集合。
代码展示:
public static void Main(string[] args)
{
// List 继承了 IEnumerable接口,所以可以使用 Where
List<int> list = new List<int>();
list.Add(4);
list.Add(9);
list.Add(100);
list.Add(50);
// Where()使用了委托,括号里面可以直接使用 lambda表达式,下面会展示怎么使用lambda
foreach (var item in list.Where(i => i > 10))
{
Console.WriteLine(item);
}
}
输出:
100
50
使用数组实现同样的效果:
public static void Main(string[] args)
{
int[] list = { 4, 9, 100, 50 };
foreach (var item in list.Where(i => i > 10))
{
Console.WriteLine(item);
}
}
使用类似数据库的语句查询:
public static void Main(string[] args)
{
int[] list = { 4, 9, 100, 50 };
IEnumerable<int> vs = from item in list where item > 10 select item;
foreach (var item in vs)
{
Console.WriteLine(item);
}
}
lambda
(参数)=>{ 语句; }
匿名方法
当有一个方法只有委托在使用,且只使用一次,就可以使用匿名方法。使用方法看下面代码
class MainClass
{
delegate void Del();
public static void Main(string[] args)
{
// 直接在声明的时候写方法,方法直接用delegate命名,参数必须与委托一致,如果有返回值,需要写return
Del myDelegate = delegate ()
{
Console.WriteLine("匿名方法");
};
}
}
输出:
匿名方法
使用lambda 替代匿名方法
- 无返回值委托
class MainClass
{
delegate void Del();
public static void Main(string[] args)
{
Del myDelegate = () =>
{
Console.WriteLine("匿名方法");
};
}
}
与上面是一样的效果,=> 读作 goes to
class MainClass
{
public static void Main(string[] args)
{
// Action 足够应付大部分无返回值的委托
Action<int> action = (int i) =>
{
Console.WriteLine("匿名方法");
};
}
}
再简写一点
class MainClass
{
public static void Main(string[] args)
{
Action<int> action = (i) =>
{
Console.WriteLine("匿名方法");
};
}
}
如果只有一个参数,多个参数需要写括号
class MainClass
{
public static void Main(string[] args)
{
Action<int> action = i =>
{
Console.WriteLine("匿名方法");
};
}
}
- 有返回值委托
class MainClass
{
public static void Main(string[] args)
{
// 如果使用 delegate 的时候有参数,参数必须声明类型,Action、Func都需要遵守这一条
Func<int, int> func = delegate (int i) {
return i;
};
Console.WriteLine("func({0})的返回值是:{0}",func(9));
}
}
输出:
func(9)的返回值是:9
使用lambda简写
class MainClass
{
public static void Main(string[] args)
{
Func<int, int> func = (int i) =>{
return i;
};
Console.WriteLine("func({0})的返回值是:{0}",func(9));
}
}
再简写
class MainClass
{
public static void Main(string[] args)
{
Func<int, int> func = (i) =>{
return i;
};
Console.WriteLine("func({0})的返回值是:{0}",func(9));
}
}
如果只有一个参数也可以不写括号
class MainClass
{
public static void Main(string[] args)
{
Func<int, int> func = i =>{
return i;
};
Console.WriteLine("func({0})的返回值是:{0}",func(9));
}
}
如果只有方法体只有一条语句,可以省略大括号和return
class MainClass
{
public static void Main(string[] args)
{
Func<int, int> func = i =>i;
Console.WriteLine("func({0})的返回值是:{0}",func(9));
}
}
使用委托实现LINQ的where
class MainClass
{
public static void Main(string[] args)
{
int[] a = { 8, 90, 4, 20 };
// 使用了扩展方法,this关键词修饰的可以不写在括号里面
IEnumerable<int> data = a.MyWhere(i => i > 10);
foreach (var item in data)
{
Console.WriteLine(item);
}
}
}
// 扩展方法是写在静态类里面的静态方法,扩展方法必须有一个参数,且参数使用this关键词修饰
static class A
{
public static IEnumerable<T> MyWhere<T>(this IEnumerable<T> data, Func<T, bool> func)
{
List<T> list = new List<T>();
foreach (var item in data)
{
if (func(item))
{
list.Add(item);
}
}
return list;
}
}
输出:
90
20