Use Delegate.EnumerateInvocationList instead of Delegate.GetInvocationList

[ThomasGoulet73]

Description

Use Delegate.EnumerateInvocationList instead of Delegate.GetInvocationList. Delegate.GetInvocationList allocates an array on every call while Delegate.EnumerateInvocationList doesn't allocate which makes the code faster and use less memory.

I also used Delegate.HasSingleTarget for places where we only wanted to check if there was only one entry in Delegate.GetInvocationList, which makes it even faster.

Delegate.EnumerateInvocationList and Delegate.HasSingleTarget were added in .Net 9.0 Preview 4 with dotnet/runtime#97683.

Benchmark results for Delegate.EnumerateInvocationList:

Method	count	eventHandler	Mean	Error	StdDev	Ratio	RatioSD	Gen0	Allocated	Alloc Ratio
GetInvocationList	1	Syste(...)Args] [39]	6.159 ns	0.1593 ns	0.2872 ns	1.00	0.00	0.0019	32 B	1.00
EnumerateInvocationList	1	Syste(...)Args] [39]	3.389 ns	0.0120 ns	0.0100 ns	0.55	0.02	-	-	0.00
GetInvocationList	5	Syste(...)Args] [39]	24.718 ns	0.2882 ns	0.2555 ns	1.00	0.00	0.0038	64 B	1.00
EnumerateInvocationList	5	Syste(...)Args] [39]	8.205 ns	0.0431 ns	0.0382 ns	0.33	0.00	-	-	0.00
GetInvocationList	10	Syste(...)Args] [39]	46.508 ns	0.9130 ns	1.1547 ns	1.00	0.00	0.0062	104 B	1.00
EnumerateInvocationList	10	Syste(...)Args] [39]	14.742 ns	0.0720 ns	0.0602 ns	0.32	0.01	-	-	0.00

I used this benchmark:

Code

[MemoryDiagnoser]
public class GetInvocationListVsEnumerateInvocationListBenchmark
{
  public IEnumerable<object[]> GetArguments()
  {
      EventHandler<EventArgs> handler = (s, e) => { };

      yield return [1, handler];

      EventHandler<EventArgs> handler2 = (s, e) => { };

      for (int x = 0; x < 4; x++)
          handler2 += (s, e) => { };

      yield return [5, handler2];

      EventHandler<EventArgs> handler3 = (s, e) => { };

      for (int x = 0; x < 9; x++)
          handler3 += (s, e) => { };

      yield return [10, handler3];
  }

  [Benchmark(Baseline = true)]
  [ArgumentsSource(nameof(GetArguments))]
  public Delegate GetInvocationList(int count, EventHandler<EventArgs> eventHandler)
  {
      Delegate result = null;
      foreach (Delegate value in eventHandler.GetInvocationList())
      {
          result = value;
      }
      return result;
  }

  [Benchmark]
  [ArgumentsSource(nameof(GetArguments))]
  public Delegate EnumerateInvocationList(int count, EventHandler<EventArgs> eventHandler)
  {
      EventHandler<EventArgs> result = null;
      foreach (EventHandler<EventArgs> value in Delegate.EnumerateInvocationList(eventHandler))
      {
          result = value;
      }
      return result;
  }
}

Benchmark results for Delegate.HasSingleTarget:

Method	count	eventHandler	Mean	Error	StdDev	Ratio	Gen0	Allocated	Alloc Ratio
GetInvocationList	1	Syste(...)Args] [39]	6.4361 ns	0.1005 ns	0.0940 ns	1.00	0.0019	32 B	1.00
HasSingleTarget	1	Syste(...)Args] [39]	0.9718 ns	0.0009 ns	0.0008 ns	0.15	-	-	0.00
GetInvocationList	5	Syste(...)Args] [39]	19.6740 ns	0.3254 ns	0.2717 ns	1.00	0.0038	64 B	1.00
HasSingleTarget	5	Syste(...)Args] [39]	0.9788 ns	0.0032 ns	0.0030 ns	0.05	-	-	0.00
GetInvocationList	10	Syste(...)Args] [39]	38.0967 ns	0.7512 ns	0.7714 ns	1.00	0.0062	104 B	1.00
HasSingleTarget	10	Syste(...)Args] [39]	0.9816 ns	0.0017 ns	0.0014 ns	0.03	-	-	0.00

I used this benchmark:

Code

[MemoryDiagnoser]
public class GetInvocationListVsHasSingleTargetBenchmark
{
  public IEnumerable<object[]> GetArguments()
  {
      EventHandler<EventArgs> handler = (s, e) => { };

      yield return [1, handler];

      EventHandler<EventArgs> handler2 = (s, e) => { };

      for (int x = 0; x < 4; x++)
          handler2 += (s, e) => { };

      yield return [5, handler2];

      EventHandler<EventArgs> handler3 = (s, e) => { };

      for (int x = 0; x < 9; x++)
          handler3 += (s, e) => { };

      yield return [10, handler3];
  }

  [Benchmark(Baseline = true)]
  [ArgumentsSource(nameof(GetArguments))]
  public bool GetInvocationList(int count, EventHandler<EventArgs> eventHandler)
  {
      return eventHandler.GetInvocationList().Length != 1;
  }

  [Benchmark]
  [ArgumentsSource(nameof(GetArguments))]
  public bool HasSingleTarget(int count, EventHandler<EventArgs> eventHandler)
  {
      return !eventHandler.HasSingleTarget;
  }
}

Customer Impact

Improved performance and reduced allocations.

Regression

No.

Testing

Local testing

Risk

Low.

Microsoft Reviewers: Open in CodeFlow

[lindexi]

LGMT

[h3xds1nz]

I'd remove the outer null checks as EnumerateInvocationList accepts null and returns an empty enumerator (false). Same in PropertyMetadata. Otherwise LGTM.

[ThomasGoulet73]

I'd rather keep it that way since it would make cases when _threadPreprocessMessage is null slower while maybe making a tiny perf gain by skipping a null check. Your suggestion would require knowing how often it is called with a null delegate vs a non null delegate, which is more complex.

[h3xds1nz]

Yes, that is a fine argument. Maybe I'll feel bored someday but probably not.

[miloush]

Just out of curiosity, does subscribing/unsubscribing in the handler not make the enumerator unhappy?

[ThomasGoulet73]

Just out of curiosity, does subscribing/unsubscribing in the handler not make the enumerator unhappy?

Delegates are immutable (subscribing/unsubscribing creates a new delegate instance) so I don't believe we can make the enumerator unhappy: https://learn.microsoft.com/en-us/dotnet/api/system.delegate?view=net-8.0#:~:text=Delegates%20are%20immutable%3B%20once%20created%2C%20the%20invocation%20list%20of%20a%20delegate%20does%20not%20change.