[Proposal] Pass instance in delegate to lambda to avoid allocation by closure capture

[CortiWins]

Hooking a lambda to an event often creates a closure that purely contains "this", while "this" is already contained in the delegate, which makes it two allocations while there practially only needs to be one.

Example of the issue

Two variants of hooking a method to an event.

void Method()
{
  // Version 1:
  this.OnEventHappening += () => 
  {
    this.LogStuff("Something happened!);
  }
	
  // Version 2:
  this.OnEventHappening += LocalFunction;
  void LocalFunction()
  {
    this.LogStuff("Something happened!);
  }
}

Version 1:

1. Allocates a delegate, the delegate contains a reference to the instance "this".
2. Emits a class that holds "this" as a field to allow capturing of the closure.

Version 2:

1. Allocates a delegate, the delegate contains a reference to the instance "this".

Idea for a solution

Allow the delgate to pass it's instance to the lamba.

// this as a parameter from the delegate.
this.OnEventHappening += (this) =>
{
  this.LogStuff("Something happened!);
}

// this as a parameter in addition to existing delegate arguments
button.Click += (this, s, e) =>
{
  this.LogStuff("Button clicked);
}

// combine with static to disallow capture of other data
this.OnEventHappening += static (this) =>
{
  this.LogStuff("Something happened!);
}

[timcassell]

I don't think we need any new syntax to optimize the lambda. The compiler can just emit more optimized code if the lambda only captures this.

[huoyaoyuan]

Version 1:

1. Allocates a delegate, the delegate contains a reference to the instance "this".
2. Emits a class that holds "this" as a field to allow capturing of the closure.

Version 2:

1. Allocates a delegate, the delegate contains a reference to the instance "this".

The assumption is incorrect. Both versions are using an instance method on this. See https://sharplab.io/#v2:D4AQTAjAsAUCDMACciDCiDetE8QUwDc8A7AF2QjEQHliBRIsgCQEMAHNkgS2IHMBubLhAAWRABkA9rwDKpAK4AzRQAo5AJx69ELdbwCUGAL5Ccp5GICyeUgAtJAExX7zWGLlwB6T4gBqedQBnLkliRAgALnMcOy5AgDpaBhJSVg5uPkQAagBeRGdEHIA+RGjMMpjbOPipWQVlFQAiGUkAWxsqzNt2TmI8BwBCRv1Bdw9EI1Gy7z8A4NDEMCixj1iEpMZUnoztXIlJAGMWABsQAFZSEOJR8Yt9o9OLq+cyt1vK6tq5JVVmto6tIhuuk+oNhjdxiYVhNYEYgA= .

The compiler already optimizes delegate creation with best effort. It's an implementation detail and no new syntax is required.

[CortiWins]

Oh that is fascinating, @huoyaoyuan. In my test, that did not happen, and i managed to find out why.

Example 1: if both the lamba and the local function only require the capture of this, they are created as member method and no display_class is created.

https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA+ABATARgLABQGADAAQY4oDchJ5OAdADICWAdgI41FkUMAqMBABdudCgFZuhNgEMAtjADOAB1lgYpAMIQ2SiABsYAQRUr8BAN6FSt0u2Ewocg+Sz0A7DbvWCd/6QwAG4wbML07gDybACiIWEAErJmoewA5twBdt5ZGCikALIw8sBOGBLCLLoAFADKwlDppLJQaQCUOQG+Wbk4AJzVACQARACqSsqkalAKpJYtaQC+zWwAJvZ6wrJsGqSrsltzwgAWLEoCEPWNbGnVbYvDbdJ+PYuEnf4A9J+kMQgKKiMpBwIFIADkIHszoDZABPNykMCwA4wVYMD52PKkRxKYR3DG2bo9L4/ABqTiUVTYwNBTAUwFk2OOB1IsA4AFcWLAlEyzgAaUjAdnhMDbQWaVa6TQAdxYJwgwqhqgMcLcBICJzODGicVCwiSKTYTQA1ABeUh3UimgB86v8ROJWU15yKJTKFSp1WGtQgik1N0CBgmpGZhtRAEJHplHbZFtGY+8XjHvqRyVBKbpSFhQQARCCTNgQcJszmwZpKmHwgBm7J2lV06KTjud2ti8X1yRUqQDZtITAgooM5XrbHjjqx/cHw89HSbxIdMbsLddpSg05q3t9MH9aRDndCEajdrsbznJ86p9PQA

Example 2: If one lambda requires capture of a stack variable through a display_class, even the cases where the display_class is not required are created as members of the display_class

https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA+ABATARgLABQGADAAQY4oDchJ5OAdADICWAdgI41FkUMAqMBABdudCgFZuhNgEMAtjADOAB1lgYpAMIQ2SiABsYAQRUr8BAN6FSt0u2Ewocg+Sz0A7DbvWCd/6QwAG4wbML07gDybACiIWEAErJmoewA5twBdt5ZGCikALIw8sBOGBLCLLoAFADKwlDppLJQaQCUOQG+Wbk4AJzVACQARACqSsqkalAKpJYtaQC+zWwAJvZ6wrJsGqSrsltzwgAWLEoCEPWNbGnVbYvDbdJ+PYuEnf4A9J+kMQgKKiMpCwIFIABEzoDZABPNykMCwA4wdbBUKkABm0FIJ006IArjtKrolHsIKQ2BBwoiDAZYWwYMj7MIAPwfOx5bHKYR3Nm2bo9L4/ABqTiUVTYpBwoKYCmAsmxxwOpFgHDxLFgJJOZwANKRgHjwpA8QZ1qVSfTSAB3FgnCAGvaQgwwty8gJa87ROKhYRJFJsJoAagAvKQ7qQgwA+V3+fkCrLuhhFEplCri6rDWoQRRam6BAwTUiKv3IgCEj0ycdsiwrlfeL0r31IIqgYt0wNBYIgkwpVJgqvVmnlq0dzvxhPFDGjdgTnviPuSKlSueDpCYEDAsgM5SJbBrcY5a43W9TNQ69bjscr09O5yTpSg27TGazMBzaULC9CpfLU6rv9I/6Ns2rYSgAzB2XYkiqaqwAqmgbiowh4rBEDoqQShbGAADWpBBC0LCyMARiAT82zrCceJQX2MGTEOI6wtgGJYji8IGBASjITA/4OM04akFI/4zrEc6+ou/rLiGYaRv+l5XrYCZ3imO7ppm2anLmIRQLCMD5poRZid+pABs0FxXOkdxPP+1aum8562bZQA=

I this case, it is not really that wasteful because the display_class already exists for the lambda that really needs it.

Example 3: A pair of extra brackets prevents that from happening.

https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA+ABATARgLABQGADAAQY4oDchJ5OAdADICWAdgI41FkUMAqMBABdudCgFZuhNgEMAtjADOAB1lgYpAMIQ2SiABsYAQRUr8BAN6FSt0u2Ewocg+Sz0A7DbvWCd/6QwAG4wbML07gDybACiIWEAErJmoewA5twBdt5ZGCikALIw8sBOGBLCLLoAFADKwlDppLJQaQCUOQG+Wbk4AJzVACQARACqSsqkalAKpJYtaQC+zWwAJvZ6wrJsGqSrsltzwgAWLEoCEPWNbGnVbYvDbdJ+PYuEnf4A9J+kMQgKKiMpCwIFIABEzoDZABPNykMCwA4wdbBUKkABm0FIJ006IArjtKrolHsIKQ2BBwoiDAZYWwYMj7MIAPwfOx5bHKYTVYAQQzNYRbMDHJgKYD7DovLLdHpfH4ANScSiqbFIOFBopKsmxxwOpFgHDxLFgJJOZwANKRgHjwpA8QZ1qVSfTSAB3FgnCA2vaQgwwtxsrJm87ROKhYRJFJsJoAagAvKQ7qQ4wA+QNddOy4MMIolMoVFXVYa1CCKM03QIGCakXVR5EAQkemVldkWzZbpHeUpb31Iiqgyt0wNBYIgkwpVJghuNmm1q19/vxhJVDEzdmzofiEeSKlSFfjpCYEDAsgM5SJbHbLY5R5PZ4LNUlHdsMuf69O51zpSg58LxdLMDlmkNY7qEDZNmuthvAQkGdt2sq9n8DTakokC7laMwANaASSKiwFufZKiqaorOs/aDqq7jolApZWjATQqN6DhkjiPqqH60IAPrYLBr5vqQvbkcRADMI5jiSBpGrAOqaCeKjCHi0kQOipBKEKmGkEELQsLIwBGLBcqkTqeISVOUmTHOC6wtgGJYqxYAGBASiKTABl2A4zTJqQUhubYG6xFuka7tG+4Jkmqa+XMkUBNmX75heRYlmWpwViEUCwjAVaaLWwXgaQMbNBcVzpHcTyRW2sHQbKVWtoQ0FAA

As a language proposal, this discussion is done. Thank you both @timcassell and @huoyaoyuan!