Using ref, out param in Lambda

They are widely used in event handling, LINQ queries, and other scenarios where you need short, inline functions.

The Basics of Lambda Expressions in C#

In most cases, you can define a lambda expression without explicitly specifying the types of parameters.

The compiler is capable of inferring the types based on the context in which the lambda is used.

button1.Click += (sender, e) => { /* Handle the click event */ };

Here, sender and e are implicitly inferred from the context of the Click event (typically of type object and EventArgs, respectively). The lambda expression in this case is concise and doesn't require type definitions for the parameters.

The Exception: Ref and Out Parameters

Lambda expressions, by design, don’t provide an easy way to handle this without being told the parameter types upfront.

Here, you must explicitly define the parameter types:

ie.DocumentComplete += (object pDisp, ref object url) 
                        => { /* Handle the DocumentComplete event */ };

In this example, the DocumentComplete event takes a ref parameter for url. Because ref parameters cannot be inferred from the context, the type of the parameter (object) must be explicitly declared.

Using Ref Parameters with a Lambda Expression

Let's say we have a method that accepts a ref parameter.

public void GetData(ref string data)
{
    data = "Updated Data";
}

Normally, if you were using this method in a regular delegate, you might invoke it like so:

string myData = "Initial Data";
GetData(ref myData);

However, if you wanted to use a lambda expression to handle this, you'd need to specify the type of the ref parameter explicitly:

Action<ref string> action = (ref string data) => { data = "Updated Data"; };
string myData = "Initial Data";
action(ref myData);
Console.WriteLine(myData);  // Outputs: Updated Data

Here, the lambda expression must explicitly define the type of the ref parameter (ref string data), which differs from how you would handle non-ref parameters where type inference would be sufficient.