static void Main2()
{
Del2 o1 = (a, b) => a + b;
Console.WriteLine(o1(1, 2));
Del3 o3 = (a, b) => b > a;
Console.WriteLine(o3(1, 2));
Del4 obj4 = a => a.Basic;
Console.WriteLine(obj4(new Emp {
Basic = 1234
}));
Del5 obj5 = a => a.Basic > 10000;
Console.WriteLine(obj5(new Emp {
Basic = 12345
}));
Console.ReadLine();
}
public Form1()
{
InitializeComponent();
startBC();
graphOpened = false;
expressionTextBox.Select();
grafoveOkno = null;
InitializeTooltips();
pamet = new string[10];
delButtons = new Button[7];
for (int i = 0; i < 10; i++)
{
pamet[i] = "Memory " + (1 + i).ToString();
}
memoryComboBox.SelectedIndex = 0;
delButtons[0] = Del0;;
delButtons[1] = Del1;;
delButtons[2] = Del2;;
delButtons[3] = Del3;;
delButtons[4] = Del4;;
delButtons[5] = Del5;;
delButtons[6] = Del6;;
Del0.Hide();
Del1.Hide();
Del2.Hide();
Del3.Hide();
Del4.Hide();
Del5.Hide();
Del6.Hide();
favButtons = new List <Button>();
}
public StartScreen()
{
InitializeComponent();
// Instantiate the delegate.
handler = makeVisible;
join = joining;
start = starting;
invisible = makeInvisible;
}
public void HasTarget_Instance ()
{
DelegateTest dt = new DelegateTest ();
dt.int_field = 5;
Del3 d = (Del3)Delegate.CreateDelegate (typeof (Del3), dt, typeof (DelegateTest).GetMethod ("method3"));
Assert.AreEqual (10, d (5));
}
public int IndexOf(ToolStripItem item)
{
if (this.InvokeRequired)
{
Del3 del = new Del3(IndexOf);
IAsyncResult result = this.BeginInvoke(del, new object[] { item });
return((int)this.EndInvoke(result));
}
else
{
return(Items.IndexOf(item));
}
}
static void Main(string[] args)
{
// Del1 del1 = Test1;
// Del1 del1 = delegate() { };
//=>goes to:去执行
//Del1 del1 = () => { };
//Del2 del2 = Test1;
//Del2 del2 = delegate(string name) { };
// Del2 del2 = (name) => { };
//Del3 del3 = Test1;
//Del3 del3 = delegate(string name) { return 100; };
Del3 del3 = (name) => { return(100); };
}
static void Main(string[] args)
{
Del1 d = delegate()
{
Console.WriteLine("Display MEthod");
};
d();
Del2 d2 = delegate(int n)
{
Console.WriteLine($"number is {n}");
};
d2(5);
Del3 d3 = delegate(string str)
{
return(str.ToUpper());
};
Console.WriteLine(d3("hello world"));
Del4 d4 = delegate()
{
return(DateTime.Now.ToString());
};
Console.WriteLine(d4());
int x = 10;
Del1 d5 = delegate()
{
Console.WriteLine(x);
};
d5();
}
static void Main()
{
Del2 o = Display;
o("a");
Del3 o3 = Add;
int ans = o3(10, 20);
Console.WriteLine(ans);
Del1 o4 = class2.Show;
o4();
class2 oCls2 = new class2();
Del1 o5 = oCls2.Show2;
o5();
Console.ReadLine();
}
/// <summary>
/// Lambda表达式是一种可用于创建委托或表达式目录树类型的匿名函数，简单来说Lambda是牛名函数。
/// 表达式目录树类似于这样(m, n) => m * n + m + n + 2;
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
try
{
//
Del3 myTest1 = () => Test();
myTest1.Invoke();
//
Del3 myTest2 = () => Test2();
myTest2.Invoke();
//
Del3 myTest3 = () => Test3();
myTest3.Invoke();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
Console.ReadLine();
}
//lambda语句本质就是一个匿名函数
static void Main(string[] args)
{
//Del1 del1 = delegate() { Console.WriteLine("无参数，无返回值"); };
Del1 del1 = () => { Console.WriteLine("无参数，无返回值"); };
//Del2 del2 = delegate(string name){int a=name.Length ;Console .WriteLine ("有参数,字符串长{0}",a);};
Del2 del2 = (string name) => { int a = name.Length; Console.WriteLine("有参数,字符串长{0}", a); };
//Del3 del3 = delegate(string name) { int a = name.Length; return a; };
Del3 del3 = (string name) => { int a = name.Length; return(a); };
del1();
del2("zhangsan");
Console.WriteLine(del3("zhangsan"));
//关于Lambda在参数中的应用
List <int> listNums = new List <int>()
{
1, 2, 3, 4, 5, 6, 7, 8, 9,
};
listNums.RemoveAll(n => n > 7);//见提示Precidate <int> match，就是使用lambda输入一个条件；
foreach (int item in listNums)
{
Console.WriteLine(item);
}
IEnumerable <int> aa = listNums.Where(n => n > 3);//根据提示写的返回值类型
foreach (int item in aa)
{
Console.WriteLine(item);
}
Console.ReadKey();
}
static void Main(string[] args)
{
#region MyRegion
Del handler = DelegateMethod;
handler("Hello");
MethodWithCallback(1, 2, handler);
MethodWithCallback(3, 4, handler);
MethodWithCallback(5, 6, handler);
MethodClass obj = new MethodClass();
Del d1_1 = obj.Metrhod1;
Del d1_2 = obj.Metrhod2;
Del d1_3 = DelegateMethod;
Del allMethodsDelegate = d1_1 + d1_2;
allMethodsDelegate += d1_3;
int invocationCount = allMethodsDelegate.GetInvocationList().Length;//.GetLength(0);
Console.WriteLine($"count:{invocationCount}");
Del2 d2 = obj.MultipyNumbers;
Console.WriteLine("Invoking the delegate using 'MultiplyNumbers':");
for (int i = 1; i <= 5; i++)
{
d2(i, 2);
}
Console.WriteLine("委托映射到静态方法和实例方法，并返回来自两种方法的具体信息:");
Del3 d3_1 = obj.InstancaMethod;
d3_1();
Del3 d3_2 = MethodClass.StaticMethod;
d3_2();
Console.WriteLine("multicast delegates(多播委托):");
CustomDel hiDel, byeDel, multiDel, multiMinusHiDel;
hiDel = Hello;
byeDel = Goodbye;
multiDel = hiDel + byeDel;
multiMinusHiDel = multiDel - hiDel;
Console.WriteLine("Invoke delegate hiDel:");
hiDel("A");
Console.WriteLine("Invoke delegate byDel:");
byeDel("B");
Console.WriteLine("Invoke delegate multiDel:");
multiDel("C");
Console.WriteLine("Invoke delegate multiMinusHiDel:");
multiMinusHiDel("D");
#endregion
#region Func Delegate
Console.WriteLine("\nFunc Delegate:\n");
OutPutTarget output = new OutPutTarget();
// 调用自定义委托：WriteMethod
//WriteMethod methodCall = output.SendToFile;
// 调用Func<TResult>
//Func<bool> methodCall = output.SendToFile;
// 使用 Func<TResult> 委托与 C# 中的匿名方法
//Func<bool> methodCall = delegate () { return output.SendToFile(); };
// lambda 表达式 Func<T, TResult> 委托
Func <bool> methodCall = () => output.SendToFile();
if (methodCall())
{
Console.WriteLine("Success!");
}
else
{
Console.WriteLine("File write operation failed");
}
Console.WriteLine("\nFunc Delegate示例:\n");
LazyValue <int> lazyOne = new LazyValue <int>(() => ExpensiveOne());
LazyValue <long> lazyTwo = new LazyValue <long>(() => ExpensiveTwo("hello"));
Console.WriteLine("LazyValue objects has been created.");
Console.WriteLine(lazyOne.Value);
Console.WriteLine(lazyTwo.Value);
#endregion
#region Func<T1, T2, TResult> 委托
Console.WriteLine("Func<T1, T2, TResult> 委托:");
Func <string, int, bool> predicate = (str, index) => str.Length == index;
string[] words = { "orange", "apple", "Article", "elephant", "star", "and" };
IEnumerable <string> aWords = words.Where(predicate).Select(str => str);
foreach (string word in aWords)
{
Console.WriteLine(word);
}
#endregion
}
private static void Main()
{
#region Б.
// Демонстрация контрвариантности в делегате Action.
Action <Cat> action = TestAction;
// Демонстрация контрвариантности и ковариантности в делегате Func.
Func <MiniCat, Animal> func = TestFunc;
// Демонстрация контрвариантности в делегате Predicate.
Predicate <Dog> predicate = TestPredicate;
// Демонстрация контрвариантности в интерфейсе IComparable.
IComparable <Client <int> > inter = new Person <int>(123);
// Демонстрация контрвариантности в интерфейсе IComparer.
IComparer <Car <int> > car = new Transport <int>(12);
#endregion
#region В.
// Ошибка, потому что интерфейс IFruit не является ковариантным.
IFruit <B <int> > ifruit1 = new B <C <int> >();
// Ошибка, потому что интерфейс IFruit не является контрвариантным.
IFruit <B <int> > ifruit2 = new B <A <int> >();
// Нет ошибки, потому что интерфейс ICar является ковариантным.
ICar <B <int> > icar1 = new B <C <int> >();
// Ошибка, потому что интерфейс ICar не является контрвариантым.
ICar <B <int> > icar2 = new B <A <int> >();
// Ошибка, потому что интерфейс IPerson не является ковариантным.
IPerson <B <int> > Iperson1 = new B <C <int> >();
// Нет ошибки, потому что интерфейс IPerson является контрвариантым.
IPerson <B <int> > Iperson2 = new B <A <int> >();
#endregion
#region Г.
// Две ошибки, потому что делегат Del1 не является
// ни ковариантным, ни контрвариантынм.
Del1 <A2> del1 = Del1 <A1>;
Del1 <A2> del2 = Del1 <A3>;
// Нет ошибки, потому что делегат Del2 является контрвариантным.
Del2 <A2> del3 = Del2 <A1>;
// Ошибка, потому что делегат Del2 не является контрвариантным.
Del2 <A2> del4 = Del2 <A3>;
// Ошибка, потому что делегат Del3 не является контрвариантным.
Del3 <A2> del6 = Del3 <A1>;
// Нет ошибки, потому что делегат Del3 является ковариантным.
Del3 <A2> del5 = Del3 <A3>;
#endregion
#region Д.
// 1) Ковариантность и контрвариантность
// обеспечивают большую гибкость в назначении и использовании универсальных типов.
// 2) Поддержка ковариации и контрвариантности для групп методов позволяет
// сопоставить сигнатуры методов с типами делегатов. За счет этого вы можете
// назначать делегатам не только методы с совпадающими сигнатурами, но и методы,
// которые возвращают более производные типы (ковариация) или принимают параметры
// с менее производными типами (контрвариантность), чем задает тип делегата.
// 3) Вся суть вариантности состоит в использовании в производных типах
// преимуществ наследования. Известно, что если два типа связаны
// отношением "предок-потомок", то объект потомка может храниться в переменной
// типа предка. На практике это значит, что мы можем использовать для
// каких-либо операций объекты потомка вместо объектов предка.
// Тем самым, можно писать более гибкий и короткий код
// для выполнения действий поддерживаемых разными потомками с общим предком.
#endregion
}
private static void Main(string[] args)
{
//Del myDel = new Del(MyDel); //explicit delegate creation
Del myDel;
var nasobic = new Nasobic();
nasobic.Nasob(Method);
nasobic.Nasob(delegate(int i) { return(i); });
nasobic.Nasob(i => i / 2);
myDel = nasobic.Zdvojnasob;
myDel = Nasobic.Podel;
nasobic.Zdvojnasob(3);
//var a = myDel.Invoke(3);
Del myDel20 = nasobic.Zdvojnasob;
Del myDel22 = delegate(int x) { return(x / 2); };
Del myDel23 = (int x) =>
{
int y = x / 2;
return(x);
};
Del myDel24 = x =>
{
int y = x / 2;
return(x);
};
Del2 myDel224 = (x, y) =>
{
return(x / 2 + 12);
};
Del3 myDel31 = (out int x, string y) =>
{
x = 0;
return(x);
};
Del myDel25 = x => x / 2;
Del myDel26 = x =>
{
return(x / 2);
};
Del myDel2 = MyDel; //named function
Del myDel3 = delegate { return(3); }; //delegate + anonymous function
Del myDel4 = delegate { return(3); }; //delegate + anonymous function with implicit parameters
Del myDel5 = i => { return(3); }; //statement lambda
Del myDel6 = i => 3; //lambda expression
Expression <Del> myExpression = x => x + 2;
int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
int oddNumbers = numbers.Count(n => n % 2 == 1);
string s;
Console.WriteLine("bla");
}
