C# Language Design Notes for Jan. 16th, 2019

Agenda

1. Shadowing in lambdas
2. pattern-based disposal in await foreach

Discussion

Shadowing in nested functions

Q: Allow shadowing for all lambdas as well?

A: Yes.

Q: Allow shadowing with range variables in LINQ queries?

// char c;
var q = from c in s
        from c2 in s
        where c != ' '
        select c;
var q2 = s
    .SelectMany(c => s, (c, c2) => new { c, c2 })
    .Where(_x => _x.c != ' ')
    .Select(_x => _x.c);

c and c2 can't be named the same because they are equivalent to two parameters being named the same. However, should the new c be able to shadow the local c?

A: Let's look at the implementation and decide based on the complexity.

Pattern-based disposal in await foreach

WithCancellation and ConfigureAwait both return a custom type that does not implement the interface, just the pattern. await foreach does not pick it up because it does not have pattern-based disposal and the type cannot implement the IAsyncDisposable type because it does not produce a ValueTask return for disposal.

Proposals:

1. Just allow pattern-based disposal for IAsyncDisposable. Only allow pattern-based disposable for IDisposable in ref structs.

   a. For await foreach, use the pattern, then dynamically check for interface and use it if present.

   b. For await foreach, use the pattern, then statically check for the interface and use it if present.

The dynamic check in (1a) is used because in C# 1.0 the non-generic IEnumerator did not implement IDisposable.

The next question is whether to consider extension methods. The standard pattern we've previously settled on is:

1. Check for pattern
2. Check for interface
3. Check for extension methods

Can we use this pattern for IAsyncDisposable? The primary question is whether to consider extension methods.

Conclusion

Let's do 1b. We do not have a non-generic IAsyncEnumerator that doesn't implement IAsyncDisposable, so the dynamic check is unnecessary.

We will not consider extension methods for IAsyncDisposable or IDisposable (on ref structs). We will consider extension methods for IAsyncEnumerable and IEnumerable.