C# delegation and Lambda expression conversion mechanism and life cycle analysis in weak event mode

1. Delegate internal structure

The delegate type contains three important non-public fields:

_target field
- Static method packaging: When delegate wraps a static method, this field is null.
- Example method packaging: When delegating the wrapper instance method, this field refers to the object operated by the callback method.
_methodPtr field
- Identifies the method to be called by the delegate.
_invocationList field
- Store delegate chains (i.e., internal delegate arrays) to implement multicast delegate.

2. Convert Lambda expression to delegate instance

The C# compiler will convert the lambda expression into the corresponding delegate instance, and the specific conversion method depends on whether the lambda captures external data.

2.1 No external data captured

Conversion method：
- Generate the lambda expression into a private static function (the compiler automatically generates the method name).
- A static field of delegate type is generated at the same time to cache the delegate instance.
Delegate instance creation and caching：
- When calling a method containing lambda, first check whether the static field is null.
- If not null, the cached delegate instance is directly returned; if null, a new delegate instance is created and assigned to the static field.
- This method ensures that the delegate instance is created only once and will not be recycled after being referenced by a static field.

2.2 Capture instance members (accessed via this)

Conversion method：
- Generate the lambda expression into a private instance function (the compiler automatically generates the method name).
Delegate instance creation：
- Each time a method containing lambda is called, a new delegate instance is created in real time, wrapping the instance function.

2.3 Capture non-instance members (such as local variables)

Conversion method：
- The compiler generates a private auxiliary closure class (usually named "<>c__DisplayClassXXX").
- The auxiliary class contains public fields that hold captured local variables (or other non-instance data).
- In this helper class, the lambda expression is converted into an exposed instance function, which uses captured data by accessing the helper class field.
Delegate and closure instance creation：
- Each time a method containing a lambda is called, a helper class instance is generated.
- Then create a delegate instance whose _target field points to the secondary class instance.
- Notice: Closure traps are easily generated in loops - although multiple auxiliary class instances and delegate instances may be created in each iteration, the capture fields in these auxiliary class instances point to the same piece of memory (i.e., sharing the same loop variable). Since lambda expressions are usually executed after the loop ends, all callbacks see loop variable values often appear in the state of the last iteration.
- In addition, different versions of C# may have differences in the creation of auxiliary class instances in loops. Some versions may only be created once when entering the method, while others create new instances in each iteration. As for the delegate instance, I guess that a new delegate instance will be created every iteration (otherwise there may be duplicate issues when used as a dictionary key), but the example code in CLR Via C# Fourth Edition (Section 17.7.3, Chinese version Page 365) It shows that the commissioned instance has only been created once. I feel that there is a problem here. Interested friends can analyze it.

3. Subscription and life cycle of delegated instances

3.1 General Delegation/Event Subscription

When the delegate instance subscribes to a regular delegate or event, the event source holds the delegate instanceStrong quote, thereby extending the life cycle of the delegate instance (unsubscribe or event source recycle).

3.2 Weak Event Subscription

Features of weak event mode：
- The life cycle of a delegate instance is at least greater than the life cycle of the object its _target references.
Implementation mechanism：
- useConditionalWeakTable<TKey, TValue>Make association:
  - Take the object referenced by _target as the key.
  - Take the delegate instance as a value.
- ConditionalWeakTable uses weak references to keys, but uses strong references to value, ensuring that as long as the key exists, the corresponding value will not be recycled.
Subscription Process：
- When the delegate instance passesWeakEventManager<TEventSource, TEventArgs>When subscribing to weak events, internal access will be passedGets the object referenced by _target and associates the object with the delegate instance into the ConditionalWeakTable, ensuring that the lifecycle of the delegate instance is at least consistent with the _target object.

The above has been retyped with tools, and the following is the original text I edited:

The delegate type contains three important non-public fields: the _target field. When the delegate instance wraps a static method, the field is empty; when wrapping the instance method, this field refers to the object to which the callback method is to operate. The _methodPtr field identifies the method to callback. The _invocationList field references the delegate array.

The C# compiler replaces the lambda method with the corresponding delegate instance.

When the lambda does not get any external data, the call creates the delegate instance only once and caches it: the C# compiler generates the lambda expression into a private static function (a method that the compiler automatically named) and generates a static field of the delegate type. When calling the method using lambda, first determine whether the automatically generated static field is empty. If it is not empty, it will directly return the delegate instance referenced by the static field. If it is empty, first create a delegate instance wrapping the static function and assign it to the static delegate field. (This causes the delegate instance referenced by the static field to not be released, but the delegate instance will only be created once).

When a lambda gets an instance member (accessed through this pointer), a new delegate instance is created every call: the C# compiler generates the lambda expression into a private instance function (a method that the compiler automatically named). Each time a method using lambda is called, a delegate instance is created in real time to wrap the automatically generated instance function.

When a lambda obtains a non-instance member (not accessed through this pointer of the current instance, such as local variables), the C# compiler creates a private auxiliary class. The auxiliary class has the corresponding public field to reference the non-instance member, and the auxiliary class will be selected in the auxiliary class. The lambda expression is generated as a public instance function. Each time a method using lambda is called, a helper class instance is generated, a reference to the same non-instance member is referenced, and a delegate instance is created to pass into the helper class instance. (The closure trap in a loop is that although multiple auxiliary class instances and delegate instances are created in the loop, the non-instance members referenced by different auxiliary class instances are the same piece of memory. The lambda expression is created in the loop, but its execution is performed. It often happens after the loop ends, so all loop variables seen by the callback are the final state.andDifferent versions of C# are implemented inThere may not be a secondary class instance of the number of loops created in the loop, but it is created only once when entering the method. I guess that the delegate instance of the number of loops was created, otherwise it should have an error when used as a key to the dictionary. However, the delegated instance is only created once in the sample code given by CLR Via C#, which may be a bit problematic. Interested friends can analyze it.）

After the lambda is converted into a delegate instance, when the delegate instance is subscribed to a regular delegate or event, the event source strongly references the delegate instance.

When subscribing the delegate instance to a weak event, there is an interesting phenomenon: the life cycle of the delegate instance is at least greater than the life cycle of the object referenced by _target. This is achieved through ConditionalWeakTable<TKey, TValue>, by setting the object referenced by _target to key and setting the delegate instance to value. This class is responsible for the association between data. It is a weak reference to the key, but it guarantees that as long as the key is in memory, the value must be in memory.

When the delegate instance subscribes to a weak event through WeakEventManager<TEventSource, TEventArgs>, the delegate instance will be associated as the value of the ConditionalWeakTable by getting the object referenced by _target in the delegate instance as the key of the ConditionalWeakTable. This ensures that the life cycle of the delegate instance in weak event mode is at least greater than the life cycle of the object referenced by _target.

public void AddHandler(Delegate handler)
{
    (_users == 0, "Cannot modify a ListenerList that is in use");
    object obj = ;
    if (obj == null)
    {
        obj = StaticSource;
    }

    _list.Add(new Listener(obj, handler));
    AddHandlerToCWT(obj, handler);
}

private void AddHandlerToCWT(object target, Delegate handler)
{
    if (!_cwt.TryGetValue(target, out var value))
    {
        _cwt.Add(target, handler);
        return;
    }

    List<Delegate> list = value as List<Delegate>;
    if (list == null)
    {
        Delegate item = value as Delegate;
        list = new List<Delegate>();
        (item);
        _cwt.Remove(target);
        _cwt.Add(target, list);
    }

    (handler);
}