static void Main(string[] args) { // Instantiate the delegate. Del handler = DelegateMethod; // Call the delegate. handler("Hello World"); //Hello World MethodWithCallback(1, 2, handler); //The number is: 3 MethodClass obj = new MethodClass(); Del d1 = obj.Method1; Del d2 = obj.Method2; Del d3 = DelegateMethod; //Both types of assignment are valid. Del allMethodsDelegate = d1 + d2; allMethodsDelegate += d3; //remove Method1 allMethodsDelegate -= d1; // copy AllMethodsDelegate while removing d2 Del oneMethodDelegate = allMethodsDelegate - d2; int invocationCount = d1.GetInvocationList().GetLength(0); }
public Delegate GetInvocationListPartial(int index) { Del del = MethodOne; del += MethodTwo; return(del.GetInvocationList()[index]); }
static void Main(string[] args) { Del d = Foo1; d += Foo2; d += Foo3; d += Foo3; d += Foo3; d += Foo4; d += (str) => { Console.WriteLine(str + "I do nothing"); }; // d("My name is Ivan"); // Thread.Sleep(2000); // Console.WriteLine("----------------------------------------"); d -= Foo2; d -= Foo3; d -= Foo1; d?.Invoke("Ivan"); // d("My name is Ivan"); foreach (Del item in d.GetInvocationList()) { // Console.WriteLine(item.Method); item?.Invoke("Olga"); } }
//error: A field initalizer cannot reference the nonostatic field, method or property... //when we dont put the code below to Test() function we will the error above //Because Del is a instance variable, Method1 is a instance method of a instance class //there is no guarantee that MethodClass will be initialized before MathodClassTest; void Test() { MethodClass obj = new MethodClass(); Del d1 = obj.Method1; Del d2 = obj.Method2; Del d3 = DelegateManager.DelegateMethod; //Both types of assignment are valid. Del allMethodsDelegate; allMethodsDelegate = d1 + d2; //multicasting allMethodsDelegate(" Called1..."); //" MethodClass Method1 Called1..." //" MethodClass Method2 Called1..." allMethodsDelegate += d3; //multicasting allMethodsDelegate(" Called2...."); //" MethodClass Method1 Called2..." //" MethodClass Method2 Called2..." //"DelegateManager DelegateMethod Called2..." //remove Method1 allMethodsDelegate -= d1; allMethodsDelegate(" Called3...."); //" MethodClass Method2 Called2..." //"DelegateManager DelegateMethod Called2..." int invocationCount = d1.GetInvocationList().GetLength(0); }
static void Main(string[] args) { Calculate cal = Add; Console.WriteLine(cal(5, 5)); Calculate cal1 = Mutiply; Console.WriteLine(cal1(8, 8)); Console.ReadLine(); Del d = MethodOne; d += MethodTwo; d(); int invocationCount = d.GetInvocationList().GetLength(0); Console.WriteLine(invocationCount); CovarianceDel Cov = null; Cov = MethodStream; Cov = MethodString; Console.ReadLine(); }
public void Test2() { var obj = new MethodClass(); Del d1 = obj.Method1; Del d2 = obj.Method2; Del d3 = DelegateMethod; //Both types of assignment are valid. Del allMethodsDelegate = d1 + d2; allMethodsDelegate += d3; int invocationCount = allMethodsDelegate.GetInvocationList().GetLength(0); allMethodsDelegate("123"); var x = ShowMsg == null; ShowMsg += ShowName; ShowMsg("hahahha"); var y = ShowMsg == null; //Delegate1 d; //Delegate2 e; System.Delegate f; // Console.WriteLine(d==e); //Console.WriteLine(d==f); }
protected override void UseSample() { Del del = MethodOne; del += MethodTwo; Logger.Info($"Delegate invocation list consists of {del.GetInvocationList().GetLength(0)} elements"); del(); }
public void Run() { Del d = MethodOne; d += MethodTwo; d(); Console.WriteLine(d.GetInvocationList().GetLength(0)); }
public void MulticastDelegate() { Del d = MethodOne; d += MethodTwo; d(); Console.WriteLine("No. of methods that will be called = {0}", d.GetInvocationList().GetLength(0)); }
private static void Multicast() { Del d = MethodOne; d += MethodTwo; d(); var invocationCount = d.GetInvocationList().Count(); Console.WriteLine("d invocation count is: {0}", invocationCount); }
// a multicast delegate public static void Main(string[] args) { Del del = MethodOne; del += MethodTwo; del(); Console.WriteLine(del.GetInvocationList().GetLength(0)); Console.ReadKey(); }
public static void Multicast() { Del d = MethodOne; d += MethodTwo; d(); int invocationCount = d.GetInvocationList().GetLength(0); Console.WriteLine(invocationCount); }
public void MulticastingDelegates() { Del d = MethodOne; d += MethodTwo; d(); int invocationCount = d.GetInvocationList().GetLength(0); Console.WriteLine("Methods invoked by delegate: {0}", invocationCount); }
public void Multicast() { Del d = MethodOne; d += MethodTwo; Delegate[] list = d.GetInvocationList(); int count = list.GetLength(0); Console.WriteLine($"count 1: {list.Count()} "); Console.WriteLine($"count 2: {count} "); d(); }
public void Empezar() { //creamos un objeto delegado Del del = Escribir; //Le asignamos el metodo escribir sin necesidad de los parametros // Del del = new Del(Escribir);//otra forma de crear el obj del del("texto desde el programa principal");//LLamamos al delegado y pasamos el parametro como texto //tambien se puede enviar delegados como parametros MethodWithCallback(1, 2, del);//El metodo acepta un delegado, le pasamos del creado anteriormente //Se puede crear un delegados con varias delegados MethodClass obj = new MethodClass(); //Creamos un obj de la clase con dos metodos Del d1 = obj.Method1; //creamos un delegado llamado d1 Del d2 = obj.Method2; //creamos un delegado llamado d1 //Both types of assignment are valid. Del allMethodsDelegate = d1 + d2; allMethodsDelegate += del; //se puede llamar al método que te dice cuantos delegados tiene el obj int invocationCount = allMethodsDelegate.GetInvocationList().GetLength(0); Console.WriteLine("El delegado allmethodsDelegate tiene " + invocationCount + " delegados"); allMethodsDelegate("all methods"); //Si el delegado usa parámetros de referencia, la referencia se pasa secuencialmente a cada uno // de los tres métodos por turnos, y cualquier cambio que realice un método es visible para el // siguiente método. Cuando alguno de los métodos produce una excepción que no se captura dentro // del método, esa excepción se pasa al llamador del delegado y no se llama a los métodos siguientes // de la lista de invocación.Si el delegado tiene un valor devuelto o los parámetros de salida, // devuelve el valor devuelto y los parámetros del último método invocado. Para quitar un método // de la lista de invocación, utilice el operador de decremento o el operador de asignación de // decremento('-' o '-= '). Por ejemplo: //remove Method1 allMethodsDelegate -= d1; // copy AllMethodsDelegate while removing d2 Del oneMethodDelegate = allMethodsDelegate - d2; // Crear un delegado con un metodo anónimo. Del del3 = delegate(string name) { Console.WriteLine("Notification received for: {0}", name); }; //Crear un delegado con una expresión lambda. Del del4 = name => { Console.WriteLine("Notification received for: {0}", name); }; del4("del 4"); }
public static void RunMain() { Del d = MethodOne; d += MethodTwo; d(); int invoactionCount = d.GetInvocationList().GetLength(0); Console.WriteLine($" invoactionCount : {invoactionCount}"); }
public static void MulticastDelegate() { Del d = Metodo1; d += Metodo2; int invocationCount = d.GetInvocationList().GetLength(0); Console.WriteLine(invocationCount); d(); }
internal static void MultiCastingDelegates() { Del d = MethodOne; // Add subsequent methods to invocation list. d += MethodTwo; int invocationCount = d.GetInvocationList().GetLength(0); Console.WriteLine($"No. of methods in the invocationlist {invocationCount}"); d(); }
static void Main(string[] args) { UseDelegate(); //A multicast delegate Del d = MethodOne; d += MethodTwo; d(); int invocationCount = d.GetInvocationList().GetLength(0); // how many methods a multicast delegate is going to cal Console.WriteLine(invocationCount); UseCovariance(); }
static void Main(string[] args) { // Instantiate the delegate. Del handler = DelegateMethod; // Call the delegate. handler("Hello World"); MethodWithCallback(1, 2, handler); // A delegate can call more than one method when invoked. This is referred to as multicasting. // To add an extra method to the delegate's list of methods—the invocation list—simply requires // adding two delegates using the addition or addition assignment operators ('+' or '+='). var obj = new MethodClass(); Del d1 = obj.Method1; Del d2 = obj.Method2; Del d3 = DelegateMethod; //Both types of assignment are valid. Del allMethodsDelegate = d1 + d2; allMethodsDelegate += d3; allMethodsDelegate("multicasting message"); // At this point allMethodsDelegate contains three methods in its invocation list—Method1, Method2, and DelegateMethod. // The original three delegates, d1, d2, and d3, remain unchanged. When allMethodsDelegate is invoked, all // three methods are called in order. If the delegate uses reference parameters, the reference is passed // sequentially to each of the three methods in turn, and any changes by one method are visible to the next method. // When any of the methods throws an exception that is not caught within the method, that exception is passed // to the caller of the delegate and no subsequent methods in the invocation list are called. If the delegate // has a return value and/or out parameters, it returns the return value and parameters of the last method invoked. // To remove a method from the invocation list, use the subtraction or subtraction assignment operators (- or -=). // remove Method1 allMethodsDelegate -= d1; // copy AllMethodsDelegate while removing d2 Del oneMethodDelegate = allMethodsDelegate - d2; // Because delegate types are derived from System.Delegate, the methods and properties defined by that class // can be called on the delegate. For example, to find the number of methods in a delegate's invocation list, you may write: int invocationCount = d1.GetInvocationList().GetLength(0); // Delegates with more than one method in their invocation list derive from MulticastDelegate, which is a subclass of System.Delegate. // Multicast delegates are used extensively in event handling. Event source objects send event notifications to // recipient/ objects that have registered to receive that event. To register for an event, the recipient creates // a method designed to handle the event, then creates a delegate for that method and passes the delegate to the // event source. The source calls the delegate when the event occurs. The delegate then calls the event handling // method on the recipient, delivering the event data. The delegate type for a given event is defined by the event source. }
public static void Test() { MethodClass methodClass = new MethodClass(); Del del1 = DeleteMethod; Del del2 = methodClass.Method1; Del del3 = methodClass.Method2; Del handler = del1 + del2 + del3; handler("Hello World"); Console.WriteLine($"委托数量:{handler.GetInvocationList().Length}"); Console.WriteLine($"是否同一委托:{del1 == del2}"); }
public void Ex2_Multicast() { Del d = new Del(() => { Console.WriteLine("MethodOne"); return(1); }); d = d + this.Method2; d += () => { Console.WriteLine("MethodThree"); return(3); }; Console.WriteLine("Count: {0}", d.GetInvocationList().GetLength(0)); d -= this.Method2; // removes delegate Console.WriteLine("Count: {0}", d.GetInvocationList().GetLength(0)); int r = d(); // invokes group Console.WriteLine("Return: {0}", r); }
// A multicast delegate public MainListing1X76() { Del d = MethodOne; d += MethodTwo; d(); // Também é possível remover métodos de uma lista de métodos // usando o decrementador - ou -= // Para saber quantos métodos existem em um delegate int invocationCount = d.GetInvocationList().GetLength(0); Console.WriteLine(invocationCount); }
static void Main(string[] args) { Del d = MethodOne; d += MethodTwo; d += MethodThree; d -= MethodOne; //One will be removed //Find How many methods delegate gonna call int methodCount = d.GetInvocationList().Count(); Console.WriteLine("Delegate will call {0} methods", methodCount); d(); Console.ReadLine(); }
static void Main(string[] args) { Del d = MethodOne; //adiciona mais um metodo ao delegate d += MethodTwo; //chama todos os metedos adicionados ao delegate d(); //remove o metodo da lista, caso não exista esse metodo no delegate ele não irá retorna um exception d -= MethodOne; d(); d += MethodOne; //Pega quantidade de metodo que está no delegate int count = d.GetInvocationList().GetLength(0); Console.WriteLine(count); Console.Read(); }
//Along with the static DelegateMethod shown previously, we now have three methods that can be wrapped by a Del instance. public void exampleForInstanceMethod() { MethodClass obj = new MethodClass(); Del d1 = obj.Method1; Del d2 = obj.Method2; Del d3 = DelegateMethod; //Both types of assignment are valid. Del allMethodsDelegate = d1 + d2; allMethodsDelegate += d3; //At this point allMethodsDelegate contains three methods in its invocation list—Method1, Method2, and DelegateMethod. //The original three delegates, d1, d2, and d3, remain unchanged. When allMethodsDelegate is invoked, all three methods are called in order. //If the delegate uses reference parameters, the reference is passed sequentially to each of the three methods in turn, //and any changes by one method are visible to the next method. //When any of the methods throws an exception that is not caught within the method, //that exception is passed to the caller of the delegate and no subsequent methods in the invocation list are called. //If the delegate has a return value and/or out parameters, it returns the return value and parameters of the last method invoked. //To remove a method from the invocation list, use the decrement or decrement assignment operator ('-' or '-='). For example: //remove Method1 allMethodsDelegate -= d1; // copy AllMethodsDelegate while removing d2 Del oneMethodDelegate = allMethodsDelegate - d2; //Because delegate types are derived from System.Delegate, the methods and properties defined by that class can be called on the delegate. //For example, to find the number of methods in a delegate's invocation list, you may write: int invocationCount = d1.GetInvocationList().GetLength(0); //Comparing delegates of two different types assigned at compile-time will result in a compilation error. //If the delegate instances are statically of the type System.Delegate, then the comparison is allowed, but will return false at run time. For example: // Compile-time error. //Console.WriteLine(d1 == e2); // OK at compile-time. False if the run-time type of f // is not the same as that of d. System.Console.WriteLine(d1 == d2); }
static void Main(string[] args) { Del handler = DelegateMethod; handler("DelegateMethod"); MethodWithCallback(1, 2, handler); MethodClass obj = new MethodClass(); Del d1 = obj.Method1; Del d2 = obj.Method2; Del d3 = DelegateMethod; Del allMethodDelegate = d1 + d2; allMethodDelegate += d3; allMethodDelegate -= d1; Del oneMethodDelegate = allMethodDelegate - d2; int invocationCount = d1.GetInvocationList().GetLength(0); }
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 }