¿Cómo trabajan los delegados internamente?

How do delegates work internally?

Delegate internally has an array of references to each method and when the delegate runs Invoke() method, all the referenced methods are invoked in line. Because it is an object assigned to a variable, we can treat it as a normal variable and pass it as a parameter.

A Delegate is an object which refers to a method or you can say it is a reference type variable that can hold a reference to the methods. Delegates in C# are similar to the function pointer in C/C++….Delegates vs Interfaces in C#

A delegate is a type that represents references to methods with a particular parameter list and return type. When you instantiate a delegate, you can associate its instance with any method with a compatible signature and return type. You can invoke (or call) the method through the delegate instance.

It is a reference type. It is a function pointer or it holds a reference (pointer) to a function (method). It is type safe. Delegates are mainly used for the event handling and the callback methods.

At stake in each primary or caucus is a certain number of delegates. These are individuals who represent their state at national party conventions. The candidate who receives a majority of the party’s delegates wins the nomination. Each party also has some unpledged delegates or superdelegates.

The Democratic Party uses a proportional representation to determine how many delegates each candidate is awarded in each state. A candidate must win at least 15% of the vote in a particular contest in order to receive any delegates. Pledged delegates are awarded proportionally in both state-wide and regional contests.

So the internal implementation of a delegate, the part responsible for calling a method, is created by the runtime. This is because there needs to be complete control over those methods, delegates are a fundamental part of the CLR, any security issues, performance overhead or other inefficiencies would be a big problem.

The delegates are actually the .NET implementation of functions pointers and they are object-oriented, type safe and secure unlike C++ functions pointers. Therefore, we can say that delegates are the .NET reference objects which can be used to invoke methods of matching signatures and return type.

Once a delegate is instantiated, a method call made to the delegate will be passed by the delegate to that method. The parameters passed to the delegate by the caller are passed to the method, and the return value, if any, from the method is returned to the caller by the delegate. This is known as invoking the delegate.

To invoke a method using a delegate, first we define a custom delegate reference type using the delegate keyword and declare its parameters list and a return type according the target method then we declare an instance from it and instantiate it by assigning the target method to it as parameter.

Terminology: Invoking a method = executing a method. Other phrases with exactly the same meaning: calling a method. running a method.

A delegate is a way of telling C# which method to call when an event is triggered. For example, if you click a Button on a form, the program would call a specific method. It is this pointer that is a delegate. Delegates are good, as you can notify several methods that an event has occurred, if you wish so.

The parameters passed to the delegate by the caller are passed to the method, and the return value, if any, from the method is returned to the caller by the delegate. This is known as invoking the delegate. An instantiated delegate can be invoked as if it were the wrapped method itself. For example: C#.

If you invoke a delegate, it calls all the function pointers in that internal list. Adding and removing a receiver (via Delegate.Combine and Delegate.Remove) amounts to adding to and removing from that list. For more low-level information, refer to ECMA-335 (the CLI standard), section II.14.5 (Method pointers) and II.14.6 (Delegates).