static void Main(string[] args)
{
// 1. 기본 선언
DelegateTest dt = new DelegateTest(Sum);
// 2. 간략한 선언
DelegateTest dt2 = Sum;
// 3. 익명 함수 선언
DelegateTest dt3 = delegate(int a, int b)
{
Console.WriteLine("a + b = " + (a + b));
};
// 4. 람다식 선언
DelegateTest dt4 = (a, b) =>
{
Console.WriteLine("a + b = " + (a + b));
};
dt(1, 1);
dt2(2, 2);
dt3(3, 3);
dt4(4, 4);
}
static void Main()
{
PrintMeInfo info = null;
info += new PrintMeInfo(ShowMeTheNumber);
info += new PrintMeInfo(DelegateTest.IsOdd);
info += new PrintMeInfo(IsDividableByTen);
DelegateTest additional_info = new DelegateTest();
info += new PrintMeInfo(additional_info.BiggerThanTen); //The method is not static!
Calculations calc = null;
calc += new Calculations(DelegateTest.SumAndMultiply1);
calc += new Calculations(DelegateTest.SumAndMultiply2);
List <Calculations> my_list = new List <Calculations> {
SumAndMultiply1, SumAndMultiply2, SumAndMultiply3
};
foreach (var my_result in my_list)
{
Console.WriteLine(my_result(5, 6, 7));
}
info(25);
}
// Firma de un metodo/funcion
static void AnonymousSample()
{
// Declaracion normal
// Type nombre;
Type a1;
string a2;
int a3;
// Declaracion anonima
var b1 = typeof(object);
var b2 = "Hola";
var b3 = 10;
// no funciona
// var b4;
// Delegates examples
// Function call
Console.WriteLine(Sumar(2, 3));
Calculo funcion = Sumar;
Console.WriteLine(funcion(2, 3));
DelegateTest x = new DelegateTest();
x.ClickHandler += Sumar;
x.ClickHandler += Restar;
x.ClickHandler += (z, y) => { return(10); };
}
public void DelegatePracticeMethodGroupConversion()
{
// Construct a delegate using method group conversion.
StrMod strOp = DelegateTest.ReplaceSpaces; // use method group conversion
string str;
// Call methods through the delegate.
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
Console.WriteLine();
strOp = DelegateTest.RemoveSpaces; // use method group conversion
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
Console.WriteLine();
strOp = DelegateTest.Reverse; // use method group conversion
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
// Calling Intance Class
Console.WriteLine("Delegate Method Group Conversion with Intance Method");
DelegateTest DlgOb = new DelegateTest();
strOp = DlgOb.ReplaceSpacesInsTanceMethod;
str = strOp("My name is Muhammad Adshikuzzaman");
Console.CursorSize = 10;
Console.WriteLine("My space replaced name is : " + str);
Console.WriteLine();
}
private void btnDelegateTestClick(object sender, EventArgs e)
{
//使用using在调用完后会自动回收垃圾
using (DelegateTest test = new DelegateTest())
{
//实例化委托
DelegateTest.StringDelegate dgt1 = new DelegateTest.StringDelegate(doubleString);
dgt1 += plusA2String;
// 用这个变量来保存输出的字符串
StringBuilder returnstring = new StringBuilder();
//以下方法可获取委托中每个方法的返回值，并可处理委托链中的报错
// 获取一个委托数组，其中每个元素都引用链中的委托
foreach (var item in dgt1.GetInvocationList())
{
DelegateTest.StringDelegate tempObj = item as DelegateTest.StringDelegate;
try
{
string str = "test\n";
//调用委托获得返回值
returnstring.Append(tempObj(ref str) + Environment.NewLine);
}
catch (Exception ex)
{
returnstring.AppendFormat("异常从 {0} 方法中抛出, 异常信息为：{1}{2}", tempObj.Method.Name, ex.Message, Environment.NewLine);
}
}
richTextBox2.Text += returnstring;
richTextBox2.Text += "///////////////////////////////////////\n";
richTextBox2.Text += test.delegateUser("test\n", dgt1) + "\n";
}
}
public Object TestConv(int a, int b)
{
int[] arr = new int[1];
DelegateTest dt = new DelegateTest();
this.Prop = dt;
this[0] = dt;
arr[0] = dt;
DelegateTest v = this.Prop;
DelegateTest v2 = this[0];
DelegateTest v3 = arr[0];
DelegateTest vv, vv2, vv3;
vv = this.Prop;
vv2 = this[0];
vv3 = arr[0];
DelegateTest v4 = arr[0];
int[] arr2 = null;
v4 = arr2?[0];
DelegateTest vv4 = arr2?[0];
ConvTest ct = null;
dt = ct?.Prop;
dt = ct?[0];
DelegateTest v5 = ct?[0];
DelegateTest vv5;
vv5 = ct?[0];
return(null);
}
static void Main(string[] args)
{
// 创建委托对象1，绑定一个静态方法
DelegateTest dtstatic = new DelegateTest(methodStatic);
// 创建委托对象2，绑定一个实例方法
DelegateTest dtinstance = new DelegateTest(new Captal8_Delegate_04DelegateChain().methodInstance);
// 创建一个委托对象，并绑定委托对象1，使用"+"添加委托对象2，成为委托链
DelegateTest delegateChain = dtstatic;
delegateChain += dtinstance;
// 调用委托对象
delegateChain.Invoke();
Console.WriteLine();
Console.WriteLine("从委托链上移除静态方法后：");
// 从委托链上移除静态方法
delegateChain -= dtstatic;
delegateChain.Invoke();
Console.ReadKey();
}
public delegate void DelegateTest(); // 声明一个委托类型
public static void Show()
{
DelegateTest dt_static = new DelegateTest(Method1); // 用静态方法来实例化委托 dt_static
DelegateTest dt_instance = new DelegateTest(new DelegateChain().Method2); // 用实例方法来实例化委托 dt_instance
// 定义一个委托对象, 一开始初始化为null, 没有和任何方法关联
DelegateTest delegate_chain = null; // 初始化不是必须的
// 使用 + 号链接委托, 多个委托链接起来形成委托链
delegate_chain = dt_static + dt_instance;
/* 显然, 使用符合赋值 += 符号亦可
* delegate_chain += dt_static;
* delegate_chain += dt_instance;
*/
// 调用委托链
delegate_chain();
// 使用 - 或 -= 取消链接委托
delegate_chain -= dt_static;
delegate_chain();
// 委托链可以重新赋值
delegate_chain = dt_static;
delegate_chain();
}
public static void Main()
{
InterfaceTest interfaceTest = new InterfaceTest();
DelegateTest delegateTest = new DelegateTest();
interfaceTest.Run();
delegateTest.Run();
}
static void Main(string[] args)
{
Console.WriteLine(math.Add("4", "9"));
Console.ReadKey();
DelegateTest a1 = Add;
a1(14, 32);
}
static void Main()
{
FirstDelegate d1 = new FirstDelegate(StaticMethod);
DelegateTest instance = new DelegateTest();
instance.name = "My instance";
FirstDelegate d2 = new FirstDelegate(instance.InstanceMethod);
Console.WriteLine(d1(10)); // Writes out "Static method: 10"
Console.WriteLine(d2(5)); // Writes out "My instance: 5"
}
static void Main(string[] args)
{
DelegateTest delegatetest = new DelegateTest();
delegatetest.DoStuff();
DoOperation someOperation = new DoOperation(MyMultiply);
someOperation += MySum;
}
static void Main()
{
// 간단 사용법 (그냥 메소드 호출이랑 차이없음)
DelegateTest AddDelegate = new DelegateTest(Add);
int sumValue = AddDelegate(5, 10);
Console.WriteLine(sumValue);
// 콜백 예제 10+입력받은값 출력
CallbackDelegate readText = new CallbackDelegate(ReturnInt);
PrintSum(10, readText);
}
// Start is called before the first frame update
void Start()
{
DelegateTest delTest = FindObjectOfType <DelegateTest>();
if (delTest != null)
{
delTest.OnSpacePressed += Testing_OnSpacePressed;
}
else
{
Debug.Log("Could not find DelegateTest.");
}
}
static void Main(string[] args)
{
//Multicast delegate
DelegateTest dt = () => { };
dt = T1;
dt += T2;
dt += T3;
dt += T4;
dt();
Console.ReadLine();
}
public static void Run()
{
string mid = ",middle part,";
DelegateTest anondel = delegate(string param)
{
param += mid;
param += " and this was added to the string.";
return(param);
};
Console.WriteLine();
Console.WriteLine("AnonymousDelegate");
Console.WriteLine(anondel("start of string."));
}
public void DelegatePracticeWithInstanceMthod()
{
// Construct a delegate.
StrMod strOp = new StrMod(DelegateTest.ReplaceSpaces);
string str;
// Calling Intance Class
DelegateTest DlgOb = new DelegateTest();
strOp = new StrMod(DlgOb.ReplaceSpacesInsTanceMethod);
str = strOp("My name is Muhammad Adshikuzzaman");
Console.CursorSize = 10;
Console.WriteLine("My space replaced name is : " + str);
Console.WriteLine();
}
static void Main(string[] args)
{
DelegateTest del1 = Test1;
// 多播委托
del1 += Test2;
del1 += Test3;
del1 += Test4;
del1();
Console.WriteLine("~~~~~~~~~~~~~~~");
del1 -= Test4;
del1 -= Test3;
del1();
Console.ReadKey();
}
public Chapter1()
{
var delegObj = new DelegateTest();
string str;
var strOp = new StrMod(delegObj.ReplaceSpaces);
str = strOp("Test string line");
Console.WriteLine("str: " + str + "\n");
strOp = delegObj.RemoveSpace;
str = strOp("Test string line");
Console.WriteLine("str: " + str + "\n");
strOp = delegObj.Reverse;
str = strOp("Test string line");
Console.WriteLine("str: " + str + "\n");
}
public void CanRegisterAndResolveServiceWithRuntimeTypeAndMetadata()
{
// Arrange
_containerBuilder.ForType <IMyInterface>(typeof(MyClassImplementingInterfaceWithMetadata))
.Register()
.WithMetadata <IMyMetadata, string>(a => a.StringValue, "sdasdasd")
.WithMetadata <IMyMetadata, Guid>(a => a.GuidValue, Guid.NewGuid())
.WithMetadata <IMyMetadata, int>(a => a.IntValue, 1237);
_containerBuilder.ForType <IMyInterface>(typeof(MyClassImplementingInterfaceWithMetadata))
.Register()
.WithMetadata <IMyMetadata, string>(a => a.StringValue, "blahblah")
.WithMetadata <IMyMetadata, Guid>(a => a.GuidValue, Guid.Empty)
.WithMetadata <IMyMetadata, int>(a => a.IntValue, 7);
DelegateTest delegateTest = new DelegateTest();
delegateTest.GetGuid = Guid.NewGuid();
var blahblah2 = "blahblah2";
delegateTest.GetString = blahblah2;
delegateTest.GetInt = 42;
_containerBuilder.ForType <IMyInterface>(typeof(MyClassImplementingInterfaceWithMetadata))
.Register()
.WithMetadata <IMyMetadata, string>(a => a.StringValue, delegateTest.GetString)
.WithMetadata <IMyMetadata, Guid>(a => a.GuidValue, delegateTest.GetGuid)
.WithMetadata <IMyMetadata, int>(a => a.IntValue, delegateTest.GetInt);
delegateTest.GetGuid = Guid.Empty;
_containerBuilder.ForType <MyClassAcceptingResolvedMetadata, MyClassAcceptingResolvedMetadata>().Register();
IDependencyResolver container = _containerBuilder.Build();
// Act
var result = container.Resolve <IMyInterface>();
var autoResult = container.Resolve <MyClassAcceptingResolvedMetadata>();
var propertyResult = result.MyStringProperty;
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(autoResult);
Assert.IsInstanceOfType(result, typeof(IMyInterface));
Assert.IsTrue(propertyResult == blahblah2);
}
public void VisitControls(ControlCollection list, DelegateTest isTarget, ControlDelegate visit)
{
foreach (Control member in list)
{
if (member.HasControls())
{
VisitControls(member.Controls,
isTarget,
visit
);
}
if (isTarget(member))
{
visit(member);
}
}
}
public void CanRegisterAndResolveServiceWithRuntimeTypeAndMetadata()
{
// Arrange
_containerBuilder.ForType<IMyInterface>(typeof (MyClassImplementingInterfaceWithMetadata))
.Register()
.WithMetadata<IMyMetadata, string>(a => a.StringValue, "sdasdasd")
.WithMetadata<IMyMetadata, Guid>(a => a.GuidValue, Guid.NewGuid())
.WithMetadata<IMyMetadata, int>(a => a.IntValue, 1237);
_containerBuilder.ForType<IMyInterface>(typeof(MyClassImplementingInterfaceWithMetadata))
.Register()
.WithMetadata<IMyMetadata, string>(a => a.StringValue, "blahblah")
.WithMetadata<IMyMetadata, Guid>(a => a.GuidValue, Guid.Empty)
.WithMetadata<IMyMetadata, int>(a => a.IntValue, 7);
DelegateTest delegateTest = new DelegateTest();
delegateTest.GetGuid = Guid.NewGuid();
var blahblah2 = "blahblah2";
delegateTest.GetString = blahblah2;
delegateTest.GetInt = 42;
_containerBuilder.ForType<IMyInterface>(typeof(MyClassImplementingInterfaceWithMetadata))
.Register()
.WithMetadata<IMyMetadata, string>(a => a.StringValue, delegateTest.GetString)
.WithMetadata<IMyMetadata, Guid>(a => a.GuidValue, delegateTest.GetGuid)
.WithMetadata<IMyMetadata, int>(a => a.IntValue, delegateTest.GetInt);
delegateTest.GetGuid = Guid.Empty;
_containerBuilder.ForType<MyClassAcceptingResolvedMetadata, MyClassAcceptingResolvedMetadata>().Register();
IDependencyResolver container = _containerBuilder.Build();
// Act
var result = container.Resolve<IMyInterface>();
var autoResult = container.Resolve<MyClassAcceptingResolvedMetadata>();
var propertyResult = result.MyStringProperty;
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(autoResult);
Assert.IsInstanceOfType(result, typeof(IMyInterface));
Assert.IsTrue(propertyResult == blahblah2);
}
static void Main(string[] args)
{
// 创建委托实例
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
// 使用委托对象调用方法
nc1(25, "");
Console.WriteLine("Value of Num: {0}", getNum());
nc2(5, "");
Console.WriteLine("Value of Num: {0}", getNum());
StringChanger c = new StringChanger(addString);
c("tema");
Console.WriteLine(c("tema"));
Console.ReadKey();
//委托链
//委托的多播（Multicasting of a Delegate）
/*s
* 委托对象可使用 "+" 运算符进行合并。一个合并委托调用它所合并的两个委托。只有相同类型的委托可被合并。"-" 运算符可用于从合并的委托中移除组件委托。
* 使用委托的这个有用的特点，您可以创建一个委托被调用时要调用的方法的调用列表。这被称为委托的 多播（multicasting），也叫组播。下面的程序演示了委托的多播：
* - 方法移除一个委托
*/
DelegateTest test = null;
DelegateTest test1 = new DelegateTest(writeDown);
DelegateTest test2 = new DelegateTest(writeDown);
DelegateTest test3 = new DelegateTest(writeDown);
DelegateTest test4 = new DelegateTest(writeDown);
test += test1;
test += test2;
test += test3;
test += test4;
test -= test1;
test("qwerty");
Console.Read();
}
static void Main(string[] args)
{
Console.WriteLine("\n\n---===Delegate===---\n");
var instance = new MyClass();
// Instantiate delegate with named methode:
DelegateTest dt = instance.Average;
// Invoke delegate:
var numbers = new List <double>()
{
4, 2, 6
};
double averageOfThree = dt(numbers);
Console.WriteLine("The average of the following set of numbers (2, 4, 6) is: {0}", averageOfThree);
Console.ReadKey();
dt -= instance.Average;
dt += MyClass.PrintFirst;
Console.WriteLine("First element: {0}", dt(numbers));
Console.ReadKey();
// Instantiate delegate with anonymous methode:
DelegateTest dt2 = delegate(List <double> input)
{
return(input.Any() ? input.Sum() / input.Count() : 0);
};
double average = dt2(new List <double>()
{
2, 6, 8
});
Console.WriteLine("The average of the following set of numbers (2, 6, 8) is: {0}", average);
/*
* Instantiate delegate with lambda expression -> next day
*/
Console.ReadKey();
}
protected T CreateControl <T>(T prefab, string text) where T : Object, IControl
{
if (!prefab)
{
throw new Exception(String.Format("Отсутствует ссылка на {0}", typeof(T)));
}
var tempControl = Instantiate(prefab, Interface.InterfaceResources.MainPanel.transform.position, Quaternion.identity,
Interface.InterfaceResources.MainPanel.transform);
if (tempControl.GetText != null)
{
tempControl.GetText.text = text;
}
DelegateTestr = Test;
var test = DelegateTestr.BeginInvoke(null, null);
return(tempControl);
}
/// <summary>
/// 委托链
/// </summary>
public void T8D4()
{
//TODO:用静态方法实例化委托
DelegateTest dtstatic = new DelegateTest(T8.Method1);
DelegateTest dtinstance = new DelegateTest(new T8().Method2);
//TODO：定义一个委托，初始化为null，即不代表任何方法
DelegateTest delegatechain = null;
//TODO:使用“+”符号链接委托，链接多个委托后形成委托链
delegatechain += dtstatic;
delegatechain += dtinstance;
//TODO:使用“-”符号把委托从委托链中移除
delegatechain -= dtstatic;
//TODO:调用委托链
delegatechain();
Console.Read();
}
static void Run()
{
// TODO: One day these should be converted to proper unit tests...
TestPrimitiveType();
TestWithDispatch(new BaseClass());
TestWithDispatch(new DerivedClassA());
TestWithDispatch(new DerivedClassB());
TestWithDispatch(new DerivedClassC());
TreeTest.RunTest();
TreeTest.RunTestWithDefinitions();
TestArrays();
TestManyTypes();
DelegateTest.RunTest();
}
//-----------------------------------------------------------------------------------------------------
public static void LambadaDelegateEntry()
{
DateTime dt = DateTime.Now; TimeSpan dt1 = new TimeSpan();
foreach (var item in Process.GetProcesses())
{
Console.WriteLine(item.ProcessName);
}
string mid = ",middle part,";
DelegateTest lamdel = param => param += mid + " and this was added to the string.";
//{
// param += mid;
// param += " and this was added to the string.";
// return param;
//};
Console.WriteLine(lamdel("start of string"));
Console.WriteLine(Process.GetCurrentProcess().Threads[0].UserProcessorTime.Subtract(dt1).TotalMilliseconds);
}
static void Main(string[] args)
{
// 用静态方法来实例化委托
DelegateTest dtstatic = new DelegateTest(Program.method1);
DelegateTest dtinstance = new DelegateTest(new Program().method2);
// 定义一个委托对象，一开始初始化为null，就是不代表任何方法（我就是我，我不代表任何人）
DelegateTest delegatechain = null;
// 使用+符号链接委托，链接多个委托后就成为委托链了
delegatechain += dtstatic;
delegatechain += dtinstance;
// 使用-运算符把dtstatic委托从委托链中移除
delegatechain -= dtstatic;
// 调用委托链
delegatechain();
Console.Read();
}
static void Main(string[] args)
{
// 用静态方法来实例化委托
DelegateTest dtstatic = new DelegateTest(Program.method1);
DelegateTest dtinstance = new DelegateTest(new Program().method2);
// 定义一个委托对象，一开始初始化为null，就是不代表任何方法（我就是我，我不代表任何人）
DelegateTest delegatechain = null;
// 使用+符号链接委托，链接多个委托后就成为委托链了
delegatechain += dtstatic;
delegatechain += dtinstance;
Console.WriteLine("delegatechain's number methods : " + delegatechain.GetInvocationList().Length);
// 使用-运算符把dtstatic委托从委托链中移除
delegatechain -= dtstatic;
// 调用委托链
delegatechain.Invoke();
Console.Read();
}
static void Main(string[] args)
{
#region DelegateTest
DelegateTest d = new DelegateTest(Test);
d("Delegate");
//ラムダ1
d = new DelegateTest((string s) => { Console.WriteLine($"This is {s}"); });
d("Delegate");
//ラムダ2
d = new DelegateTest(s => Console.WriteLine($"This is {s}"));
d("Delegate");
#endregion
#region Action
Action <string> a = Test;
a("Action");
a = s => Console.WriteLine($"This is {s}");
a("Action");
#endregion
#region Func
Func <string> f = Test2;
Console.WriteLine($"{f()} Func");
f = () => "This is";//引数のないラムダ式は()を省略できない
Console.WriteLine($"{f()} Func");
Func <string, string> ff = Test3;
Console.WriteLine(ff("Func"));
ff = s => $"This is {s}";
Console.WriteLine(ff("Func"));
#endregion
Console.ReadKey();
}
static void Main()
{
string mid = ", middle part,";
// Anonymous Method
DelegateTest anonDel = delegate(string param)
{
param += mid;
param += " and this was added to the string.";
return(param);
};
// Lambda Expression
//DelegateTest anonDel = param =>
// {
// param += mid;
// param += " and this was added to the string.";
// return param;
// };
Console.WriteLine(anonDel("Start of string"));
}
public void Remove(DelegateTest isTarget)
{
for (int i = 0; i < Count(); ++i) {
object[] data = listModel[i];
if (isTarget(data)) {
Remove(i);
--i;
}
}
}
private void button10_Click(object sender, EventArgs e)
{
DelegateTest test = new DelegateTest();
}
