public static void Main()
{
GreetingDelegate firstDel, secondDel;
firstDel = new GreetingDelegate(Hello);
secondDel = new GreetingDelegate(Goodbye);
GreetMethod(firstDel, "Cathy");
GreetMethod(secondDel, "Bob");
}
/// <summary> 供应商名称速查选择器
/// </summary>
/// <param name="ContorlName">控件ID</param>
/// <param name="delDataBack">回调函数</param>
public static void SupperNameChoose(TextChooser ContorlName, GreetingDelegate delDataBack)
{
string table = "tb_supplier";
string valueColumn = "sup_full_name";
//设置表和显示字段
ContorlName.SetBindTable(table, valueColumn);
ContorlName.GetDataSourced += new TextChooser.GetDataSourceHandler(Sup_NameBindData);
if (delDataBack != null)
{
ContorlName.DataBacked -= new TextChooser.DataBackHandler(delDataBack);
ContorlName.DataBacked += new TextChooser.DataBackHandler(delDataBack);
}
}
/// <summary> 配件编码速查选择器
/// </summary>
/// <param name="ContorlName">控件ID</param>
/// <param name="delDataBack">回调函数</param>
public static void PartsCodeChoose(TextChooser ContorlName, GreetingDelegate delDataBack)
{
string table = "tb_parts";
string displayColumn = "ser_parts_code";
string valueColumn = "parts_name";
//设置表和显示字段
ContorlName.SetBindTable(table, displayColumn, valueColumn);
ContorlName.GetDataSourced += new TextChooser.GetDataSourceHandler(Parts_CodeBindData);
if (delDataBack != null)
{
ContorlName.DataBacked -= new TextChooser.DataBackHandler(delDataBack);
ContorlName.DataBacked += new TextChooser.DataBackHandler(delDataBack);
}
}
static void Main(string[] args)
{
//create the delegate reference
GreetingDelegate firstDel = new GreetingDelegate(Hello);
GreetingDelegate secondDel = new GreetingDelegate(Goodbye);
firstDel("Ray");
secondDel("Romano");
DelegateChosen(firstDel, "Ray");
DelegateChosen(secondDel, "Romano");
DelegateChosen(secondDel, "Romano");
}
static void Main(string[] args)
{
//总结：我们一般的方法是传入数据 而委托是将其作为参数传给方法。委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。
//1.使用
GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法
// 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
GreetPeople("Jimmy Zhang", delegate1);
Console.WriteLine();
delegate1 -= EnglishGreeting; //取消对EnglishGreeting方法的绑定
// 将仅调用 ChineseGreeting
GreetPeople("张子阳", delegate1);
Console.ReadKey();
//总结：使用委托可以将多个方法绑定到同一个委托变量，当调用此变量时(这里用“调用”这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。
}
// entry point
public static void Main()
{
Person p1 = new Person { Name = "Gary" };
GreetingDelegate gd1 = null;
gd1 += p1.SayHello; // add method to delegate
Console.WriteLine(gd1()); // invoke method in delegate
// alternative syntax to +=
GreetingDelegate gd2 = new GreetingDelegate(p1.SayGoodBye);
Console.WriteLine(gd2());
// plug in a lamdba expression instead (i.e. an anonymous function)
GreetingDelegate gd3 = new GreetingDelegate(() => { return "See you soon " + p1.Name; });
Console.WriteLine(gd3());
}
static void Main(string[] args)
{
Program p = new Program();
DisplayDelegate dd = new DisplayDelegate(Display);
dd.Invoke(3.42f, 5.6f);
SumDelegate sd = new SumDelegate(Sum);
int result = sd.Invoke(60, 90);
Console.WriteLine(result);
GreetingDelegate gd = new GreetingDelegate(p.Greeting);
bool name = gd.Invoke("kavya");
Console.WriteLine(name);
Console.ReadKey();
}
static void Main(string[] args)
{
GreetingDelegate obj = (name) => //Using arrow function then remove keyword delegate, datatype for parameter also removed
{
return("Hello " + name + ", Good Morning");
};
var str = obj.Invoke("nmfairus");
Console.WriteLine(str);
SayHello obj2 = () => { Console.WriteLine("Hello Lambda Expression"); };
obj2.Invoke();
Console.WriteLine("Hello World!");
}
public static void Main()
{
Console.WriteLine("------委托第一种实现方式------");
#region 委托第一种实现方式
GreetPeople("Mark1", EnglishGreeting);
GreetPeople("马云1", ChineseGreeting);
#endregion
Console.WriteLine("------委托第二种实现方式_可以节省一个GreetPeople方法------");
#region 委托第二种实现方式_可以节省一个GreetPeople方法
GreetingDelegate greetingDelegate1, greetingDelegate2;
greetingDelegate1 = EnglishGreeting;
greetingDelegate2 = ChineseGreeting;
greetingDelegate1("Mark2");
greetingDelegate2("马云2");
#endregion
Console.WriteLine("------多个方法绑定到同一个委托,依次调用其所绑定的方法------");
#region 多个方法绑定到同一个委托,依次调用其所绑定的方法
GreetingDelegate greetingDelegate3;
greetingDelegate3 = EnglishGreeting;
greetingDelegate3 += ChineseGreeting;
greetingDelegate3("Mark3");
#endregion
Console.WriteLine("多个方法绑定到同一个委托,依次调用其所绑定的方法_简化版");
#region 多个方法绑定到同一个委托,依次调用其所绑定的方法_简化版
GreetingDelegate greetingDelegate4 = new GreetingDelegate(EnglishGreeting);
greetingDelegate4 += ChineseGreeting;
greetingDelegate4("Mark4");
#endregion
Console.WriteLine("----------------委托取消对某个方法的绑定----------------");
#region 委托取消对某个方法的绑定
greetingDelegate3 -= EnglishGreeting;
greetingDelegate3("马云3");
#endregion
Console.ReadKey();
/************************************************************************/
/* 委托总结:
* 委托是一个类,它定义了方法的类型,使可以讲方法当作另一个方法的参数来进行传递
* 这种将方法动态地赋值给参数的做法,可以避免在程序中大量使用If-Else(Switch)语句,同时使得程序具有更好的可扩展性*/
/************************************************************************/
/************************************************************************/
/* 委托总结2:
* 使用委托可以将多个方法绑定到同一个委托变量，当调用此变量时(这里用“调用”这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。*/
/************************************************************************/
}
static void TestDelegate()
{
GreetPeople("Joe", EnglishGreeting);
GreetPeople("Liming", ChineseGreeting);
GreetingDelegate gd = ChineseGreeting;
gd += EnglishGreeting;
GreetPeople("Bruce", gd);
gd("Doris");
//GreetPeople("Other", OtherGreeting);//wrong func signature
GreetingManager gm = new GreetingManager();
gm.MakeGreet += EnglishGreeting;
gm.MakeGreet += ChineseGreeting;
gm.GreetPeople("JJJJ");
}
static void Main(string[] args)
{
SayHello("Mikiy", EnglishGreeting);//方法名EnglishGreeting作为函数参数
SayHello("林依晨", ChineseGreeting);
Console.WriteLine("---------------------");
//Console.ReadKey();//等待获取任何一个按键按下
Type t = typeof(GreetingDelegate);//t.IsClass可检查一个东东是不是类class
Console.WriteLine(t.IsClass ? "GreetingDelegate是一个类" : "GreetingDelegate不是一个类");
Console.WriteLine("---------------------");
Console.WriteLine("--------实例化委托-------------");
GreetingDelegate gd = new GreetingDelegate(ChineseGreeting);//实例化委托
gd("王麻子");
}
// Use this for initialization
void Start () {
GreetingDelegate delegate1, delegate2;
delegate1 = EnglishGreeting;
delegate2 = ChineseGreeting;
delegate2 += EnglishGreeting;
GreetPeople("Liker", delegate1);
GreetPeople("徐光亮", delegate2);
delegate1("liker");
//----------
GreetingDelegate de1 = new GreetingDelegate(EnglishGreeting);
de1 += ChineseGreeting;//给此魏国变量再绑定一个方法
GreetPeople("徐光亮", de1);
de1 -= EnglishGreeting;//取消对EnglishGreeting的绑定
//仅调用ChineseGreeting
de1 += EnglishGreeting;
GreetPeople("徐光亮", ChineseGreeting);
}
static void Main(string[] args)
{
Console.WriteLine("Adding 'GoodMoring' Reference to a Delegate...");
GreetingDelegate myGreeting = GoodMorning;
// invoking the delegate
Console.WriteLine("Invokin Delegate...");
myGreeting.Invoke("MS");
// Assiging the addressof the another function to the same delegate
Console.WriteLine();
Console.WriteLine("Making Existing Delegate To Point To Another Fuction...");
Console.WriteLine("Replacing With 'GoodNight' Reference...");
myGreeting = new GreetingDelegate(GoodNight);
// Another way of invoking the delegate
Console.WriteLine("Invoking Delegate...");
myGreeting("SM");
}
public static void GreetPeople(string name, GreetingDelegate MakeGreeting)
{
//做些额外的事情，比如初始化之类
//switch(lang)
//{
// case Language.English:
// EnglishGreeting(name);
// break;
// case Language.Chinese:
// ChineseGreeting(name);
// break;
//}
//EnglishGreeting(name);
MakeGreeting(name);
}
public static void Main1(string[] args)
{
// 1、
//GreetManager gm = new GreetManager();
//gm.GreetPeople("Neo", ChineseGreeting);
//gm.GreetPeople("Neo", EnglishGreeting);
// 2、方法可以直接赋值给对应的委托变量。（第一次赋值初始化）
//GreetingDelegate d;
//d = ChineseGreeting;
//d += EnglishGreeting;
//d("Neo");
// 3、委托采用构造函数初始化时，必须传入对应的方法。
//GreetingDelegate d = new GreetingDelegate(ChineseGreeting);
//d += EnglishGreeting;
//// 委托变量可以赋值和注册
//GreetingDelegate d2;
//d2 = d;
//d("Neo");
//d2("Neo");
// 4、一个委托变量可以绑定多个方法，然后将这个委托变量作为函数参数，就可以按方法绑定顺序执行多个方法。
//GreetManager gm = new GreetManager();
//gm.d = ChineseGreeting;
//gm.d += EnglishGreeting;
//// 在类内部调用最终执行的委托，这个委托为最终要执行的委托。
//gm.GreetPeople("Neo");
// 5、事件是对委托变量的进一步封装，类似于属性对字段的封装，用于保护委托不被外界修改。
// 因此事件的权限很低，只能被注册+=和注销-=方法。即事件永远只能出现在注册+=和注销-=的左边。
// 事件event本身也是一个委托类型，所以它可以直接注册方法。
GreetManager gm = new GreetManager();
GreetingDelegate d = new GreetingDelegate(ChineseGreeting);
//gm.MarkGreet = ChineseGreeting;
// 委托可以注册到事件。
gm.MarkGreet += d;
gm.MarkGreet += EnglishGreeting;
gm.GreetPeople("Neo");
}
static void Main(string[] args)
{
// 1) named method
GreetingDelegate gd1 = new GreetingDelegate(DelegateDemo.DoWork);
gd1("named method");
// 2) anonymous method
GreetingDelegate gd2 = delegate(string s)
{
System.Console.WriteLine(s);
};
gd2("anonymous methods");
// 3) lambda expressions
GreetingDelegate gd3 = (s)=>
{
System.Console.WriteLine(s);
};
gd3("lambda expressions");
Console.ReadLine();
}
static void Main(string[] args)
{
List <Student> u = new List <Student>()
{
new Student {
Name = "aaa", Age = 10, Sex = "男", Tel = "131456131", Nationality = "中国"
},
new Student {
Name = "bbb", Age = 28, Sex = "女", Tel = "45678613", Nationality = "韩国"
},
new Student {
Name = "ccc", Age = 27, Sex = "男", Tel = "131456131", Nationality = "日本"
},
new Student {
Name = "ddd", Age = 18, Sex = "男", Tel = "131456131", Nationality = "美国"
}
};
//排序后的list表
//DemoClass.SortStudent(u);
/////-------------------------/////
//问题的引入
//如果打招呼的人有日本人,德国人,韩国人
//则我们需要频繁的修改DelegateQuestion.Language的枚举
//需要添加对应他国人打招呼的方法(fun)这步操作必须
//面对以上修改频繁的修改枚举的操作,这里我们将用到委托
//DelegateQuestion question = new DelegateQuestion();
//question.GreetPeople(u[0].Name, DelegateQuestion.Language.Chinese);
//实例委托
//实例方式1:
GreetingDelegate Greet1 = new GreetingDelegate(new DelegateQuestion().ChineseGreeting);
Greet1(u[0].Name);
//实例方式2:
//GreetingDelegate Greet2 = new DelegateQuestion().EnglishGreeting;//委托推断
//Greet2.Invoke(u[1].Name);
// Greet1.Invoke();
}
static void Main(string[] args)
{
RemotingConfiguration.Configure("HelloClient.exe.config");
Hello obj = new Hello();
if (obj == null)
{
Console.WriteLine("could not locate server");
return;
}
// synchronous:
// greeting = obj.Greeting("Christian");
// asynchronous:
GreetingDelegate d = new GreetingDelegate(obj.Greeting);
Console.WriteLine("Starting remote method");
IAsyncResult ar = d.BeginInvoke("Christian", null, null);
// do some work
Console.WriteLine("Do some other work");
ar.AsyncWaitHandle.WaitOne();
if (ar.IsCompleted)
{
greeting = d.EndInvoke(ar);
}
Console.WriteLine(greeting);
/*
* Console.WriteLine("starting long call");
* obj.TakeAWhile(10000);
* Console.WriteLine("finished long call");
*/
}
static void Main(string[] args)
{
// 为什么在此处不能引用实例方法
GreetPeople("zll", EnglishGreeting);
GreetPeople("周梁亮", ChineseGreeting);
//GreetingDelegate delegate1, delegate2;
//delegate1 = EnglishGreeting;
//delegate1 += ChineseGreeting;
GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
delegate1 += ChineseGreeting;
//delegate2 = ChineseGreeting;
//GreetPeople("zll", delegate1);
//GreetPeople("周梁亮", delegate1);
//delegate1("zll");
GreetPeople("zll", delegate1);
delegate1 -= ChineseGreeting;
GreetPeople("zll", delegate1);
// 使用委托可以将多个方法绑定到同一个委托变量，当调用此变量，可以依次调用
// 所有绑定的方法，返回最后一个方法的结果。
// delegate2("周梁亮");
//委托就相当于是一种类型，可以进行复制，只是可以将方法复制给委托
// 多个方法绑定委托。
GreetingManager gm = new GreetingManager();
// gm.MakeGreet = EnglishGreeting;
// 事件“BoWenXuexiDelegate.GreetingManager.MakeGreet”
// 只能出现在 += 或 -= 的左边(从类型“BoWenXuexiDelegate.GreetingManager”中使用时除外)
gm.MakeGreet += ChineseGreeting;
gm.GreetPeople("zll and zyd");
Heater ht = new Heater();
Alarm alarm = new Alarm();
ht.BoilEvent += alarm.MakeAlert;
ht.BoilEvent += (new Alarm()).MakeAlert;
ht.BoilEvent += Display.ShowMsg;
ht.BoilWater();
}
static void Main(string[] args)
{
RemotingConfiguration.Configure("HelloClient.exe.config");
Hello obj = new Hello();
if (obj == null)
{
Console.WriteLine("could not locate server");
return;
}
// synchronous:
// greeting = obj.Greeting("Christian");
// asynchronous:
GreetingDelegate d = new GreetingDelegate(obj.Greeting);
Console.WriteLine("Starting remote method");
IAsyncResult ar = d.BeginInvoke("Christian", null, null);
// do some work
Console.WriteLine("Do some other work");
ar.AsyncWaitHandle.WaitOne();
if (ar.IsCompleted)
{
greeting = d.EndInvoke(ar);
}
Console.WriteLine(greeting);
/*
Console.WriteLine("starting long call");
obj.TakeAWhile(10000);
Console.WriteLine("finished long call");
*/
}
static void Main(string[] args)
{
//第一种
GreetPeople("Jack", EnglishGreeting);
GreetPeople("哎哟", ChineseGreeting);
//第二种
GreetingDelegate greet;
greet = EnglishGreeting;
greet += ChineseGreeting;
greet("Jack");
//第三种
GreetingDelegate gr = new GreetingDelegate(EnglishGreeting);
gr += ChineseGreeting;
gr("Rose");
//添加greetmanager 类封装后.
GreetManager gm = new GreetManager();
gm.delegate1 = EnglishGreeting;
gm.delegate1 += ChineseGreeting;
gm.GreetPeople("Adi");
Console.ReadKey();
}
static void Main(string[] args)
{
//委托调用
Greet_People("Tank", English_Greeting);
Greet_People("李梅梅", Chinese_Greeting);
Console.WriteLine("======================================");
//绑定多个事件--【方法一】
GreetingDelegate delegate1;
//绑定事件一
delegate1 = English_Greeting;
//绑定事件二
delegate1 += Chinese_Greeting;
//调用
Greet_People("韩梅梅", delegate1);
Console.WriteLine("======================================");
//绑定多个事件--【方法二】
//绑定事件一
GreetingDelegate delegate2 = new GreetingDelegate(English_Greeting);
//绑定事件二
delegate2 += Chinese_Greeting;
//调用
Greet_People("韩梅梅", delegate2);
Console.WriteLine("======================================");
//取消事件绑定
//取消绑定事件一
delegate2 -= English_Greeting;
//调用
Greet_People("龙傲天", delegate2);
Console.ReadLine();
}
static void Main(string[] args)
{
DisplayDelegate dd = delegate(float x, float y)
{
Console.WriteLine(x + y);
};
dd.Invoke(3.02f, 4.2f);
SumDelegate sd = delegate(int x, int y)
{
return(x + y);
};
int result = sd.Invoke(60, 90);
Console.WriteLine(result);
GreetingDelegate gd = delegate(string name)
{
return(true);
};
bool name1 = gd.Invoke("friends");
Console.WriteLine(name1);
Console.ReadKey();
}
static void Main(string[] args)
{
//instantiation, creation of delegate objects
GreetingDelegate firstDel, secondDel;
//registeration
firstDel = new GreetingDelegate(Hello);
secondDel = new GreetingDelegate(Goodbye);
//calling methods via the delegate
firstDel("Nazif");
secondDel("Sahim");
//second way of instantiation
//firstDel=Hello;
//SecondDel=GoodBye;
//Multicasting Delegate
firstDel += secondDel;
//passing delegate to a method
GreetingMethod(firstDel, "Nazif Sahim");
}
static void Main(string[] args)
{
DisplayDelegate dd = (x, y) =>
{
Console.WriteLine(x + y);
};
dd.Invoke(3.02f, 6.78f);
SumDelegate sd = (x, y) =>
{
return(x + y);
};
int result = sd.Invoke(60, 90);
Console.WriteLine(result);
GreetingDelegate gd = name =>
{
return(true);
};
bool name1 = gd.Invoke("friends");
Console.WriteLine(name1);
Console.ReadKey();
}
static void Main(string[] args)
{
// 1) named method
GreetingDelegate gd1 = new GreetingDelegate(DelegateDemo.DoWork);
gd1("named method");
// 2) anonymous method
GreetingDelegate gd2 = delegate(string s)
{
System.Console.WriteLine(s);
};
gd2("anonymous methods");
// 3) lambda expressions
GreetingDelegate gd3 = (s) =>
{
System.Console.WriteLine(s);
};
gd3("lambda expressions");
Console.ReadLine();
}
public static void GreetMethod
(GreetingDelegate gd, string name)
{
Console.WriteLine("The greeting is:");
gd(name);
}
static void Main(string[] args)
{
List <int> numbers = new List <int>()
{
1, 3, 5, 7, 8, 9, 11, 13, 14, 15
};
IEnumerable <int> largeNumber = numbers.Where(c => c > 14);
foreach (int i in largeNumber)
{
Console.WriteLine("Large Number is " + i);
}
IEnumerable <int> results = from num in numbers
where num < 3 || num > 7
orderby num descending
select num;
int count = /*(from num in numbers
* where num < 3 || num > 7
* orderby num descending
* select num).Count();*/
numbers.Where(n => n < 3 || n > 10).Count();
Console.WriteLine("Count is " + count);
foreach (int num in results)
{
Console.WriteLine("number is : " + num);
}
string[] groupingQuery = { "carrots", "cabbage", "broccoli", "beans", "barley" };
IEnumerable <IGrouping <char, string> > gQuery =
from item in groupingQuery
group item by item[0];
foreach (var item in gQuery)
{
//Console.WriteLine("Grouped Items are - ");
}
Student.QueryHighScores(1, 90);
Console.WriteLine("Hello World!");
MQ app = new MQ();
int[] nums = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var q1 = app.QueryMethod1(ref nums);
foreach (string s in q1)
{
Console.WriteLine("string is - " + s);
}
IEnumerable <string> mq2;
app.QueryMethod2(ref nums, out mq2);
foreach (string s in mq2)
{
Console.WriteLine(s);
}
Student.GroupBySingleProperty();
FileLogger file = new FileLogger("/Users/giridharreddykatha/Documents/Logs/log.txt");
Logger.LogMessage(Severity.Error, "This is Error", "This Error is caused");
Logger.LogMessage(Severity.Critical, "This is Critical Error", "Big Error");
AddDelegate ad = new AddDelegate(DelegateDemo.Add);
ad.Invoke(10, 20);
MulDelegate md = MulticastDelegate.Area;
md += MulticastDelegate.Circumference;
md.Invoke(10.2, 12);
GreetingDelegate gd = delegate(string name)
{
return("Hello " + name + " A Very Good Morning!!");
};
Console.WriteLine(gd.Invoke("Friend"));
GreetingDelegate g = (name) => { return("Hello " + name + " A Very Good Morning!!"); };
Console.WriteLine(g.Invoke("Mike"));
Console.ReadLine();
}
public void GreetPeople(string name, GreetingDelegate MakeGreeting)
{
MakeGreeting(name);
}
// 有了委托之后，可以像如下实现打招呼方法
public void Greeting(string name, GreetingDelegate callback)
{
// 调用委托
callback(name);
}
public IAsyncResult BeginGreet(string name, AsyncCallback callback, object state)
{
GreetingDelegate caller = new GreetingDelegate(() => Greet(name));
return caller.BeginInvoke(callback, state);
}
/// <summary> 客户编码速查选择器
/// </summary>
/// <param name="ContorlName">控件ID</param>
/// <param name="delDataBack">回调函数</param>
public static void CusCodeChoose(TextChooser ContorlName, GreetingDelegate delDataBack)
{
string table = "tb_customer";
string displayColumn = "cust_code";
string valueColumn = "cust_name";
//设置表和显示字段
ContorlName.SetBindTable(table, displayColumn, valueColumn);
ContorlName.GetDataSourced += new TextChooser.GetDataSourceHandler(Cus_CodeBindData);
if (delDataBack != null)
{
ContorlName.DataBacked -= new TextChooser.DataBackHandler(delDataBack);
ContorlName.DataBacked += new TextChooser.DataBackHandler(delDataBack);
}
}
//委托传递的是方法。
private static void GreetPeople(string name, GreetingDelegate makeGreeting)
{
makeGreeting(name);
}
//注意此方法，它接受一个GreetingDelegate类型的方法作为参数
private static void GreetPeople(string name, DateTime aa, GreetingDelegate MakeGreeting)
{
MakeGreeting(name, aa);
}
public static void GreetPeople(string name, GreetingDelegate MakeGreet)
{
MakeGreet(name);
}
private static void GreetPeople(string name, GreetingDelegate MakeGreeting)
{
MakeGreeting(name);
}
public void GreetingManage(string name, GreetingDelegate greetingDelegate)
{
greetingDelegate(name);
}
private static void SayHello(string name, GreetingDelegate GreetPeople)
{//此方法接受一个GreetingDelegate类型的方法作为参数
GreetPeople(name);
}
public void GreetPeople(string name, GreetingDelegate MakeGreeting)
{
MakeGreeting(name);
}
/// <summary>
/// 调用委托
/// </summary>
/// <param name="name"></param>
/// <param name="greetingDelegate"></param>
public string Greeting(string name, GreetingDelegate greetingDelegate)
{
//greetingDelegate.Invoke(name);
return(greetingDelegate.Invoke(name));
}
public static void GreetMethod(GreetingDelegate gd, string name)
{
Console.WriteLine("The greeting is:");
gd(name);
}
public static void GreetPeople(string name, GreetingDelegate MakeGreeting)
{
// 做某些额外的事情,比如初始化之类,此处略
MakeGreeting(name);
}
/// <summary> 配件类型名称速查选择器
/// </summary>
/// <param name="ContorlName">控件ID</param>
/// <param name="delDataBack">回调函数</param>
public static void PartsTypeNameChoose(TextChooser ContorlName, GreetingDelegate delDataBack)
{
string table = "sys_dictionaries";
string valueColumn = "dic_name";
//设置表和显示字段
ContorlName.SetBindTable(table, valueColumn);
ContorlName.GetDataSourced += new TextChooser.GetDataSourceHandler(PartsType_NameBindData);
if (delDataBack != null)
{
ContorlName.DataBacked -= new TextChooser.DataBackHandler(delDataBack);
ContorlName.DataBacked += new TextChooser.DataBackHandler(delDataBack);
}
}
static void GreetPeople(string name, GreetingDelegate greetingDelegate)
{
greetingDelegate(name);
}
/// <summary> 配件车型名称速查选择器
/// </summary>
/// <param name="ContorlName">控件ID</param>
/// <param name="delDataBack">回调函数</param>
public static void PartsCarModelNameChoose(TextChooser ContorlName, GreetingDelegate delDataBack)
{
string table = "tb_vehicle_models";
string valueColumn = "vm_name";
//设置表和显示字段
ContorlName.SetBindTable(table, valueColumn);
ContorlName.GetDataSourced += new TextChooser.GetDataSourceHandler(PartsCarModel_NameBindData);
if (delDataBack != null)
{
ContorlName.DataBacked -= new TextChooser.DataBackHandler(delDataBack);
ContorlName.DataBacked += new TextChooser.DataBackHandler(delDataBack);
}
}
