static void Main(string[] args)
{
Console.WriteLine("GetAStringDemo");
int x = 40;
//委托绑定方法
GetAString firstStringMethod = new GetAString(x.ToString); //不能写成x.ToString() 这个是方法的调用 需要的是传递方法本身
GetAString secondStringMethod = x.ToString; //可以使用委托推断 给委托绑定方法 两种方式 C#编译器创建的代码是一样的
//委托调用 这两种方式相同
firstStringMethod();
WriteLine($"firstStringMethod() 方式调用： { firstStringMethod()}");
firstStringMethod.Invoke();
WriteLine($"firstStringMethod.Invoke() 方式调用： { firstStringMethod.Invoke()}");
var balance = new Currency(34, 50);
//委托指向实例方法
firstStringMethod = balance.ToString;
WriteLine($"balance.ToString is {firstStringMethod()}");
//委托指向静态方法
firstStringMethod = Currency.GetCurrencyUnit;
WriteLine($"Currency.GetCurrencyUnit is {firstStringMethod()}");
//本节只是给委托绑定方法，使用委托调用方法
//没有设计把文档当作参数，传递给其他方法
//也没有体现委托的方便之处
ReadKey();
}
static void Main(string[] args)
{
int x = 40;
//委托在语法上总是接受一个参数的构造函数，这个参数就是委托引用的方法。这个方法必须匹配最初定义委托时的签名。
GetAString firstStringMethod = new GetAString(x.ToString);
Console.WriteLine("string is {0}", firstStringMethod());
//下面跟上面效果一样
Console.WriteLine("string is {0}", firstStringMethod.Invoke());
//把方法传递给委托变量也可以
GetAString secondString = GoodJob;
Console.WriteLine("second string is {0}", secondString());
//这样两个方法都会执行，这个叫多播委托
secondString += BadJob;
Console.WriteLine("third string is {0}", secondString());
secondString -= BadJob;
Console.WriteLine("fourth string is {0}", secondString());
GetAString Money1 = Money.GetMoney;
Console.WriteLine("get money is {0}", Money1());
Money m = new Money();
Money1 = m.SendMoney;
Console.WriteLine("send money is {0}", Money1());
Console.ReadKey();
}
static void Main(string[] args)
{
int x = 40;
int y = 20;
string s = x.ToString();
Console.WriteLine(s);
// 实例委托
GetAString getAString = new GetAString(x.ToString);
// 通过委托调用一个方法，和直接调用这个方法是一样的
string str = getAString(); // 通过委托实例调用x中的tostring方法
Console.WriteLine(s);
// 调用方法
// 1. 赋值给委托
GetAString a = x.ToString;
Console.WriteLine(a());
// 2. Invoke 通过Invoke方法调用a所引用的方法
Console.WriteLine(a.Invoke());
// 使用委托类型作为方法的参数
PrintString method = Method1;
PrintStr(method);
method = Method2;
PrintStr(method);
Console.ReadKey();
}
static void Main()
{
int s = 20;
GetAString firstStringMethod = new GetAString(s.ToString);
Console.WriteLine(firstStringMethod());
Console.WriteLine(firstStringMethod.Invoke());
sbyte o = 127;
//checked { ++o; }
++o;
Console.WriteLine(o);
int r=9;
Console.WriteLine(R(ref r));
Console.WriteLine(DayOfWeek.Friday);
Console.WriteLine(r);
int z;
Console.WriteLine("z+a=out "+ F(out z));
const int n = 6;
int c = 4;
Program p = new Program();
Console.WriteLine("gET tYPE: "+p.GetType(), p.MemberwiseClone());
Console.WriteLine(p._a);
Console.WriteLine(b);
Console.WriteLine(c);
Console.WriteLine(c.GetType());
//Console.WriteLine(F());
for(int i = 0; i < 3; i++)
{
int d = 5;
Console.WriteLine(d);
}
//Console.ReadLine();
return;
}
static void Main(string[] args)
{
int x = 10;
GetAString GetIntAsString = new GetAString(x.ToString);
Console.WriteLine("The number is {0}", GetIntAsString.Invoke());
Console.ReadLine();
}
/// <summary>
/// 测试委托
/// </summary>
private static void test01()
{
int x = 40;
//a指向了x的tostring方法
GetAString a = new GetAString(x.ToString);//注意，这里是将x.ToString方法的引用传递给委托
Console.WriteLine(a.Invoke());
Console.WriteLine(a());
Console.ReadKey();
}
/// <summary>
/// 测试委托
/// </summary>
private static void test02()
{
int x = 40;
//a指向了x的tostring方法
GetAString a = x.ToString; //注意，这里是将x.ToString方法的引用传递给委托
Console.WriteLine(a.Invoke()); //通过invoke方法来调用a所引用的方法
Console.WriteLine(a());
Console.ReadKey();
}
public static void Main(string[] args)
{
int num = 400;
//使用委托类型创建实例
GetAString sasa = new GetAString(num.ToString); //sasa指向了num中的tostring方法
GetAString dada = num.ToString; //第二种赋值方法；
string kk = dada.Invoke(); //通过委托实例去调用num中的tostring方法；
Console.WriteLine(sasa()); //通过委托类型是调用一个方法，跟直接调用这个方法作用是一样的
GetAString dde = new GetAString(num.ToString);
Action a = PrintString; //action是系统内置（预定义）的一个委托类型，它可以指向一个没有返回值，没有参数的方法；
Action <int> a1 = PrintString; //定义了一个委托类型，这个类型可以指向一个没有返回值，有一个int参数的方法
Action <string> a2 = PrintString; //定义了一个委托类型，这个类型可以指向一个没有返回值，有一个string参数的方法，在这里系统hi自动寻找匹配的方法；
//Action可以后面通过泛型去指定action指向的方法的多个参数的类型，参数的类型跟action后面声明的委托是对应着的
Func <int> fu = State; //func中的泛型类型<>指定的是方法的返回值类型
Func <string, string> fu2 = State;
Func <string, int, string> fu3 = State; //func后面必须指定一个返回值类型，参数类型可以有0~16个
//先写参数类型，最后一个是返回值类型；
Console.WriteLine(fu());
Console.WriteLine(fu2("aiyanhe"));
Console.WriteLine(fu3("aitianyi", 100));
//多播委托
duobo ll = PrintString;
ll += PrintString1;
ll += PrintString2; //一个委托有多个方法，叫做多播委托；
ll();
ll -= PrintString; //减去一个指定委托
ll -= PrintString1;
ll -= PrintString2;
if (ll != null)
{
ll();//如果委托为空，执行时会报错；
}
ll = PrintString;
ll += PrintString1;
ll += PrintString2;
Delegate[] sss = ll.GetInvocationList();//新建一个委托数组来接受
foreach (var item in sss)
{
item.DynamicInvoke();
}
Console.ReadKey();
}
static void Main(string[] args)
{
int i = 40;
// 创建并初始化委托实例，将ToString()方法的地址赋予委托变量
// 委托总是接受一个参数的构造函数
GetAString firstStringMethod = new GetAString(i.ToString);
Console.WriteLine("firstStringMethod() is {0} ", firstStringMethod());
// 委托实例提供圆括号与调用委托类的Invoke()方法完全相同
Console.WriteLine("firstStringMethod() is {0} ", firstStringMethod.Invoke());
// 委托推断：编译器解析委托实例为需要的特定类型
GetAString secondStringMethod = i.ToString;
Currency balance = new Currency(34, 50);
// firstStringMethod委托调用一个实例方法
firstStringMethod = new GetAString(balance.ToString);
Console.WriteLine("String is {0} ", firstStringMethod());
// firstStringMethod委托调用一个静态方法
firstStringMethod = new GetAString(Currency.GetCurrencyUint);
Console.WriteLine("String is {0} ", firstStringMethod());
Console.Read();
}