5.8 KiB
C# Language Design Notes for Feb 21, 2017
Agenda
We triaged some of the championed features, to give them a tentative milestone and ensure they had a champion.
As part of this we revisited potential 7.1 features and pushed several out.
- Implicit interface implementation in Visual Basic (VB 16)
- Delegate and enum constraints (C# X.X)
- Generic attributes (C# X.0 if even practical)
- Replace/original (C# X.0 if and when relevant)
- Bestest betterness (C# 7.X)
- Null-coalescing assignments and awaits (C# 7.X)
- Deconstruction in from and let clauses (C# 7.X)
- Target-typed
new
expressions (C# 7.X) - Mixing fresh and existing variables in deconstruction (C# 7.1)
- Implementing
==
and!=
on tuple types (C# 7.X) - Declarations in embedded statements (No)
- Field targeted attributes on auto-properties (C# 7.1)
Implicit interface implementation in Visual Basic
Champion "Implicit interface implementation"
This long-requested feature in VB would also help deal with problems related to default implementations of interface members.
Conclusion
Candidate for VB 16.
Delegate and enum constraints
Champion "Generic constraint delegate
(or allow System.Delegate
as a constraint)"
Champion "Generic constraint enum
(or allow System.Enum
as a constraint)"
This is a common request. Could
- semantically require an actual delegate/enum or just allow the base class
- syntactically show up as either the base class or the keyword
For delegates we need to consider how to deal with MulticastDelegate
.
Conclusion
Candidates for a minor C# version.
Generic attributes
Champion "Allow Generic Attributes"
Even though this would work in principle, there are bugs in most versions of the runtime so that it wouldn't work correctly (it was never exercised).
We need a mechanism to understand which target runtime it works on. We need that for many things, and are currently looking at that. Until then, we can't take it.
Conclusion
Candidate for a major C# version, if we can make a sufficient number of runtime versions deal with it.
Replace/original
Champion "Replace/original and code generation extensions"
If there's renewed investment in source generators, we'll add this, but this is not driven from the language end.
Conclusion
Candidate for a major C# version, if and when source generators or similar efforts take place.
Bestest betterness
We want to do it, but not low-hanging enough for C# 7.1 time frame.
Conclusion
Candidate for a minor C# release in the 7.X wave.
Null-coalescing assignments and awaits
Champion "Null-coalescing assignments"
Champion "Null-conditional await"
These need a little more design work and general bake time than what 7.1 allows.
await?
is an odd kind of keyword, but changing await
to not throw on null may also be an issue. Thought needed.
Conclusion
Candidate for a minor C# release in the 7.X wave.
Deconstruction in from and let clauses
Champion "deconstruction in from and let"
Too many worms in the can for 7.1.
Conclusion
Candidate for a minor C# release in the 7.X wave.
Target-typed new
expressions
Champion "Target-typed new
expression"
Links well with target typed default
expressions, but too much design and potential fallout for 7.1. Interaction with anonymous objects as well.
Conclusion
Candidate for a minor C# release in the 7.X wave.
Mixing fresh and existing variables in deconstruction
Champion "Mix Declarations and Variables in Deconstruction"
This rounds out the C# 7.0 experience, and was a late design change we didn't get to implementing.
May lead to occasional confusion, as in M((int x, y) = e)
(declaring y
)? We are OK with that.
Conclusion
Candidate for C# 7.1.
Implementing ==
and !=
on tuple types
Champion "Support for == and != on tuple types"
There's design work. It's not just call .Equals
recursively.
==
today works between int and byte, for instance. We should probably make (i1, i2) == (b1, b2)
work with that same equality.
Also for generics, for a type parameter T
and a t
of that type, we should allow (t, i) == (null, 0)
by recursively applying the special "compare to null" semantics of equality over type parameters of C# today.
Too big for 7.1.
Conclusion
Candidate for a minor C# release in the 7.X wave.
Declarations in embedded statements
Now that you can declare expression variables in an embedded statement, it's odd that old-fashioned declaration statements are forbidden in an embedded position (such as an if-branch, for instance). However, now that you can use a discard instead of a dummy variable declaration, the motivating scenario also goes away.
Conclusion
Let's not do it.
Field targeted attributes on auto-properties
Champion "Auto-Implemented Property Field-Targeted Attributes"
Technically a breaking change, since the field target is already permitted today, but ignored. We don't expect anyone to be relying on this, though!
Conclusion
Candidate for 7.1.