csharplang Documentation

The official repo for the design of the C# programming language

12,719 stars C# C# 1 file · ~42,930 tokens #csharp#language-design
RAW Doc

Technical Documentation: dotnet/csharplang

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

Overview (`README.md`)

C# Language Design

Welcome to the official repo for C# language design. This is where new C# language features are developed, adopted and specified.

C# is designed by the C# Language Design Team (LDT) in close coordination with the Roslyn project, which implements the language.

You can find:

If you discover bugs or deficiencies in the above, please leave an issue to raise them, or even better: a pull request to fix them.

For new feature proposals, however, please raise them for discussion, and only submit a proposal as an issue or pull request if invited to do so by a member of the Language Design Team (a "champion").

The complete design process is described here. A shorter overview is below.

Discussions

Debate pertaining to language features takes place in the form of Discussions in this repo.

If you want to suggest a feature, discuss current design notes or proposals, etc., please open a new Discussion topic.

Discussions that are short and stay on topic are much more likely to be read. If you leave comment number fifty, chances are that only a few people will read it. To make discussions easier to navigate and benefit from, please observe a few rules of thumb:

  • Discussion should be relevant to C# language design. If they are not, they will be summarily closed.
  • Choose a descriptive topic that clearly communicates the scope of discussion.
  • Stick to the topic of the discussion. If a comment is tangential, or goes into detail on a subtopic, start a new discussion and link back.
  • Is your comment useful for others to read, or can it be adequately expressed with an emoji reaction to an existing comment?

Language proposals which prevent specific syntax from occurring can be achieved with a Roslyn analyzer. Proposals that only make existing syntax optionally illegal will be rejected by the language design committee to prevent increased language complexity.

Proposals

When a member of the C# LDM finds that a proposal merits consideration by the broader team, they can Champion it, which means that they will bring it to the C# Language Design Meeting. Proposals are always discussed in linked discussions, not in the champion issue. We didn't always follow this policy, so many champion issues will have discussion on them; we now lock issues to prevent new discussion from occurring on them. Each champion issue will have a discussion link on it.

Design Process

Proposals evolve as a result of decisions in Language Design Meetings, which are informed by discussions, experiments, and offline design work.

In many cases it will be necessary to implement and share a prototype of a feature in order to land on the right design, and ultimately decide whether to adopt the feature. Prototypes help discover both implementation and usability issues of a feature. A prototype should be implemented in a fork of the Roslyn repo and meet the following bar:

  • Parsing (if applicable) should be resilient to experimentation: typing should not cause crashes.
  • Include minimal tests demonstrating the feature at work end-to-end.
  • Include minimal IDE support (keyword coloring, formatting, completion).

Once approved, a feature should be fully implemented in Roslyn, and fully specified in the language specification, whereupon the proposal is moved into the appropriate folder for a completed feature, e.g. C# 7.1 proposals.

DISCLAIMER: An active proposal is under active consideration for inclusion into a future version of the C# programming language but is not in any way guaranteed to ultimately be included in the next or any version of the language. A proposal may be postponed or rejected at any time during any phase of the above process based on feedback from the design team, community, code reviewers, or testing.

Milestones

We have a few different milestones for issues on the repo:

  • Working Set is the set of championed proposals that are currently being actively worked on. Not everything in this milestone will make the next version of C#, but it will get design time during the upcoming release.
  • Backlog is the set of championed proposals that have been triaged, but are not being actively worked on. While discussion and ideas from the community are welcomed on these proposals, the cost of the design work and implementation review on these features are too high for us to consider community implementation until we are ready for it.
  • Any Time is the set of championed proposals that have been triaged, but are not being actively worked on and are open to community implementation. Issues in this can be in one of 2 states: needs approved specification, and needs implementation. Those that need a specification still need to be presented during LDM for approval of the spec, but we are willing to take the time to do so at our earliest convenience.
  • Likely Never is the set of proposals that the LDM has rejected from the language. Without strong need or community feedback, these proposals will not be considered in the future.
  • Numbered milestones are the set of features that have been implemented for that particular language version. For closed milestones, these are the set of things that shipped with that release. For open milestones, features can be potentially pulled later if we discover compatibility or other issues as we near release.

Language Design Meetings

Language Design Meetings (LDMs) are held by the LDT and occasional invited guests, and are documented in Design Meeting Notes in the meetings folder, organized in folders by year. The lifetime of a design meeting note is described in meetings/README.md. LDMs are where decisions about future C# versions are made, including which proposals to work on, how to evolve the proposals, and whether and when to adopt them.

Language Specification

The current ECMA-334 specification can be found in markdown form on the C# Language Standard repository.

Implementation

The reference implementation of the C# language can be found in the Roslyn repository. This repository also tracks the implementation status for language features. Until recently, that was also where language design artifacts were tracked. Please allow a little time as we move over active proposals.

Overview (`meetings/README.md`)

C# Language Design Meetings

C# Language Design Meetings (LDM for short) are meetings by the C# Language Design Team and invited guests to investigate, design and ultimately decide on features to enter the C# language. It is a creative meeting, where active design work happens, not just a decision body.

Each C# language design meeting is represented by a meeting notes file in this folder.

Purpose of the meetings notes

Meeting notes serve the triple purposes of

  • recording decisions so they can be acted upon
  • communicating our design thinking to the community so we can get feedback on them
  • recording rationale so we can return later and see why we did things the way we did

All have proven extremely useful over time.

Life cycle of meeting notes

  • If upcoming design meetings have a specific agenda, for instance to suit the schedule of visitors, there may be a meeting notes file with that agenda even before the meeting happens.
  • Otherwise the meeting agendas are determined just-in-time based on urgency, arrival of new information or ideas, challenges found in design and implementation, and so on.
  • After the meeting, notes will be saved directly here.
  • Usually they will be raw notes in need of subsequent cleaning up. If that's the case, they will be clearly marked as such, and a Meeting notes work item will track the task of cleaning up the notes.
  • When the notes are finalized, a notification is posted as a discussion issue to encourage discussion of the decisions made. While quick comments are welcome directly on that issue, it is recommended to open a separate issue for deeper or more topic-specific discussions.
  • If the notes impact current proposals, proposal work items will track updating those proposals, assigned to their champions.
  • When updated, the proposals link back to the meetings where the proposal was discussed.

Style of design notes

The notes serve as the collective voice of the LDM. They cover not just the decisions but the discussion, options and rationale, so that others can follow along in the discussion and provide input to it, and so that we don't forget them for later.

However, the notes are not minutes! They never state who said what in the meeting. They will occasionally mention people by name if they are visiting, provided input, should be collaborated with, etc. But the notes aim to represent the shared thinking of the room. If there's disagreement, they will report that, but they won't focus on who wants what.

This approach is intended to reinforce that the LDMs are a safe space, and a collaborative, creative effort. It is not a negotiation between representatives of different interests. It is not a voting body, and it is not a venue for posturing. Everybody cooperates towards the same end: creating the best language for today's and tomorrow's C# developers.

When there are external inputs to the notes (such as open questions, presentations, supplemental documents, etc), they will be committed to this repository and linked to from the notes, with a specific commit, to ensure that any future reorganization will keep the notes working.

Working groups

Working groups who choose to do so will keep meeting notes in a subfolder of the working-groups folder belonging to that group. These notes will be anonymized, like LDM notes, but are likely to be much rougher than dedicated LDM notes. We will not create dedicated discussions when posting these working group notes. Users that want to comment on them can either comment on the issue for the group or create a discussion, as they choose. Working groups will each have a leader, and that leader will be responsible for coordinating with the broader LDM on when things need to be brought back to the full group.

Overview (`proposals/README.md`)

C# Language Proposals

Language proposals are living documents describing the current thinking about a given language feature.

Proposals can be either active, inactive, rejected or done. Active proposals are stored directly in the proposals folder, inactive and rejected proposals are stored in the inactive and rejected subfolders, and done proposals are archived in a folder corresponding to the language version they are part of.

Lifetime of a proposal

A proposal starts its life when the language design team decides that it might make a good addition to the language some day. Typically it will start out being active, but if we want to capture an idea without wanting to work on it right now, a proposal can also start out in the inactive subfolder. Proposals may even start out directly in the rejected state, if we want to make a record of something we don't intend to do. For instance, if a popular and recurring request is not possible to implement, we can capture that as a rejected proposal.

The proposal may start out as an idea in a discussion issue, or it may come from discussions in the Language Design Meeting, or arrive from many other fronts. The main thing is that the design team feels that it should be done, and that there's someone who is willing to write it up. Typically a member of the Language Design Team will assign themselves as a champion for the feature, tracked by a Champion issue. The champion is responsible for moving the proposal through the design process.

A proposal is active if it is moving forward through design and implementation toward an upcoming release. Once it is completely done, i.e. an implementation has been merged into a release and the feature has been specified, it is moved into a subdirectory corresponding to its release.

If a feature turns out not to be likely to make it into the language at all, e.g. because it proves unfeasible, does not seem to add enough value or just isn't right for the language, it will be rejected. If a feature has reasonable promise but is not currently being prioritized to work on, it may be declared inactive to avoid cluttering the main folder. It is perfectly fine for work to happen on inactive or rejected proposals, and for them to be resurrected later. The categories are there to reflect current design intent.

Nature of a proposal

A proposal should follow the proposal template. A good proposal should:

  • Fit with the general spirit and aesthetic of the language.
  • Not introduce subtly alternate syntax for existing features.
  • Add a lot of value for a clear set of users.
  • Not add significantly to the complexity of the language, especially for new users.

Discussion of proposals

Feedback and discussion happens in discussion issues. When a new proposal is added to the proposals folder, it should be announced in a discussion issue by the champion or proposal author.

Overview (`spec/README.md`)

This content has moved to the dotnet/csharpstandard repository.

The full table of contents is in the standard folder.

To view the text of the Microsoft spec before merging with the ECMA text, checkout the ms-spec-text tag in this repository.

Overview (`meetings/2013/README.md`)

C# Language Design Notes for 2013

Overview of meetings and agendas for 2013

Oct 7, 2013

C# Language Design Notes for Oct 7, 2013

  1. Invariant meaning of names <*scrap the rule*>
  2. Type testing expression <*can’t decide on good syntax*>
  3. Local functions <*not enough scenarios*>
  4. nameof operator <*yes*>

C# Language Design Notes for Oct 21, 2013

  1. Primary Constructors <*fleshed out a few more details*>
  2. Lightweight Dynamic <*we examined a much simpler approach*>

Nov 4, 2013

C# Language Design Notes for Nov 4, 2013

  1. Initialized and getter-only auto-properties <*details decided*>
  2. Expression-bodied function members <*details decided*>
  3. Lightweight dynamic <*member access model and syntax discussed*>

Dec 16, 2013

C# Language Design Notes for Dec 16, 2013

  1. Declaration expressions <*reaffirmed scope rules, clarified variable introduction*>
  2. Semicolon operator <*reaffirmed enclosing parentheses*>
  3. Lightweight dynamic member access <*decided on a syntax*>

Overview (`meetings/2014/README.md`)

C# Language Design Notes for 2014

Overview of meetings and agendas for 2014

Jan 6, 2014

C# Language Design Notes for Jan 6, 2014

  1. Syntactic ambiguities with declaration expressions <_a solution adopted_>
  2. Scopes for declaration expressions <_more refinement added to rules_>

Feb 3, 2014

C# Language Design Notes for Feb 3, 2014

  1. Capture of primary constructor parameters <_only when explicitly asked for with new syntax_>
  2. Grammar around indexed names <_details settled_>
  3. Null-propagating operator details <_allow indexing, bail with unconstrained generics_>

Feb 10, 2014

C# Language Design Notes for Feb 10, 2014

  1. Design of using static <_design adopted_>
  2. Initializers in structs <_allow in certain situations_>
  3. Null-propagation and unconstrained generics <_keep current design_>

Apr 21, 2014

C# Language Design Notes for Apr 21, 2014

  1. Indexed members <_lukewarm response, feature withdrawn_>
  2. Initializer scope <_new scope solves all kinds of problems with initialization_>
  3. Primary constructor bodies <_added syntax for a primary constructor body_>
  4. Assignment to getter-only auto-properties from constructors <_added_>
  5. Separate accessibility for type and primary constructor <_not worthy of new syntax_>
  6. Separate doc comments for field parameters and fields <_not worthy of new syntax_>
  7. Left associative vs short circuiting null propagation <_short circuiting_>

May 7, 2014

C# Language Design Notes for May 7, 2014

  1. protected and internal <_feature cut – not worth the confusion_>
  2. Field parameters in primary constructors <_feature cut – we want to keep the design space open_>
  3. Property declarations in primary constructors <_interesting but not now_>
  4. Typeswitch <_Not now – more likely as part of a future more general matching feature_>

May 21, 2014

C# Language Design Notes for May 21, 2014

  1. Limit the nameof feature? <_keep current design_>
  2. Extend params IEnumerable? <_keep current design_>
  3. String interpolation <_design nailed down_>

Jul 9, 2014

C# Language Design Notes for Jul 9, 2014

  1. Detailed design of nameof <_details settled_>
  2. Design of #pragma warning extensions <_allow identifiers_>

Aug 27, 2014

C# Language Design Notes for Aug 27, 2014

  1. Allowing parameterless constructors in structs <_allow, but some unresolved details_>
  2. Definite assignment for imported structs <_revert to Dev12 behavior_>

Sep 3, 2014

C# Language Design Notes for Sep 3, 2014

  1. Removing “spill out” from declaration expressions in simple statements <_yes, remove_>
  2. Same name declared in subsequent else-if’s <_condition decls out of scope in else-branch_>
  3. Add semicolon expressions <_not in this version_>
  4. Make variables in declaration expressions readonly <_no_>

Oct 1, 2014

C# Language Design Notes for Oct 1, 2014

  1. Assignment to readonly autoprops in constructors (we fleshed out details)
  2. A new compiler warning to prevent outsiders from implementing your interface? (no, leave this to analyzers)

Oct 15, 2014

C# Language Design Notes for Oct 15, 2014

  1. nameof operator: spec v5
  2. String Interpolation for C#

Overview (`meetings/2015/README.md`)

C# Language Design Notes for 2015

Overview of meetings and agendas for 2015

Jan 21, 2015

C# Design Meeting Notes for Jan 21, 2015

This is the first design meeting for the version of C# coming after C# 6. We shall colloquially refer to it as C# 7. The meeting focused on setting the stage for the design process and homing in on major themes and features.

  1. Design process
  2. Themes
  3. Features

Jan 28, 2015

C# Design Meeting Notes for Jan 28, 2015

  1. Immutable types
  2. Safe fixed-size buffers
  3. Pattern matching
  4. Records

Feb 4, 2015

C# Design Meeting Notes for Feb 4, 2015

  1. Internal Implementation Only (C# 6 investigation)
  2. Tuples, records and deconstruction
  3. Classes with value semantics

Feb 11, 2015

C# Design Meeting Notes for Feb 11, 2015

  1. Destructible types <*we recognize the problem but do not think this is quite the right solution for C#*>
  2. Tuples <*we like the proposal, but there are several things to iron out*>

Mar 4, 2015

C# Design Meeting Notes for Mar 4, 2015

  1. InternalImplementationOnly attribute <*no*>
  2. Should var x = nameof(x) work? <*no*>
  3. Record types with serialization, data binding, etc. <*keep thinking*>
  4. "If I had a billion dollars...": nullability <*daunting but worth pursuing*>

Mar 10 and 17, 2015

C# Design Meeting Notes for Mar 10 and 17, 2015

These two meetings looked exclusively at nullable/non-nullable reference types. I've written them up together to add more of the clarity of insight we had when the meetings were over, rather than represent the circuitous path we took to get there.

  1. Nullable and non-nullable reference types
  2. Opt-in diagnostics
  3. Representation
  4. Potentially useful rules
  5. Safely dereferencing nullable reference types
  6. Generating null checks

Mar 18, 2015

C# Design Meeting Notes for Mar 18, 2015

In this meeting we looked over the top C# language feature requests on UserVoice to see which ones are reasonable to push on further in C# 7.

  1. Non-nullable reference types (already working on them)
  2. Non-nullary constructor constraints (require CLR support)
  3. Support for INotifyPropertyChanged (too specific; metaprogramming?)
  4. GPU and DirectX support (mostly library work; numeric constraints?)
  5. Extension properties and static members (certainly interesting)
  6. More code analysis (this is what Roslyn analyzers are for)
  7. Extension methods in instance members (fair request, small)
  8. XML comments (Not a language request)
  9. Unmanaged constraint (requires CLR support)
  10. Compilable strings (this is what nameof is for)
  11. Multiple returns (working on it, via tuples)
  12. ISupportInitialize (too specific; hooks on object initializers?)
  13. ToNullable (potentially part of nullability support)
  14. Statement lambdas in expression trees (fair request, big feature!)
  15. Language support for Lists, Dictionaries and Tuples (Fair; already working on tuples)

A number of these are already on the table.

Mar 24, 2015

C# Design Meeting Notes for Mar 24, 2015

In this meeting we went through a number of the performance and reliability features we have discussed, to get a better reading on which ones have legs. They end up falling roughly into three categories:

  • Green: interesting - let's keep looking
  • Yellow: there's something there but this is not it
  • Red: probably not

As follows:

  1. ref returns and locals <*green*> (#118)
  2. readonly locals and parameters <*green*> (#115)
  3. Method contracts <*green*> (#119)
  4. Does not return <*green*> (#1226)
  5. Slicing <*green*> (#120)
  6. Lambda capture lists <*yellow - maybe attributes on lambdas*> (#117)
  7. Immutable types <*yellow in current form, but warrants more discussion*> (#159)
  8. Destructible types <*yellow - fixing deterministic disposal is interesting*> (#161)
  9. Move <*red*> (#160)
  10. Exception contracts <*red*>
  11. Static delegates <*red*>
  12. Safe fixed-size buffers in structs <*red*> (#126)

Some of these were discussed again, some we just reiterated our position.

Mar 25, 2015 (Design Review)

C# Language Design Review, Mar 25, 2015
Additional Notes

We've recently changed gears a little on the C# design team. In order to keep a high design velocity, part of the design team meets one or two times each week to do detailed design work. Roughly monthly the full design team gets together to review and discuss the direction. This was the first such review.

  1. Overall direction
  2. Nullability features
  3. Performance and reliability features
  4. Tuples
  5. Records
  6. Pattern matching

Apr 1 and Apr 8, 2015

C# Design Meeting Notes for Apr 1 and Apr 8, 2015

Matt Warren wrote a Roslyn analyzer as a low cost way to experiment with nullability semantics. In these two meetings we looked at evolving versions of this analyzer, and what they imply for language design.

The analyzer is here.

Apr 14, 2015

C# Design Meeting Notes for Apr 14, 2015

Bart De Smet visited from the Bing team to discuss their use of Expression Trees, and in particular the consequences of their current shortcomings.

The Expression Tree API today is not able to represent all language features, and the language supports lambda conversions even for a smaller subset than that.

Apr 15, 2015

C# Design Meeting Notes for Apr 15, 2015

In this meeting we looked at nullability and generics. So far we have more challenges than solutions, and while we visited some of them, we don't have an overall approach worked out yet.

  1. Unconstrained generics
  2. Overriding annotations
  3. FirstOrDefault
  4. TryGet

Apr 22, 2015 (Design Review)

C# Language Design Review, Apr 22, 2015

  1. Expression tree extension
  2. Nullable reference types
  3. Facilitating wire formats
  4. Bucketing

May 20, 2015

C# Design Meeting Notes for May 20, 2015

  1. We discussed whether and how to add local functions to C#, with the aim of prototyping the feature in the near future.

May 25, 2015

C# Design Meeting Notes for May 25, 2015

Today we went through a bunch of the proposals on GitHub and triaged them for our list of features.

Jul 1, 2015

C# Design Meeting Notes for Jul 1, 2015

We are gearing up to prototype the tuple feature, and put some stakes in the ground for its initial design. This doesn't mean that the final design will be this way, and some choices are arbitrary. We merely want to get to where a prototype can be shared with a broader group of C# users, so that we can gather feedback and learn from it.

Jul 7, 2015

C# Design Meeting Notes for Jul 7, 2015

With Eric Lippert from Coverity as an honored guest, we looked further at the nullability feature.

  1. Adding new warnings
  2. Generics and nullability

Aug 18, 2015

C# Design Meeting Notes for Aug 18, 2015

A summary of the design we (roughly) landed on in #5031 was put out on GitHub as #5032, and this meeting further discussed it.

  1. Array creation
  2. Null checking operator
  3. Generics

Sep 1, 2015

C# Design Meeting Notes for Sep 1, 2015

The meeting focused on design decisions for prototypes. There's no commitment for these decisions to stick through to a final feature; on the contrary the prototypes are being made in order to learn new things and improve the design.

  1. ref returns and ref locals
  2. pattern matching

Sep 2, 2015

C# Design Meeting Notes for Sep 2, 2015

  1. Extending nameof
  2. What do branches mean
  3. Supersedes

Sep 8, 2015

C# Design Meeting Notes for Sep 8, 2015

  1. Check-in on some of our desirable features to see if we have further thoughts
  2. Start brainstorming on async streams

Oct 7, 2015 (Design Review)

Preparatory Notes on Records and Pattern Matching for Oct 7, 2015 Design Review

Nov 2, 2015 (Design Demo)

Outline of demo at the Nov 2, 2015 MVP summit

Overview (`meetings/2016/README.md`)

C# Language Design Notes for 2016

Overview of meetings and agendas for 2016

Feb 29, 2016

C# Language Design Notes for Feb 29, 2016

Catch up edition (deconstruction and immutable object creation)

Over the past couple of months various design activities took place that weren't documented in design notes. This a summary of the state of design regarding positional deconstruction, with-expressions and object initializers for immutable types.

Apr 6, 2016

C# Language Design Notes for Apr 6, 2016

We settled several open design questions concerning tuples and pattern matching.

Apr 12-22, 2016

C# Language Design Notes for Apr 12-22, 2016

These notes summarize discussions across a series of design meetings in April on several topics related to tuples and patterns:

  • Tuple syntax for non-tuple types
  • Tuple deconstruction
  • Tuple conversions
  • Deconstruction and patterns
  • Out vars and their scope

May 3-4, 2016

C# Language Design Notes for May 3-4, 2016

This pair of meetings further explored the space around tuple syntax, pattern matching and deconstruction.

  1. Deconstructors - how to specify them
  2. Switch conversions - how to deal with them
  3. Tuple conversions - how to do them
  4. Tuple-like types - how to construct them

May 10, 2016

C# Language Design Notes for May 10, 2016

In this meeting we took a look at the possibility of adding new kinds of extension members, beyond extension methods.

Jul 12, 2016

C# Language Design Notes for Jul 12, 2016

Several design details pertaining to tuples and deconstruction resolved.

Jul 13, 2016

C# Language Design Notes for Jul 13, 2016

We resolved a number of questions related to tuples and deconstruction, and one around equality of floating point values in pattern matching.

Jul 15, 2016

C# Design Language Notes for Jul 15, 2016

In this meeting we took a look at what the scope rules should be for variables introduced by patterns and out vars.

Aug 24, 2016

C# Design Language Notes for Aug 24, 2016

After a meeting-free period of implementation work on C# 7.0, we had a few issues come up for resolution.

  1. What does it take to be task-like?
  2. Scope of expression variables in initializers

Sep 6, 2016

C# Language Design Notes for Sep 6, 2016

  1. How do we select Deconstruct methods?

Oct 18, 2016

C# Language Design Meeting Notes, Oct 18, 2016

  1. Wildcard syntax
  2. Design "room" between tuples and patterns
  3. Local functions
  4. Digit separators
  5. Throw expressions
  6. Tuple name mismatch warnings
  7. Tuple types in new expressions

Oct 25-26, 2016

C# Language Design Meeting Notes, Oct 25-26, 2016

  1. Declaration expressions as a generalizing concept
  2. Irrefutable patterns and definite assignment
  3. Allowing tuple-returning deconstructors
  4. Avoiding accidental reuse of out variables
  5. Allowing underbar as wildcard character

Nov 1, 2016

C# Language Design Meeting Notes, Nov 1, 2016

  1. Abstracting over memory with Span<T>

Nov 15, 2016

C# Language Design Meeting Notes, Nov 15, 2016

  1. Tuple name warnings
  2. "Discards"

Nov 16, 2016

C# Language Design Meeting Notes, Nov 16, 2016

  1. Nullable reference types

Nov 30, 2016

C# Language Design Meeting Notes, Nov 30, 2016

  1. Scope of while condition expression variables
  2. Mixed deconstruction
  3. Unused expression variables
  4. Declarations in embedded statements
  5. Not-null pattern

Dec 7 and 14, 2016

C# Language Design Meeting Notes, Dec 7 and 14, 2016

  1. Expression variables in query expressions
  2. Irrefutable patterns and reachability
  3. Do-while loop scope

Overview (`meetings/2017/README.md`)

C# Language Design Notes for 2017

Overview of meetings and agendas for 2017

Jan 10, 2017

C# Language Design Notes for Jan 10, 2017

  1. Discriminated unions via "closed" types

Jan 11, 2017

C# Language Design Notes for Jan 11, 2017

  1. Language aspects of compiler intrinsics

Jan 17, 2017

C# Language Design Notes for Jan 17, 2017

  1. Constant pattern semantics: which equality exactly?
  2. Extension methods on tuples: should tuple conversions apply?

Jan 18, 2017

C# Language Design Notes for Jan 18, 2017

  1. Async streams (visit from Oren Novotny)

Feb 21, 2017

C# Language Design Notes for Feb 21, 2017

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.

  1. Implicit interface implementation in Visual Basic (VB 16)
  2. Delegate and enum constraints (C# X.X)
  3. Generic attributes (C# X.0 if even practical)
  4. Replace/original (C# X.0 if and when relevant)
  5. Bestest betterness (C# 7.X)
  6. Null-coalescing assignments and awaits (C# 7.X)
  7. Deconstruction in from and let clauses (C# 7.X)
  8. Target-typed new expressions (C# 7.X)
  9. Mixing fresh and existing variables in deconstruction (C# 7.1)
  10. Implementing == and != on tuple types (C# 7.X)
  11. Declarations in embedded statements (No)
  12. Field targeted attributes on auto-properties (C# 7.1)

Feb 22, 2017

C# Language Design Notes for Feb 22, 2017

We went over the proposal for ref readonly: Champion "Readonly ref".

Feb 28, 2017

C# Language Design Notes for Feb 28, 2017

  1. Conditional operator over refs (Yes, but no decision on syntax)
  2. Async Main (Allow Task-returning Main methods)

Mar 1, 2017

C# Language Design Notes for Mar 1, 2017

  1. Shapes and extensions (exploration)
  2. Conditional refs (original design adopted)

Mar 7, 2017

C# Language Design Notes for Mar 7, 2017

We continued to flesh out the designs for features currently considered for C# 7.1.

  1. Default expressions (design adopted)
  2. Field target on auto-properties (yes)
  3. private protected (yes, if things work as expected)

Mar 8, 2017

C# Language Design Notes for Mar 8, 2017

We looked at default interface member implementations.

  1. Xamarin interop scenario
  2. Proposal
  3. Inheritance from interface to class
  4. Overriding and base calls
  5. The diamond problem
  6. Binary compatibility
  7. Other semantic challenges

Mar 15, 2017

C# Language Design Notes for Mar 8, 2017

Triage of championed features

  1. JSON literals
  2. Fixing of captured locals
  3. Allow shadowing of parameters
  4. Weak delegates
  5. Protocols/duck typing/concepts/type classes
  6. Zero and one element tuples
  7. Deconstruction in lambda parameters
  8. Private protected

Mar 21, 2017

C# Language Design Notes for Mar 21, 2017

Discussion of default interface member implementations, based on this guided tour.

  1. Concerns raised on GitHub and elsewhere
  2. Inheritance?
  3. Breaking name lookup on this
  4. Events
  5. Modifiers
  6. Methods
  7. Properties
  8. Overrides
  9. Reabstraction
  10. Most specific override
  11. Static non-virtual members
  12. Accessibility levels
  13. Existing programs

Mar 28, 2017

C# Language Design Notes for Mar 28, 2017

Design some remaining 7.1 features

  1. Fix pattern matching restriction with generics
  2. Better best common type

Mar 29, 2017

C# Language Design Notes for Mar 29, 2017

  1. Nullable scenarios
  2. Span<T> safety

Apr 5, 2017

C# Language Design Notes for Apr 5, 2017

  1. Non-virtual members in interfaces
  2. Inferred tuple element names
  3. Tuple element names in generic constraints

Apr 11, 2017

C# Language Design Notes for Apr 11, 2017

  1. Runtime behavior of ambiguous default implementation

Apr 18, 2017

C# Language Design Notes for Apr 18, 2017

  1. Default implementations for event accessors in interfaces
  2. Reabstraction in a class of default-implemented member
  3. sealed override with default implementations
  4. Use of sealed keyword for non-virtual interface members
  5. Implementing inaccessible interface members
  6. Implicitly implementing non-public interface members
  7. Not quite implementing a member
  8. asynchronous Main

Apr 19, 2017

C# Language Design Notes for Apr 19, 2017

  1. Improved best common type
  2. Diamonds with classes
  3. Structs and default implementations
  4. Base invocation

May 16, 2017

C# Language Design Notes for May 16, 2017

  1. Triage C# 7.1 features that didn't make it
  2. Look at C# 7.2 features
  3. GitHub procedure around new design notes and proposals
  4. Triage of championed features

May 17, 2017

C# Language Design Notes for May 17, 2017

More questions about default interface member implementations

  1. Conflicting override of default implementations
  2. Can the Main entry point method be in an interface?
  3. Static constructors in interfaces?
  4. Virtual properties with private accessors
  5. Does an override introduce a member?
  6. Parameter names

May 26, 2017

C# Language Design Notes for May 26, 2017

  1. Native ints

May 31, 2017

C# Language Design Notes for May 31, 2017

  1. Default interface members: overriding or implementing?
  2. Downlevel poisoning of ref readonly in signatures
  3. Extension methods with ref this and generics
  4. Default in operators

Jun 13, 2017

C# Language Design Notes for Jun 13, 2017

  1. Native-size ints
  2. Native-size floats

Jun 14, 2017

C# Language Design Notes for Jun 14, 2017

Several issues related to default implementations of interface members

  1. Virtual properties with private accessors
  2. Requiring interfaces to have a most specific implementation of all members
  3. Member declaration syntax revisited
  4. Base calls

Jun 27, 2017

C# Language Design Notes for Jun 27, 2017

  1. User-defined operators in interfaces
  2. return/break/continue as expressions

Jun 28, 2017

C# Language Design Notes for Jun 28, 2017

  1. Tuple name round-tripping between C# 6.0 and C# 7.0
  2. Deconstruction without ValueTuple
  3. Non-trailing named arguments

Jul 5, 2017

C# Language Design Notes for Jul 5, 2017

Triage of features in the C# 7.2 milestone. They don't all fit: which should be dropped, which should be kept, and which should be pushed out?

  1. Static delegates (8.0)
  2. Native int and IntPtr operators (7.X)
  3. Field target (anytime)
  4. Utf8 strings (8.0)
  5. Slicing (7.X)
  6. Blittable (7.2)
  7. Ref structs (7.2)
  8. Ref readonly (7.2)
  9. Conditional ref (7.2)
  10. Ref extensions on structs (7.2)
  11. Readonly locals and params (X.X)
  12. ref structs in tuples (don't)
  13. Overload resolution tie breakers with long tuples (use underlying generics)

Jul 26, 2017

C# Language Design Notes for Jul 24 and 26, 2017

We started putting a series of stakes in the ground for nullable reference types, based on the evolving strawman proposal here. We're doing our first implementation of the feature based on this, and can then refine as we learn things from usage.

  1. Goals
  2. Nullable reference types
  3. Rarely-null members

Aug 7, 2017

C# Language Design Notes for Aug 7, 2017

We continued refining the nullable reference types feature set with the aim of producing a public prototype for experimentation and learning.

  1. Warnings
  2. Local variables revisited
  3. Opt-in mechanisms

Aug 9, 2017

C# Language Design Notes for Aug 9, 2017

We discussed how nullable reference types should work in a number of different situations.

  1. Default expressions
  2. Array creation
  3. Struct fields
  4. Unconstrained type parameters

Aug 14, 2017

C# Language Design Notes for Aug 14, 2017

We looked at the interaction between generics and nullable reference types

  1. Unconstrained type parameters
  2. Nullable constraints
  3. Conversions between constructed types

Aug 16, 2017

C# Language Design Notes for Aug 16, 2017

  1. The null-forgiving operator

Aug 23, 2017

C# Language Design Notes for Aug 23, 2017

We discussed various aspects of nullable reference types

  1. How does flow analysis silence the warning
  2. Problems with dotted names
  3. Type inference
  4. Structs with fields of non-nullable type

Oct 4, 2017

C# Language Design Review, Oct 4, 2017

We looked at nullable reference types with the reviewers, Anders Hejlsberg and Kevin Pilch.

  1. Overall philosophy
  2. Switches
  3. Libraries
  4. Dotted names
  5. Type narrowing
  6. The dammit operator
  7. Array covariance
  8. Null warnings
  9. Special methods
  10. Conclusion

Oct 11, 2017

C# Language Design Notes for Oct 11, 2017

We looked at the Oct 4 design review feedback for nullable reference types, and considered how to react to it.

  1. Philosophy
  2. Switches
  3. Dotted names
  4. Type narrowing
  5. Dammit operator type narrowing
  6. Dammit operator stickiness
  7. Array covariance
  8. Null warnings

Nov 8, 2017

C# Language Design Notes for Nov 8, 2017

We went over the status of the prototype for nullable reference types, to address outstanding questions and make any last minute calls before release.

  1. Constructors
  2. Dotted names
  3. Default expressions
  4. Should we track null state for nonnullable ref types?
  5. Inferred types for method type inference
  6. Inferred nullability in hover tips
  7. Smaller things not yet done
  8. Unconstrained generics
  9. Other issues

Nov 27, 2017

C# Language Design Notes for Nov 27, 2017

We went over the feedback on the nullable reference types prototype, and discussed how to address the top issues that people had found using the feature on their own source code.

  1. Interacting with existing, unannotated APIs
  2. Accommodating alternative initialization patterns
  3. Tracking nullable value types
  4. Tracking dotted names
  5. Special methods
  6. Filtering out nulls

Overview (`meetings/2018/README.md`)

C# Language Design Notes for 2018

Overview of meetings and agendas for 2018

Jan 3, 2018

C# Language Design Notes for Jan 3, 2018

  1. Scoping of expression variables in constructor initializer
  2. Scoping of expression variables in field initializer
  3. Scoping of expression variables in query clauses
  4. Caller argument expression attribute
  5. Other caller attributes
  6. New constraints

Jan 10, 2018

C# Language Design Notes for Jan 10, 2018

  1. Ranges and endpoint types

Jan 18, 2018

C# Language Design Notes for Jan 18, 2018

We discussed the range operator in C# and the underlying types for it.

  1. Scope of the feature
  2. Range types
  3. Type name
  4. Open-ended ranges
  5. Empty ranges
  6. Enumerability
  7. Language questions

Jan 22, 2018

C# Language Design Notes for Jan 22, 2018

We continued to discuss the range operator in C# and the underlying types for it.

  1. Inclusive or exclusive?
  2. Natural type of range expressions
  3. Start/length notation

Jan 24, 2018

C# Language Design Notes for Jan 24, 2018

  1. Ref reassignment
  2. New constraints
  3. Target typed stackalloc initializers
  4. Deconstruct as ref extension method

July 9, 2018

C# Language Design Notes for July 9, 2018

  1. using var feature
    1. Overview
    2. Tuple deconstruction grammar form
    3. using expr; grammar form
    4. Flow control safety
  2. Pattern-based Dispose in the using statement
  3. Relax Multiline interpolated string syntax ($@)

July 11, 2018

C# Language Design Notes for July 11, 2018

  1. Controlling nullable reference types with feature flags
  2. Interaction with NonNullTypesAttribute
  3. Feature flag and 'warning waves'
  4. How 'oblivious' null types interact with generics
  5. Nullable and interface generic constraints

July 16, 2018

C# Language Design Notes for July 16, 2018

  1. Null-coalescing assignment
    1. User-defined operators
    2. Unconstrained type parameters
    3. Throw expression the right-hand side
  2. Nullable await
  3. Nullable pointer access
  4. Non-nullable reference types feature flag follow-up

August 20, 2018

C# Language Design Notes for August 20, 2018

  1. Remaining questions on suppression operator (and possibly cast)
  2. Does a dereference update the null-state?
  3. Null contract attributes
  4. Expanding the feature
  5. Is T? where T : class? allowed or meaningful?
  6. Typing judgments containing oblivious types
  7. Unconstrained T in List<T> then FirstOrDefault(). What attribute to annotate FirstOrDefault?

August 22, 2018

C# Language Design Notes for August 22, 2018

  1. Target-typed new
  2. Clarification on constraints with nullable reference types enabled

September 5, 2018

C# Language Design Notes for September 5, 2018

  1. Index operator: is it a unary operator?
  2. Compiler intrinsics

September 10, 2018

C# Language Design Notes for September 10, 2018

  1. Nullability of constraints in inheritance and interface implementation
  2. Static local functions

Sep 19, 2018

C# Language Design Notes for September 19, 2018

Triage:

  1. XML doc comment features
  2. New foreach pattern using Length and indexer
  3. Object initializers for readonly members
  4. readonly struct methods
  5. params Span<T>
  6. Nullable reference type features on Nullable<T>

Sep 24, 2018

C# Language Design Notes for September 24, 2018

Combined C#/F# LDM

  1. What new C# features are going to require work to get F# support?
  2. How can the design of C# features play well with the broader .NET environment?

Sep 26, 2018

C# Language Design Notes for September 26, 2018

  1. Warning waves

Oct 1, 2018

C# Language Design Notes for Oct 1, 2018

  1. Nullable type inference
  2. Type parameters and nullability context

Oct 3, 2018

C# Language Design Notes for Oct 3, 2018

  1. How is the nullable context expressed?
  2. Async streams - which interface shape?

Oct 10, 2018

C# Language Design Notes for Oct 10, 2018

  1. Pattern matching open questions

Oct 15, 2018

C# Language Design Notes for Oct 15, 2018

  1. Readonly methods in structs
  2. Intrinsics update with function pointers
  3. Finalize syntax for async-streams. Per last notes, the current tentative syntax is foreach await (var x in ...) ....

Oct 17, 2018

C# Language Design Notes for Oct 17, 2018

  1. Open issues with default interface methods
  2. target typed new with default constructors on structs

Oct 22, 2018

C# Language Design Notes for Oct 22, 2018

Discussion of records proposals:

  1. The existing old one
  2. The data classes proposal

Oct 24, 2018

Oct 29, 2018

C# Language Design Notes for Oct 29, 2018

Oct 31, 2018

C# Language Design Notes for Oct 31, 2018

  • Design review

Nov 5, 2018

C# Language Design Notes for Nov 5, 2018

  1. Where can #nullable go?
  2. Open issues with pattern matching

Nov 14, 2018

C# Language Design Notes for Nov 14, 2018

  1. Base call syntax for default interface implementations
  2. Switch exhaustiveness and null

Nov 28, 2018

C# Language Design Notes for Nov 28, 2018

  1. Are nullable annotations part of array specifiers?
  2. Cancellation of async-streams

Dec 3, 2018

C# Language Design Notes for Dec 3, 2018

  1. using declaration open issues
  2. Return type of Range indexer on array and FX types

Dec 5, 2018

C# Language Design Notes for Dec 5, 2018

  • Tracked nullable states, their correspondence to source and the rules they follow in flow analysis

Dec 12, 2018

C# Language Design Notes for Dec 12, 2018

  • Async-streams misc. questions
  • Compat issue with Dispose pattern in foreach

Upcoming meetings

Dec 17, 2018

Recurring topics

  • Triage championed features
  • Triage milestones
  • Design review

Overview (`meetings/2019/README.md`)

C# Language Design Notes for 2019

Overview of meetings and agendas for 2019

Dec 18, 2019

C# Language Design Notes for Dec 18, 2019

  1. Pure null checks
  2. var?

Dec 16, 2019

C# Language Design Notes for Dec 16, 2019

  1. Switch Expression as a Statement Expression (continued) (Neal, Fred)
  2. Triage

Dec 11, 2019

C# Language Design Notes for Dec 11, 2019

  1. Design review feedback

Dec 9, 2019

(not yet transcribed)

Dec 4, 2019 (Design Review)

(not yet transcribed)

Nov 25, 2019

C# Language Design Notes for Nov 25, 2019

  1. Revisit unconstrained T? (Mads, Jared)

Nov 20, 2019

(not yet transcribed)

Nov 18, 2019

C# Language Design Notes for Nov. 18, 2019

  1. Proposed changes for pattern-matching

Nov 13, 2019

C# Language Design Notes for Nov 13, 2019

  1. Discriminated unions
  2. Improve analysis of [MaybeNull]T values

Nov 11, 2019

C# Language Design Notes for Nov 11, 2019

  1. Confirm removal of warning calling a method that returns [MaybeNull]T
  2. Allow interpolated string constant
  3. Enhancing the Common Type Specification
  4. Type pattern
  5. Simple name binding with target type

Oct 30, 2019

C# Language Design Notes for Oct 30, 2019

  1. Function Pointer syntax
  2. Enhancing the Common Type Specification

Oct 28, 2019

C# Language Design Notes for Oct 28, 2019

  1. Discard parameters in lambdas and other methods
  2. Enhancing the common type algorithm

Oct 23, 2019

C# Language Design Notes for Oct 23, 2019

  1. New primitive types

https://github.com/dotnet/csharplang/issues/435

Oct 21, 2019

C# Language Design Notes for Oct 21, 2019

  1. Records
  2. Init-only members
  3. Static lambdas

Sep 18, 2019

C# Language Design Notes for Sep 18, 2019

Triage:

  1. Proposals with complete designs:

  2. Target typing and best-common-type features:

Sep 16, 2019

C# Language Design Notes for Sep 16, 2019

  • Support for Utf8 strings
  • Triage remaining features out of the 8.X milestone

Sep 11, 2019

C# Language Design Notes for Sep 11, 2019

  1. Close https://github.com/dotnet/roslyn/issues/37313
  2. Triage new proposed 9.0 features
  3. Finish triaging away 8.X milestone

Sep 4, 2019

C# Language Design Notes for Sep 4, 2019

  1. AllowNull on properties https://github.com/dotnet/roslyn/issues/37313

Aug 28, 2019

C# Language Design Notes for Aug 28, 2019

  1. Triage language features

Jul 22, 2019

C# Language Design Notes for July 22, 2019

  1. Discuss the new records proposal

Jul 17, 2019

C# Language Design Notes for July 17, 2019

  1. Nullability of events

  2. Triage, see https://github.com/dotnet/csharplang/projects/4

Jul 10, 2019

C# Language Design Notes for July 10, 2019

  1. Empty switch statement
  2. [DoesNotReturn] attribute
  3. Revisiting the param! null-checking feature

May 15, 2019

C# Language Design Notes for May 15, 2019

  • Close on nullable attributes (Mads and Steve)

May 13, 2019

C# Language Design Notes for May 13, 2019

  • Close on desired rules for warning suppressions and #nullable interacting

Apr 29, 2019

C# Language Design Notes for Apr 29, 2019

  1. Default interface implementations and base() calls
  2. Async iterator cancellation
  3. Attributes on local functions

Apr 24, 2019

C# Language Design Notes for Apr 24, 2019

MaybeNull and related nullable reference type attributes

Apr 22, 2019

C# Language Design Notes for Apr 22, 2019

  1. Inferred nullable state from a finally block
  2. Implied constraint for a type parameter of a partial?
  3. Target-typed switch expression
  4. DefaultCancellationAttribute and overriding/hiding/interface implementation

Apr 15, 2019

C# Language Design Notes for Apr 15, 2019

  1. CancellationToken in iterators
  2. Implied nullable constraints in nullable disabled code
  3. Inheriting constraints in nullable disabled code
  4. Declarations with constraints declared in #nullable disabled code
  5. Result type of ??= expression
  6. Use annotation context to compute the annotations?
  7. Follow-up decisions for pattern-based Index/Range

Apr 3, 2019

C# Language Design Notes for Apr 3, 2019

  1. Ambiguous implementations/overrides with generic methods and NRTs
  2. NRT and dynamic

Apr 1, 2019

C# Language Design Notes for Apr 1, 2019

  1. Pattern-based Index/Range translation

  2. Default interface implementations: Is object.MemberwiseClone() accessible in
    an interface?

Mar 27, 2019

C# Language Design Notes for Mar 27, 2019

  1. Switch expression syntax

  2. Default interface implementations

    1. Reabstraction

    2. Explicit interface abstract overrides in classes

    3. object.MemberwiseClone()

    4. static int P {get; set} semantics

    5. partial on interface methods

  3. ? on unconstrained generic param T

Mar 25, 2019

C# Design Review Notes for Mar 25, 2019

We brought in the design review team to look at some of our recent and open decisions in C# LDM.

  1. Nullable reference types: shipping annotations
  2. Pattern-based indexing with Index and Range
  3. Cancellation tokens in async streams

Mar 19, 2019

C# Language Design Notes for March 19, 2019

We held a live LDM during the MVP summit with some Q&A about C# 8 and the future

Topics:

  1. Records
  2. "Extension interfaces"/roles
  3. Macros
  4. IAsyncEnumerable
  5. "Partially automatic" properties
  6. More integration with reactive extensions

Mar 13, 2019

C# Language Design Notes for March 13, 2019

  1. Interface "reabstraction" with default interface implementations
  2. Precedence of the switch expression
  3. or keyword in patterns
  4. "Pure" null tests and the switch statement/expression

Mar 6, 2019

C# Language Design Notes for March 6th, 2019

  1. Pure checks in the switch expression
  2. Nullable analysis of unreachable code
  3. Warnings about nullability on expressions with errors
  4. Handling of type parameters that cannot be annotated
  5. Should anonymous type fields have top-level nullability?
  6. Element-wise analysis of tuple conversions

Mar 4, 2019

C# Language Design Notes for March 4, 2019

  1. Nullable user studies
  2. Interpolated string and string.Format optimizations

Feb 27, 2019

C# Language Design Notes for Feb 27, 2019

  1. Allow ObsoleteAttribute on property accessors
  2. More Default Interface Member questions

Feb 25, 2019

C# Language Design Notes for Feb 25, 2019

Feb 20, 2019

C# Language Design Notes for Feb 20, 2019

Feb 13, 2019

C# Language Design Notes for Feb 13, 2019

Jan 23, 2019

C# Language Design Notes for Jan 23, 2019

Function pointers (Updated proposal)

Jan 16, 2019

C# Language Design Notes for Jan 16, 2019

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

Jan 14, 2019

C# Language Design Notes for Jan 14, 2019

Jan 9, 2019

C# Language Design Notes for Jan 9, 2019

  1. GetAsyncEnumerator signature
  2. Ambiguities in nullable array type syntax
  3. Recursive Patterns Open Language Issues https://github.com/dotnet/csharplang/issues/2095

Jan 7, 2019

C# Language Design Notes for Jan 7, 2019

Nullable:

  1. Variance in overriding/interface implementation
  2. Breaking change in parsing array specifiers

Overview (`meetings/2020/README.md`)

C# Language Design Notes for 2020

Overview of meetings and agendas for 2020

Dec 16, 2020

C# Language Design Notes for December 16th, 2020

  • List patterns
  • Definite assignment changes

Dec 14, 2020

C# Language Design Notes for December 14th, 2020

  • List patterns

Dec 7, 2020

C# Language Design Notes for December 7th, 2020

  • Required Properties

Dec 2, 2020

C# Language Design Notes for December 2nd, 2020

  • Partner scenarios in roles and extensions

Nov 16, 2020

C# Language Design Notes for November 16th, 2020

  • Triage

Nov 11, 2020

C# Language Design Notes for November 11th, 2020

  • IsRecord in metadata
  • Triage

Nov 4, 2020

C# Language Design Notes for November 4th, 2020

  • Nullable parameter defaults
  • Argument state after call for AllowNull parameters

Oct 26, 2020

C# Language Design Notes for October 26st, 2020

  • Pointer types in records
  • Triage

Oct 21, 2020

C# Language Design Notes for October 21st, 2020

  • Primary Constructors
  • Direct Parameter Constructors

Oct 14, 2020

C# Language Design Notes for October 14th, 2020

  • Triage
  • Milestone Simplification

Oct 12, 2020

C# Language Design Notes for October 12th, 2020

  • General improvements to the struct experience (continued)

Oct 7, 2020

C# Language Design Notes for October 7th, 2020

  • record struct syntax
  • data members redux
  • ReadOnlySpan<char> patterns

Oct 5, 2020

C# Language Design Notes for October 5th, 2020

  • record struct primary constructor defaults
  • Changing the member type of a primary constructor parameter
  • data members

Sep 30, 2020

C# Language Design Notes for September 30th, 2020

  • record structs
    • struct equality
    • with expressions
    • Primary constructors and data properties

Sep 28, 2020

C# Language Design Notes for September 28th, 2020

  • Warning on double.NaN
  • Triage

Sep 23, 2020

C# Language Design Notes for September 23rd, 2020

  • General improvements to the struct experience

Sep 16, 2020

C# Language Design Notes for September 16th, 2020

  • Required Properties
  • Triage

Sep 14, 2020

C# Language Design Notes for September 14th, 2020

  • Partial method signature matching
  • Null-conditional handling of the nullable suppression operator
  • Annotating IEnumerable.Cast
  • Nullability warnings in user-written record code
  • Tuple deconstruction mixed assignment and declaration

Sep 9, 2020

C# Language Design Notes for September 9th, 2020

  • Triage issues still in C# 9.0 candidate
  • Triage issues in C# 10.0 candidate

Aug 24, 2020

C# Language Design Notes for August 24th, 2020

  • Warnings on types named record
  • base calls on parameterless records
  • Omitting unnecessary synthesized record members
  • record ToString behavior review
    • Behavior of trailing commas
    • Handling stack overflows
    • Should we omit the implementation of ToString on abstract records
    • Should we call ToString prior to StringBuilder.Append on value types
    • Should we try and avoid the double-space in an empty record
    • Should we try and make the typename header print more economic
  • Reference equality short circuiting

Jul 27, 2020

C# Language Design Notes for July 27th, 2020

Jul 20, 2020

C# Language Design Notes for July 20th, 2020

Jul 13, 2020

C# Language Design Notes for July 13th, 2020

  • Triage open issues

Jul 6, 2020

C# Language Design Notes for July 6, 2020

Jul 1, 2020

C# Language Design Notes for July 1, 2020

Jun 29, 2020

C# Language Design Notes for June 29, 2020

Jun 24, 2020

C# Language Design Notes for June 24, 2020

Jun 22, 2020

C# Language Design Notes for June 22, 2020

  1. Data properties

  2. Clarifying what's supported in records for C# 9

    • Structs

    • Inheritance with records and classes

Jun 17, 2020

C# Language Design Notes for June 17, 2020

  1. Null-suppression & null-conditional operator
  2. parameter! syntax
  3. T??

Jun 15, 2020

C# Language Design Notes for June 15, 2020

Record:

  1. modreq for init accessors

  2. Initializing readonly fields in same type

  3. init methods

  4. Equality dispatch

  5. Confirming some previous design decisions

  6. IEnumerable.Current

Jun 10, 2020

C# Language Design Notes for June 10, 2020

Jun 1, 2020

C# Language Design Notes for June 1, 2020

Records:
1. Base call syntax
2. Synthesizing positional record members and assignments
3. Record equality through inheritance

May 27, 2020

C# Language Design Notes for May 27, 2020

Record syntax
1. Record structs?
2. Record syntax/keyword
3. Details on property shorthand syntax

May 11, 2020

C# Language Design Notes for May 11, 2020

Records

May 6, 2020

C# Language Design Notes for May 6, 2020

  1. Target-typing ?: when the natural type isn't convertible to the target type.
  2. Allow if (x is not string y) pattern.
  3. Open issues in extension GetEnumerator
  4. Args in top-level programs

May 4, 2020

C# Language Design Notes for May 4, 2020

  1. Reviewing design review feedback

April 27, 2020

C# Language Design Notes for April 27, 2020

Records: positional & primary constructors

April 20, 2020

C# Language Design Notes for April 20, 2020

Records: Factories

April 15, 2020

C# Language Design Notes for April 15, 2020

  1. Non-void and non-private partial methods
  2. Top-level programs

April 13. 2020

C# Language Design Notes for April 13, 2020

  1. Roadmap for records
  2. Init-only properties

April 8, 2020

C# Language Design Notes for April 8, 2020

  1. e is dynamic pure null check
  2. Target typing ?:
  3. Inferred type of an or pattern
  4. Module initializers

April 6, 2020

C# Language Design Notes for April 6, 2020

  1. Record Monday: Init-only members

April 1, 2020

C# Language Design Notes for April 1, 2020

  1. Function pointer design adjustments

  2. field keyword in properties

March 30, 2020

  1. Record Monday

C# Language Design Notes for March 30, 2020

March 25, 2020

C# Language Design Notes for March 25, 2020

  1. Open issues with native int

  2. Open issues with target-typed new

March 23, 2020

C# Language Design Notes for March 23, 2020

  1. Triage
  2. Builder-based records

March 9, 2020

C# Language Design Notes for March 9, 2020

  1. Simple programs

  2. Records

Feb 26, 2020

C# Language Design Notes for Feb. 26, 2020

Design Review

Feb 24

C# Language Design Notes for Feb. 24, 2020

Taking another look at "nominal" records

Feb 19

C# Language Design Notes for Feb. 19, 2020

State-based value equality

Feb 12

C# Language Design Notes for Feb. 12, 2020

Records

Feb 10

C# Language Design Notes for Feb. 10, 2020

Records

Feb 5

C# Language Design Notes for Feb. 5, 2020

Feb 3

C# Language Design Notes for Feb. 3, 2020

Value Equality

Jan 29, 2020

C# Language Design Notes for Jan. 29, 2020

Records: "With-ers"

Jan 22, 2020

C# Language Design Notes for Jan 22, 2020

  1. Top-level statements and functions
  2. Expression Blocks

Jan 15, 2020

C# Language Design Notes for Jan 15, 2020

Records

  1. "programming with data"
  2. Decomposing subfeatures of records

Jan 8, 2020

C# Language Design Notes for Jan 8, 2020

  1. Unconstrained type parameter annotation
  2. Covariant returns

Jan 6, 2020

C# Language Design Notes for Jan 6, 2020

  1. Use attribute info inside method bodies
  2. Making Task-like types covariant for nullability
  3. Casting to non-nullable reference type
  4. Triage

Overview (`meetings/2021/README.md`)

C# Language Design Notes for 2021

Overview of meetings and agendas for 2021

Dec 15, 2021

C# Language Design Notes for December 15th, 2021

  1. Required parsing
  2. Warnings for parameterless struct constructor

Dec 1, 2021

C# Language Design Notes for December 1st, 2021

  1. Roles and extensions

Nov 10, 2021

C# Language Design Notes for November 10th, 2021

  1. Self types

Nov 3, 2021

C# Language Design Notes for November 3rd, 2021

  1. Name shadowing in local functions
  2. params Span<T>

Nov 1, 2021

C# Language Design Notes for November 1st, 2021

  1. Order of evaluation for Index and Range
  2. Collection literals

Oct 27, 2021

C# Language Design Notes for October 27th, 2021

  1. UTF-8 String Literals
  2. Readonly modifiers for primary constructors

Oct 25, 2021

C# Language Design Notes for October 25th, 2021

  1. Required members
  2. Delegate type argument improvements

Oct 20, 2021

C# Language Design Notes for October 20th, 2021

  1. Open questions in list patterns
    1. Types that define both Length and Count
    2. Slices that return null
  2. Primary constructors

Oct 13, 2021

C# Language Design Notes for October 13th, 2021

  1. Revisiting DoesNotReturn
  2. Warning on lowercase type names
  3. Length pattern backcompat

Sep 22, 2021

C# Language Design Notes for September 22nd, 2021

  1. Open questions in list patterns
    1. Breaking change confirmation
    2. Positional patterns on ITuple
    3. Slicing rules
    4. Slice syntax recommendations
    5. Other list pattern features
  2. Nested members in with and object creation
  3. CallerIdentityAttribute
  4. Attributes on Main for top level programs

Sep 20, 2021

C# Language Design Notes for September 20th, 2021

  1. Lambda breaking changes
  2. Newlines in non-verbatim interpolated strings
  3. Object initializer event hookup
  4. Type alias improvements

Sep 15, 2021

C# Language Design Notes for September 15th, 2021

  • Feedback from the C# standardization committee
  • Permit pattern variables under disjunctive patterns

Sep 13, 2021

C# Language Design Notes for September 13th, 2021

  1. Feedback on static abstracts in interfaces

Sep 1, 2021

C# Language Design Notes for September 1st, 2021

  1. Lambda expression conversions to Delegate
  2. C# 11 Initialization Triage
    1. Required properties
    2. Primary constructors
    3. Immutable collection initializers

Aug 30, 2021

C# Language Design Notes for August 30th, 2021

  1. C# 11 Initial Triage
    1. Generic attributes
    2. List patterns
    3. Static abstracts in interfaces
    4. Declarations under or patterns
    5. Records and initialization
    6. Discriminated unions
    7. Params Span<T>
    8. Statements as expressions
    9. Expression trees
    10. Type system extensions

Aug 25, 2021

C# Language Design Notes for August 25th, 2021

  1. Interpolated string handler user-defined conversion recommendations
  2. Interpolated string handler additive expressions

Aug 23, 2021

C# Language Design Notes for August 23rd, 2021

  1. Nullability differences in partial type base clauses
  2. Top-level statements default type accessibility
  3. Lambda expression and method group type inference issues
    1. Better function member now ambiguous in some cases
    2. Conversions from method group to object
  4. Interpolated string betterness in older language versions

Jul 26, 2021

C# Language Design Notes for July 26th, 2021

  1. Lambda conversion to System.Delegate
  2. Direct invocation of lambdas
  3. Speakable names for top-level statements

Jul 19, 2021

C# Language Design Notes for July 19th, 2021

  1. Global using scoping revisited

Jul 12, 2021

C# Language Design Notes for July 12th, 2021

  1. C# 10 Feature Status
  2. Speakable names for top-level statements

Jun 21, 2021

C# Language Design Notes for June 21st, 2021

  1. Open questions for lambda return types
  2. List patterns in recursive patterns
  3. Open questions in async method builder
  4. Email Decision: Duplicate global using warnings

Jun 14, 2021

C# Language Design Notes for June 14th, 2021

  1. Open questions in CallerArgumentExpressionAttribute
  2. List pattern syntax

Jun 7, 2021

C# Language Design Notes for June 7th, 2021

  1. Runtime checks for parameterless struct constructors
  2. List patterns
    a. Exhaustiveness
    b. Length pattern feedback

Jun 2, 2021

C# Language Design Notes for June 2nd, 2021

  1. Enhanced #line directives
  2. Lambda return type parsing
  3. Records with circular references

May 26, 2021

C# Language Design Notes for May 26th, 2021

  1. Open questions in list patterns

May 19, 2021

C# Language Design Notes for May 19th, 2021

  1. Triage
    1. Checked operators
    2. Relaxing shift operator requirements
    3. Unsigned right shift operator
    4. Opaque parameters
    5. Column mapping directive
    6. Only allow lexical keywords
    7. Allow nullable types in declaration patterns
  2. Protected interface methods

May 17, 2021

C# Language Design Notes for May 17th, 2021

  1. Raw string literals

May 12, 2021

C# Language Design Notes for May 12th, 2021

  1. Experimental attribute
  2. Simple C# programs

May 10, 2021

C# Language Design Notes for May 10th, 2021

  • Lambda improvements

May 3, 2021

C# Language Design Notes for May 3rd, 2021

  1. Improved interpolated strings
  2. Open questions in record structs

Apr 28, 2021

C# Language Design Notes for April 28th, 2021

  1. Open questions in record and parameterless structs
  2. Improved interpolated strings

Apr 21, 2021

C# Language Design Notes for April 21st, 2021

  1. Inferred types for lambdas and method groups
  2. Improved interpolated strings

Apr 19, 2021

C# Language Design Notes for April 19th, 2021

  1. Improved interpolated strings

Apr 14, 2021

C# Language Design Notes for April 14th, 2021

  1. Shadowing in record types
  2. field keyword
  3. Improved interpolated strings

Apr 12, 2021

C# Language Design Notes for April 12th, 2021

  1. List patterns
  2. Lambda improvements

Apr 7, 2021

C# Language Design Notes for April 7th, 2021

  • MVP session

Apr 5, 2021

C# Language Design Notes for April 5th, 2021

  1. Interpolated string improvements
  2. Abstract statics in interfaces

Mar 29, 2021

C# Language Design Notes for March 29th, 2021

  1. Parameterless struct constructors
  2. AsyncMethodBuilder

Mar 24, 2021

C# Language Design Notes for March 24th, 2021

  1. Improved interpolated strings
  2. field keyword

Mar 22, 2021

  • Design review (No notes published)

Mar 15, 2021

C# Language Design Notes for March 15th, 2021

  1. Interpolated string improvements
  2. Global usings

Mar 10, 2021

C# Language Design Notes for March 10th, 2021

  1. Property improvements
    1. field keyword
    2. Property scoped fields
  2. Parameterless struct constructors

Mar 3, 2021

C# Language Design Notes for March 3rd, 2021

  1. Natural type for lambdas
    1. Attributes
    2. Return types
    3. Natural delegate types
  2. Required members

Mar 1, 2021

C# Language Design Notes for March 1st, 2021

  1. Async method builder override
  2. Async exception filters
  3. Interpolated string improvements

Feb 24, 2021

C# Language Design Notes for February 24th, 2021

  1. Static abstract members in interfaces

Feb 22, 2021

C# Language Design Notes for February 22nd, 2021

  1. Global usings
  2. using alias improvements

Feb 10, 2021

C# Language Design Notes for February 10th, 2021

  1. Follow up on record equality
  2. Namespace directives in top-level programs
  3. Global usings
  4. Triage
    1. Nominal And Collection Deconstruction
    2. Sealed record ToString
    3. using aliases for tuple syntax
    4. Raw string literals
    5. Allow var variables to be used in a nameof in their initializers
    6. First-class native integer support
    7. Extended property patterns

Feb 8, 2021

C# Language Design Notes for February 8th, 2021

  1. Virtual statics in interfaces
    1. Syntax Clashes
    2. Self-applicability as a constraint
    3. Relaxed operator operand types
    4. Constructors

Feb 3, 2021

C# Language Design Notes for February 3rd, 2021

  1. List patterns on IEnumerable
  2. Global usings

Jan 27, 2021

C# Language Design Notes for January 27th, 2021

  1. Init-only access on conversion on this
  2. Record structs
    1. Copy constructors and Clone methods
    2. PrintMembers
    3. Implemented equality algorithms
    4. Field initializers
    5. GetHashcode determinism

Jan 13, 2021

C# Language Design Notes for January 13th, 2021

  • Global usings
  • File-scoped namespaces

Jan 11, 2021

C# Language Design Notes for January 11th, 2021

  • Required properties simple form

Jan 6, 2021

C# Language Design Notes for January 5th, 2021

  • File scoped namespaces

Overview (`meetings/2022/README.md`)

C# Language Design Notes for 2022

Overview of meetings and agendas for 2022

Wed Dec 14, 2022

C# Language Design Meeting for December 14th, 2022

  • Breaking change for raw string literals
  • Program as internal by default

Wed Nov 30, 2022

C# Language Design Meeting for November 30th, 2022

  • Revise MemberNotNull for required
  • params Span<T>

Wed Nov 2, 2022

C# Language Design Meeting for November 2nd, 2022

  • Partial Properties
  • Default parameter values in lambdas

Wed Oct 26, 2022

C# Language Design Meeting for October 26th, 2022

  • Null-conditional assignment

Wed Oct 19, 2022

C# Language Design Meeting for October 19th, 2022

  • Open questions in list patterns on IEnumerable
    • Allowing patterns after slices
    • Allowing slicing to capture

Mon Oct 17, 2022

C# Language Design Meeting for October 17th, 2022

  • Primary Constructors
  • Permit variable declarations under disjunctive patterns

Wed Oct 12, 2022

C# Language Design Meeting for October 12th, 2022

  • Keywordness of field

Mon Oct 10, 2022

C# Language Design Meeting for October 10th, 2022

  • Working set triage
    • Static classes implementing interfaces
    • Null-conditional assignment
    • Lambda default parameters
  • Working groups
  • params support for lambda default parameters
    • Conclusion

Wed Oct 5, 2022

C# Language Design Meeting for October 5th, 2022

  • Review of ref fields
    • RefSafetyRulesAttribute
    • Return-only scope

Wed Sep 28, 2022

C# Language Design Meeting for September 28th, 2022

  • Working set triage
    • Discriminated Unions
    • Collection literals
    • Nullability improvements
    • Ungrouped

Mon Sep 26, 2022

C# Language Design Meeting for September 26th, 2022

  • Working set triage
    • Roles & Extensions
    • Discriminated Unions
    • Bridging statements and expressions
    • Construction improvements
    • ref struct improvements
    • params improvements
    • Ungrouped

Wed Sep 21, 2022

C# Language Design Meeting for September 21st, 2022

  • Unchampioned issue triage
    • Track subtype exhaustiveness for classes with only private constructors
    • ReadOnlySpan initialization from static data
    • Embedded Language Indicators for raw string literals
    • Implicit Parameters
  • Unsafer Unsafeness
    • Conclusion

Wed Aug 31, 2022

C# Language Design Meeting for August 31st, 2022

  1. Short term work triage
    1. Partial properties
    2. Using aliases for any type
    3. Null-conditional assignment
    4. await?
    5. params IEnumerable
    6. Discriminated Unions
    7. Roles
    8. pragma warning enable
    9. Ignored directives support
    10. Primary constructors
    11. Switch expression as a statement

Wed Aug 24, 2022

C# Language Design Meeting for August 24th, 2022

  1. C# feature triage

Wed Aug 10, 2022

C# Language Design Meeting for August 10th, 2022

  1. required property default nullability

Wed Aug 3, 2022

C# Language Design Meeting for August 3rd, 2022

  1. ref fields specification updates

Wed Jul 27, 2022

C# Language Design Meeting for July 27th, 2022

  1. scoped for local declarations

Wed Jul 13, 2022

C# Language Design Meeting for July 13th, 2022

  1. Lambda default parameters

Jun 29, 2022

C# Language Design Meeting for June 29th, 2022

  • UTF-8 literal concatenation operator

Jun 6, 2022

C# Language Design Meeting for June 6, 2022

  1. Open issues for ref fields
  2. Open issues for static virtual members
  3. Concatenation of Utf8 literals

May 23, 2022

C# Language Design Meeting for May 23rd, 2022

  1. Open issues for ref fields

May 11, 2022

C# Language Design Meeting for May 11th, 2022

  1. Inconsistency around accessibility checks for interface implementations
  2. ref readonly method parameters
  3. Pattern matching with UTF-8 String Literals

May 9, 2022

C# Language Design Meeting for May 9th, 2022

  1. Numeric IntPtr
  2. Ref readonly parameters

May 2, 2022

C# Language Design Meeting for May 2nd, 2022

  • Effect of SetsRequiredMembers on nullable analysis
  • field questions
    • Partial overrides of virtual properties
    • Definite assignment of manually implemented setters

Apr 27, 2022

C# Language Design Meeting for April 27th, 2022

  • Default parameter values in lambdas
  • Null-conditional assignment

Apr 25, 2022

C# Language Design Meeting for April 25th, 2022

  • ref readonly method parameters
  • Inconsistencies around accessibility checks for interface implementations

Apr 18, 2022

C# Language Design Meeting for April 18th, 2022

  1. Issues with Utf8 string literals
  2. Ref and ref struct scoping modifiers

Apr 13, 2022

C# Language Design Meeting for April 13th, 2022

  1. Parameter null checking
  2. File-scoped types

Apr 11, 2022

C# Language Design Meeting for April 11th, 2022

  1. Relax restrictions on braces on raw interpolated strings
  2. Self-type stopgap attribute

Apr 6, 2022

C# Language Design Meeting for April 6th, 2022

  1. Unresolved questions for static virtual members
  2. Parameter null checking

Mar 30, 2022

C# Language Design Meeting for March 30th, 2022

  1. Definite assignment in struct constructors calling : this()
  2. file private accessibility

Mar 28, 2022

C# Language Design Meeting for March 28th, 2022

  1. Variable declarations under disjunctive patterns
  2. Type hole in static abstracts
  3. Self types

Mar 23, 2022

C# Language Design Meeting for March 23rd, 2022

  1. Open questions in required members
    1. Emitting SetsRequiredMembers for record copy constructors
    2. Should SetsRequiredMembers suppress errors?
    3. Unsettable members
    4. Ref returning properties
    5. Obsolete members

Mar 21, 2022

C# Language Design Meeting for March 21st, 2022

  1. file private visibility
  2. Open question in semi-auto properties
  3. Open question in required members

Mar 14, 2022

C# Language Design Meeting for March 14th, 2022

  1. file private visibility

Mar 9, 2022

C# Language Design Meeting for March 9th, 2022

  1. Ambiguity of .. in collection expressions
  2. main attributes
  3. nameof(param)

Mar 7, 2022

  • Design review. No published notes.

Mar 2, 2022

C# Language Design Meeting for March 2nd, 2022

  1. Open questions in field
    1. Initializers
    2. Property assignment in structs

Feb 28, 2022

C# Language Design Meeting for February 28th, 2022

  1. Ref fields
    1. Encoding strategy
    2. Keywords vs Attributes
    3. Breaking existing lifetime rules

Feb 23, 2022

C# Language Design Meeting for February 23rd, 2022

  1. Pattern matching over Span<char>
  2. Checked operators

Feb 16, 2022

C# Language Design Meeting for February 16th, 2022

  1. Open questions in field
  2. Triage
    1. User-defined positional patterns
    2. Delegate type arguments improvements
    3. Practical existential types for interfaces
    4. Static abstract interfaces and static classes

Feb 14, 2022

C# Language Design Meeting for February 14th, 2022

  1. Definite assignment in structs
  2. Checked operators

Feb 9, 2022

C# Language Design Meeting for February 9th, 2022

  1. Continue discussion of checked user-defined operators
  2. Review proposal for unsigned right shift operator
  3. Review proposal for relaxing shift operator requirements
  4. Triage champion features

Feb 7, 2022

C# Language Design Meeting for February 7th, 2022

  1. Checked user-defined operators

Jan 26, 2022

C# Language Design Notes for January 26th, 2022

  1. Open questions in UTF-8 string literals

Jan 24, 2022

C# Language Design Notes for January 24th, 2022

  1. Required members metadata representation
  2. Default implementations of abstract statics
  3. Triage
    1. Nested members in with and object creation
    2. Binary Compat Only
    3. Attribute for passing caller identity implicitly
    4. Attributes on Main for top level programs

Jan 12, 2022

C# Language Design Notes for January 12th, 2022

  1. Open questions for field
    1. Initializers for semi-auto properties
    2. Definite assignment for struct types
  2. Generic Math Operator Enhancements

Jan 5, 2022

C# Language Design Notes for January 5th, 2022

  1. Required Members

Jan 3, 2022

C# Language Design Notes for January 3rd, 2022

  1. Slicing assumptions in list patterns, revisited
  2. Parameterless struct constructors, revisited

Overview (`meetings/2023/README.md`)

C# Language Design Notes for 2023

Mon Dec 11, 2023

C# Language Design Meeting for December 11th, 2023

  • Extensions

Mon Dec 4, 2023

C# Language Design Meeting for December 4th, 2023

  • Lock statement pattern
  • BinaryCompatOnlyAttribute

Mon Nov 27, 2023

C# Language Design Meeting for November 27th, 2023

  • Pattern order optimizations
  • Subarray slicing breaking change
  • Making patterns constant expressions

Wed Nov 15, 2023

C# Language Design Meeting for November 15th, 2023

  • params improvements
  • Nullability analysis of collection expressions
  • Evaluation of implicit indexers in object initializers

Mon Oct 16, 2023

C# Language Design Meeting for October 16th, 2023

  • Triage
    • Breaking change warnings
    • Determine natural type of method group by looking scope-by-scope
    • u8 string interpolation
    • Lock statement pattern
    • String/Character escape sequence \e as a short-hand for \u001b
    • New operator %% for canonical Modulus operations

Wed Oct 11, 2023

C# Language Design Meeting for October 11th, 2023

  • C# spec update
  • Collection expressions

Mon Oct 9, 2023

C# Language Design Meeting for October 9th, 2023

  • Triage
    • ReadOnlySpan initialization from static data
    • Embedded Language Indicators for raw string literals
    • list-patterns on enumerables
    • Make generated `Program`` for top-level statements public by default
    • CallerCharacterNumberAttribute
    • Add private and namespace accessibility modifiers for top-level types
    • Require await to apply nullable postconditions to task-returning calls
    • is expression evaluating const expression should be considered constant

Wed Oct 4, 2023

C# Language Design Meeting for October 4th, 2023

  • Trimming and AOT

Mon Oct 2, 2023

C# Language Design Meeting for October 2nd, 2023

  • Collection expressions

Wed Sept 27, 2023

C# Language Design Meeting for September 27th, 2023

  • Collection expressions

Mon Sept 25, 2023

C# Language Design Meeting for September 25th, 2023

  • Primary constructors
  • Defining well-defined behavior for collection expression types

Wed Sept 20, 2023

C# Language Design Meeting for September 20th, 2023

  • Collection expressions
    • Type inference from spreads
    • Overload resolution fallbacks

Mon Sept 18, 2023

C# Language Design Meeting for September 18th, 2023

  • Collection expression questions
    • Optimizing non-pattern collection construction
    • Avoiding intermediate buffers for known-length cases

Wed Aug 16 2023

C# Language Design Meeting for August 16th, 2023

  • Ref-safety scope for collection expressions
  • Experimental attribute

Mon Aug 14, 2023

C# Language Design Meeting for August 14th, 2023

  • Betterness for collection expressions and span types
  • Type inference from collection expression elements
  • Collection expression conversions

Wed Aug 9, 2023

C# Language Design Meeting for August 9th, 2023

  • Lambdas with explicit return types
  • Target typing of collection expressions to core interfaces
  • Loosening requirements for collection builder methods

Mon Aug 7, 2023

C# Language Design Meeting for August 7th, 2023

  • Improvements to method group natural types

Mon Jul 31, 2023

C# Language Design Meeting for July 31st, 2023

  • Primary constructor parameters and readonly

Wed Jul 26, 2023

C# Language Design Meeting for July 26th, 2023

  • Primary constructor parameters and readonly

Mon Jul 24, 2023

C# Language Design Meeting for July 24th, 2023

  • Method group natural types with extension members
  • Interceptors

Mon Jul 17, 2023

C# Language Design Meeting for July 17th, 2023

  • Compiler Check-in
  • readonly parameters

Wed Jul 12, 2023

C# Language Design Meeting for July 12th, 2023

  • Collection Literals
    • Create methods
    • Extension methods
  • Interceptors

Mon Jun 19, 2023

C# Language Design Meeting for June 19th, 2023

  • Prefer spans over interfaces in overload resolution
  • Collection literals

Mon Jun 5, 2023

C# Language Design Meeting for June 5th, 2023

  • Collection literals

Wed May 31, 2023

C# Language Design Meeting for May 31st, 2023

  • Collection literals

Wed May 17, 2023

C# Language Design Meeting for May 17th, 2023

  • Inline arrays

Mon May 15, 2023

C# Language Design Meeting for May 15th, 2023

  • Breaking Change Warnings
  • Primary Constructors

Mon May 8, 2023

C# Language Design Meeting for May 8th, 2023

  • Primary Constructors

Wed May 3, 2023

C# Language Design Meeting for May 3rd, 2023

  • Inline Arrays
  • Primary constructors
    • Attributes on captured parameters
    • Warning for shadowing base members
  • Collection literal natural type

Mon May 1, 2023

C# Language Design Meeting for May 1st, 2023

  • Fixed Size Buffers
  • lock statement improvements

Wed Apr 26, 2023

C# Language Design Meeting for April 26th, 2023

  • Collection literals

Mon Apr 10, 2023

C# Language Design Meeting for April 10th, 2023

  • Fixed Size Buffers

Mon Apr 3, 2023

C# Language Design Meeting for April 3rd, 2023

  • Collection Literals
  • Fixed-size buffers

Wed Mar 15, 2023 (No notes)

  • Discriminated Unions
  • Interceptors

Mon Mar 13, 2023 (Shorter meeting)

C# Language Design Meeting for March 13th, 2023

  • Unsafe in aliases hole
  • Attributes on primary ctors

Wed Mar 8, 2023

C# Language Design Meeting for March 8th, 2023

  • Discriminated Unions
  • Limited Breaking Changes in C#

Wed Mar 1, 2023 (Shorter meeting)

C# Language Design Meeting for March 1st, 2023

  • Discriminated Unions Summary

Mon Feb 27, 2023

C# Language Design Meeting for February 27th, 2023

  • Interceptors

Wed Feb 22, 2023

C# Language Design Meeting for February 22nd, 2023

  • Primary Constructors
  • Extensions

Wed Feb 15, 2023

C# Language Design Meeting for February 15th, 2023

  • Open questions in primary constructors
    • Capturing parameters in lambdas
    • Assigning to this in a struct

Wed Feb 1, 2023

C# Language Design Meeting for February 1st, 2023

  • Position of unsafe in aliases
  • Roles and extensions

Wed Jan 18, 2023

C# Language Design Meeting for January 18th, 2023

  • Nullable post-conditions and async/await
  • Semi-colon bodies for type declarations

Wed Jan 11, 2023

C# Language Design Meeting for January 11th, 2023

  • using aliases for any types
    • Pointer types in aliases
    • Reference nullability in aliases
    • Value nullability in aliases

Mon Jan 9, 2023

C# Language Design Meeting for January 9th, 2023

  • Working group re-evaluation

Overview (`meetings/2024/README.md`)

C# Language Design Notes for 2024

Mon Dec 9, 2024

C# Language Design Meeting for December 9th, 2024

  • First-class span open questions
  • Simple Lambda Parameters
  • Collection expression arguments

Wed Dec 4, 2024

C# Language Design Meeting for December 4th, 2024

  • First-class span open questions
    • Preferring ReadOnlySpan<T> over Span<T> conversions
    • Conversions in expression trees

Wed Nov 20, 2024

C# Language Design Meeting for November 20th, 2024

  • Extensions
  • Dictionary Expressions

Wed Nov 13, 2024

C# Language Design Meeting for November 13th, 2024

  • Extensions

Mon Nov 4, 2024

C# Language Design Meeting for November 4th, 2024

  • not and or patterns
  • Notes on notes

Wed Oct 30, 2024

C# Language Design Meeting for October 30th, 2024

  • Extensions

Mon Oct 28, 2024

C# Language Design Meeting for October 28th, 2024

  • Increment and Decrement Operators in null conditional access
  • yield in try / catch

Mon Oct 21, 2024

Canceled

Wed Oct 16, 2024

C# Language Design Meeting for October 16th, 2024

  • Simple lambda parameters
  • Unbound generic types in nameof
  • typeof string constants

Mon Oct 14, 2024

C# Language Design Meeting for October 14th, 2024

  • Extensions

Wed Oct 9, 2024

C# Language Design Meeting for October 9th, 2024

  • Extensions

Mon Oct 7, 2024

C# Language Design Meeting for October 7th, 2024

  • Extensions

Wed Oct 2, 2024

C# Language Design Meeting for October 2nd, 2024

  • Open questions in field
    • readonly contexts and set
    • Conditional code
    • Interface properties and auto-accessors
  • Extensions

Mon Sep 30, 2024

C# Language Design Meeting for September 30th, 2024

  • Extensions

Wed Sep 25, 2024

  • C# 14 (no notes)

Mon Sep 23, 2024

  • Design review (no notes)

Wed Sep 18, 2024

C# Language Design Meeting for September 18th, 2024

  • Nullability in field
  • Extensions naming

Wed Sep 11, 2024

C# Language Design Meeting for September 11th, 2024

  • Better conversion from collection expression and params collections
  • First-class span types
    • Reverse
    • New ambiguities
    • Covariant arrays

Wed Sep 4, 2024

C# Language Design Meeting for September 4th, 2024

  • Triage (no milestone)
    • Type inference using method group natural type
    • Collection Expressions Next (C#13 and beyond)
    • Dictionary expressions
    • Extending patterns to "as"
    • params in parameters
  • Triage (working set)
    • Only Allow Lexical Keywords in the Language
    • Permit variable declarations under disjunctive patterns
    • CallerCharacterNumberAttribute
    • Task<T> nullability covariance
    • Nullable analysis of LINQ queries

Wed Aug 28, 2024

C# Language Design Meeting for August 28th, 2024

  • Nullable in ref ternaries
  • Block-bodied switch expression arms

Mon Aug 26, 2024

C# Language Design Meeting for August 26th, 2024

  • field keyword open questions
    • field in property initializers
    • Interaction with partial properties
    • readonly field

Wed Aug 21, 2024

C# Language Design Meeting for August 21st, 2024

  • Better conversion from collection expression
  • field keyword nullability

Mon Aug 19, 2024

C# Language Design Meeting for August 19th, 2024

  • Better conversion from collection expression

Wed Aug 14, 2024

C# Language Design Meeting for August 14th, 2024

  • field keyword
    • field nullability
    • field in event accessor
    • Scenarios similar to set;

Wed Jul 24, 2024

C# Language Design Meeting for July 24th, 2024

  • Discriminated Unions
  • Better conversion from collection expression with ReadOnlySpan<T> overloads

Mon Jul 22, 2024

C# Language Design Meeting for July 22nd, 2024

  • Extensions
  • Ref structs implementing interfaces

Wed Jul 17, 2024

C# Language Design Meeting for July 17th, 2024

  • Overload resolution priority open questions
  • Better conversion from collection expression with ReadOnlySpan<T> overloads

Mon Jul 15, 2024

C# Language Design Meeting for July 15th, 2024

  • field keyword
  • First-Class Spans Open Question

Wed Jun 26, 2024

C# Language Design Meeting for June 26th, 2024

  • Extensions

Mon Jun 24, 2024

C# Language Design Meeting for June 24th, 2024

  • First-Class Spans
  • field questions
    • Mixing auto-accessors
    • Nullability

Mon Jun 17, 2024

C# Language Design Meeting for June 17th, 2024

  • params Span breaks
  • Overload resolution priority questions
    • Application error or warning on overrides
    • Implicit interface implementation
  • Inline arrays as record structs

Wed Jun 12, 2024

C# Language Design Meeting for June 12th, 2024

  • params Span breaks
  • Extensions

Mon Jun 10, 2024

C# Language Design Meeting for June 10th, 2024

  • ref structs implementing interfaces and in generics

Mon Jun 3, 2024

C# Language Design Meeting for June 3rd, 2024

  • Params collections and dynamic
  • Allow ref and unsafe in iterators and async

Wed May 15, 2024

C# Language Design Meeting for May 15th, 2024

  • field and value as contextual keywords
    • Usage in nameof
    • Should value be a keyword in a property or indexer get? Should field be a keyword in an indexer?
    • Should field and value be considered keywords in lambdas and local functions within property accessors?
    • Should field and value be keywords in property or accessor signatures? What about nameof in those spaces?
  • Dictionary expressions

Mon May 13, 2024

C# Language Design Meeting for May 13th, 2024

  • First-class span types questions
    • Delegate conversions
    • Variant conversion existence
  • Overload resolution priority questions
    • Attribute shape and inheritance
    • Extension overload resolution

Wed May 8, 2024

C# Language Design Meeting for May 8th, 2024

  • readonly for primary constructor parameters

Wed May 1, 2024

C# Language Design Meeting for May 1st, 2024

  • Adjust binding rules in the presence of a single candidate

Wed Apr 24, 2024

C# Language Design Meeting for Apr 24th, 2024

  • Adjust dynamic binding rules for a situation of a single applicable candidate

Mon Apr 22, 2024

C# Language Design Meeting for Apr 22nd, 2024

  • Effect of language version on overload resolution in presence of params collections
  • Partial type inference: '_' in method and object creation type argument lists

Wed Apr 17, 2024

C# Language Design Meeting for Apr 17th, 2024

  • Relax Add requirement for collection expression conversions to types implementing IEnumerable
  • Extensions

Mon Apr 15, 2024

C# Language Design Meeting for Apr 15th, 2024

  • Non-enumerable collection types
  • Interceptors
  • Relax Add requirement for collection expression conversions to types implementing IEnumerable

Mon Apr 8, 2024

C# Language Design Meeting for Apr 8th, 2024

  • Implementation specific documentation

Mon Apr 1, 2024

C# Language Design Meeting for Apr 1st, 2024

  • Async improvements (Async2)

Wed Mar 27, 2024

C# Language Design Meeting for Mar 27th, 2024

  • Discriminated Unions

Mon Mar 11, 2024

C# Language Design Meeting for Mar 11th, 2024

  • Dictionary expressions

Mon Mar 4, 2024

C# Language Design Meeting for Mar 4th, 2024

  • Breaking changes: making field and value contextual keywords
  • Overload resolution priority

Wed Feb 28, 2024

C# Language Design Meeting for Feb 28th, 2024

  • Extensions

Mon Feb 26, 2024

C# Language Design Meeting for Feb 26th, 2024

  • ref structs in generics
  • Collection expressions

Wed Feb 21, 2024

C# Language Design Meeting for Feb 21st, 2024

  • Declaration of ref/out parameters in lambdas without typename
  • params collections
    • Metadata format
    • params and scoped across overrides
    • required members and params parameters

Wed Feb 7, 2024

C# Language Design Meeting for Feb 7th, 2024

  • Partial type inference
  • Breaking change warnings

Mon Feb 5, 2024

C# Language Design Meeting for Feb 5th, 2024

  • First-class span types
  • Collection expressions: inline collections

Wed Jan 31, 2024

C# Language Design Meeting for January 31st, 2024

  • Relax "enumerable" requirement for collection expressions
  • params collections evaluation orders

Mon Jan 29, 2024

C# Language Design Meeting for January 29th, 2024

  • params collections
    • Better function member changes
    • dynamic support
  • dynamic and ref local function bugfixing

Mon Jan 22, 2024

C# Language Design Meeting for January 22nd, 2024

Wed Jan 10, 2024

C# Language Design Meeting for January 10th, 2024

  • Collection expressions: conversion vs construction

Mon Jan 8, 2024

C# Language Design Meeting for January 8th, 2024

  • Collection expressions
    • Iteration type of CollectionBuilderAttribute collections
    • Iteration type in conversions

Overview (`meetings/2025/README.md`)

C# Language Design Notes for 2025

Wed December 17, 2025

C# Language Design Meeting for December 17th, 2025

  • Collection expression arguments parsing question
  • Null-conditionals evaluating to a pointer type
  • Triage
    • Top-Level Members
    • Using local declaration improvements

Wed Dec 10, 2025

C# Language Design Meeting for December 10th, 2025

  • Collection expression arguments

Wed Nov 12, 2025

C# Language Design Meeting for November 12th, 2025

  • Unsafe evolution

Wed Nov 5, 2025

C# Language Design Meeting for November 5th, 2025

  • Unsafe evolution

Wed Oct 29, 2025

C# Language Design Meeting for October 29th, 2025

  • Unsafe evolution

Mon Oct 13, 2025

C# Language Design Meeting for October 13th, 2025

  • Collection expression safe-context bug fix
  • Immediately-enumerated collection expressions

Wed Oct 1, 2025

C# Language Design Meeting for October 1st, 2025

  • Closed enums
  • Closed Hierarchies

Mon Sep 29, 2025

C# Language Design Meeting for September 29th, 2025

  • Union Syntax Thunderdome Part 2
  • Enums vs Unions

Wed Sep 24, 2025

C# Language Design Meeting for September 24th, 2025

  • Union Syntax Thunderdome Part 1

Wed Sep 17, 2025

C# Language Design Meeting for September 17th, 2025

  • Unsafe evolution

Wed Sep 10, 2025

C# Language Design Meeting for September 10th, 2025

  • Unions overview

Wed Aug 27, 2025

C# Language Design Meeting for August 27th, 2025

  • Type inference in patterns
  • Type value conversion
  • Union syntax

Wed Aug 20, 2025

C# Language Design Meeting for August 20th, 2025

  • Union interfaces
  • Target-type inference improvements

Mon Aug 18, 2025

C# Language Design Meeting for August 18th, 2025

  • C# 15 Kickoff and Themes
    • Unions
    • Extensions
    • Dictionary expressions
    • Type inference
    • Continuing the null monad
    • Object initialization
    • Top-level methods
    • Caller type name
    • Switch statement/expression improvements

Wed Aug 13, 2025

C# Language Design Meeting for August 13th, 2025

  • Unions

Wed Jul 30, 2025

C# Language Design Meeting for July 30th, 2025

  • '/main' and top-level statements
  • Union proposals overview
  • Add type parameter restriction to closed hierarchies
  • Standard unions
  • Union interfaces
  • Custom unions
  • Non-boxing access pattern

Mon Jun 30, 2025

C# Language Design Meeting for June 30th, 2025

  • Type parameter inference from constraints
  • Target-typed static member lookup

Wed Jun 25, 2025

C# Language Design Meeting for June 25th, 2025

  • Unions
    • Stand-alone issues
    • Mutually exclusive issues

Mon Jun 23, 2025

C# Language Design Meeting for June 23rd, 2025

  • Extensions
    • Use of extension operators in LINQ expression trees
    • ref encoding and conflict checks
    • Extern support
    • Lookup

Wed Jun 18, 2025

C# Language Design Meeting for June 18th, 2025

  • Iterators in lambdas
  • Extensions

Wed Jun 11, 2025

C# Language Design Meeting for June 11th, 2025

  • Extensions
    • Dynamic resolution of operator true/false
    • Extension operators in LINQ expression trees
    • Built-in operator protection rules
    • Extension module initializers
    • Extension methods as entry points
    • Langversion behavior for new extensions
    • nameof

Mon Jun 9, 2025

C# Language Design Meeting for June 9th, 2025

  • Extensions - crefs

Wed Jun 4, 2025

C# Language Design Meeting for June 4th, 2025

  • Extensions
    • Should extension operators on nullable of extended type be disallowed
    • Applicability of bitwise operators during evaluation of user-defined conditional logical operators
    • Extension user-defined conditional logical operators
    • Extension compound assignment operators
    • Delegate returning properties
    • Extension declaration validation
    • Cref references

Wed May 28, 2025

C# Language Design Meeting for May 28th, 2025

  • Nominal type unions

Mon May 12, 2025

C# Language Design Meeting for May 12th, 2025

  • Collection expression arguments
    • Empty argument lists
    • Constructor binding behavior
    • Syntax
  • Dictionary expressions

Wed May 7, 2025

C# Language Design Meeting for May 7th, 2025

  • Collection Expression Arguments
    • Interface target type
    • Constructor binding behavior
    • Syntax

Mon May 5, 2025

C# Language Design Meeting for May 5th, 2025

  • Extensions
    • XML Docs
    • Participation in pattern-based constructs
    • Skeleton type metadata
    • Single-phase consequences

Wed, Apr 23, 2025

C# Language Design Meeting for April 23rd, 2025

  • Extensions
    • Extension operators
    • Overload resolution priority
  • Dictionary Expressions

Wed Apr 16, 2025

C# Language Design Meeting for April 16th, 2025

  • Extensions

Mon Apr 14, 2025

C# Language Design Meeting for April 14th, 2025

  • Dictionary expressions
  • Collection expression arguments

Wed Apr 9, 2025

C# Language Design Meeting for April 9th, 2025

  • Dictionary expressions
  • Collection expression arguments

Mon Apr 7, 2025

C# Language Design Meeting for April 7th, 2025

  • Breaking change discussion: making partial members in interfaces virtual and/or public
  • Interpolated string handler argument values

April 2, 2025

C# Language Design Meeting for April 2nd, 2025

  • User Defined Compound Assignment Operators
    • Should readonly modifier be allowed in structures?
    • Should shadowing be allowed
    • Should we have any consistency enforcement between declared += and + operators?
  • Readonly setters
    • Expansions

Mon Mar 24, 2025

C# Language Design Meeting for March 24th, 2025

  • Dictionary Expressions
    • Support dictionary types as params type
    • Type inference for KeyValuePair<K, V> collections
    • Overload resolution for KeyValuePair<K, V> collections
  • Extensions
    • Signature conflict rules
    • extension vs extensions

Wed Mar 19, 2025

C# Language Design Meeting for March 19th, 2025

  • Readonly setters on non-variables

Mon Mar 17, 2025

C# Language Design Meeting for March 17th, 2025

  • Collection expression arguments
    • with breaking change
    • Collection expression arguments and conversions
  • Dictionary expressions
  • Extensions
    • Accessibility
    • Static factory scenarios

Mon Mar 12, 2025

C# Language Design Meeting for March 12th, 2025

  • Optional and named parameters in expression trees
  • Collection builder method parameter order
  • Ignored directives

Mon Mar 10, 2025

C# Language Design Meeting for March 10th, 2025

  • Extensions
    • Property method calling
    • Scoping and Shadowing
    • Type parameter inferrability
    • Accessibility

Wed Mar 5, 2025

C# Language Design Meeting for March 5th, 2025

  • Dictionary expressions
  • Target-typed static member lookup

Mon Mar 3, 2025

C# Language Design Meeting for March 3rd, 2025

  • Extensions

Wed Feb 26, 2025

C# Language Design Meeting for February 26th, 2025

  • Extensions

Mon Feb 24, 2025

C# Language Design Meeting for February 24th, 2025

  • Extensions
  • Interpolated string handler method names

Wed Feb 19, 2025

C# Language Design Meeting for February 19th, 2025

  • Extensions

Wed Feb 12, 2025

C# Language Design Meeting for February 12th, 2025

  • User-defined instance-based operators
  • Left-right join in query expressions

Wed Jan 22, 2025

C# Language Design Meeting for January 22nd, 2025

  • Partial events and constructors
  • Collection expression arguments
  • Extensions disambiguation syntax

Wed Jan 15, 2025

C# Language Design Meeting for January 15th, 2025

  • fieldof
  • Simple lambda parameters
  • Interpolated string handler method names

Mon Jan 13th, 2025

C# Language Design Meeting for January 13th, 2025

  • Discriminated Unions

Mon Jan 6, 2025

C# Language Design Meeting for January 6th, 2025

  • Ignoring ref structs in Expressions
  • Extensions

Overview (`meetings/2026/README.md`)

Upcoming meetings for 2026

All schedule items must have a public issue or checked-in proposal that can be linked from the notes.

Schedule ASAP

Schedule when convenient

Recurring topics

  • Triage championed features and milestones
  • Design review

Schedule

Mon Nov 30, 2026

Mon Nov 23, 2026

Mon Nov 9, 2026

Mon Nov 2, 2026

Mon Oct 12, 2026

Mon Oct 5, 2026

C# Language Design Notes for 2026

Wed Aug 19, 2026

C# Language Design Meeting for August 19th, 2026

  • Type parameter inference for constructor calls
    • Generalized generic type inference
    • Type groups
    • Constructor type inference

Wed Aug 12, 2026

C# Language Design Meeting for August 12th, 2026

  • Type parameter inference from constraints implementation review
  • Union pattern matching targets

Wed Aug 5, 2026

C# Language Design Meeting for August 5th, 2026

  • C# 16 feature focus
    • Unsafe v2
    • Dictionary expressions
    • Closed enums
    • Type inference improvements
    • Declarative UI construction
    • Other areas

Wed Jul 22, 2026

C# Language Design Meeting for July 22nd, 2026

  • Allowing safe on non-extern members

Wed Jul 15, 2026

C# Language Design Meeting for July 15th, 2026

  • Declarative UI construction

Wed Jul 1, 2026

C# Language Design Meeting for July 1, 2026

  • Unsafe awaits
  • Extension constants
  • Partial extension members

Mon Jun 8, 2026

C# Language Design Meeting for June 8, 2026

  • Dictionary expressions
    • IReadOnlyDictionary comparer binding
    • KeyValuePair variance in params
  • Unions
    • Union pattern target for custom unions
  • Labeled break and continue

Wed May 27, 2026

C# Language Design Meeting for May 27th, 2026

  • Unsafe evolution
    • Unsafe expressions
    • Await in unsafe blocks
    • Safety comments

Wed May 20, 2026

C# Language Design Meeting for May 20th, 2026

  • Unions
    • Union pattern matching target for custom unions
    • Missing required APIs in custom union declarations
    • Direct value property matching and union rules

Mon May 18, 2026

C# Language Design Meeting for May 18th, 2026

  • Closed hierarchies open questions
    • Exhaustiveness when no subtypes exist
    • Matching the base type after all subtypes
    • Type parameters constrained to closed types
    • Constraint-based ruling out of generic subtypes

Wed May 13, 2026

C# Language Design Meeting for May 13th, 2026

  • Unsafe evolution, continued
    • safe marker syntax
    • unsafe on types
    • unsafe fields
    • Explicit and extended layout fields
    • Implicit calls and constructor edge cases

Wed Apr 29, 2026

C# Language Design Meeting for April 29th, 2026

  • Unsafe evolution
    • Finer-grained opt-in
    • More gradual opt-in
    • Members with pointers in their signature

Mon Apr 27, 2026

C# Language Design Meeting for April 27th, 2026

  • Relaxed partial ordering
  • Labeled break and continue
  • Null-conditional await
  • Chained relational comparisons
  • Compound assignment in initializers
  • Prioritization

Wed Apr 22, 2026

C# Language Design Meeting for April 22nd, 2026

  • Unsafe evolution, continued
    • Signature unsafe and unsafe contexts
    • Transitional diagnostics for pointer-signature calls

Mon Apr 20, 2026

C# Language Design Meeting for April 20th, 2026

  • Closed hierarchies continued
    • Generics and exhaustiveness
    • Accessibility and exhaustiveness
    • Interface convertibility of sealed classes
    • Concrete intermediate nodes

Wed Apr 15, 2026

C# Language Design Meeting for April 15th, 2026

  • Deconstruction in lambda parameters
  • Labeled break and continue

Mon Apr 13, 2026

C# Language Design Meeting for April 13th, 2026

  • Unsafe evolution, continued
    • Safe markers for members with internal unsafe code
    • Members with pointers in their signatures
    • Choosing a temporary spelling for safe

Wed Apr 8, 2026

C# Language Design Meeting for April 8th, 2026

  • Target-typed static member access
    • Scope review and motivating examples
    • Dot or no dot
    • Initial rollout scope

Mon Apr 6, 2026

C# Language Design Meeting for April 6th, 2026

  • Unsafe evolution, continued
    • Simple core model
    • extern members and explicit safety markers

Wed Apr 1, 2026

C# Language Design Meeting for April 1st, 2026

  • Unsafe evolution migration and explicit safety markers
    • Marking extern members as explicitly safe
    • Avoiding easy but incorrect unsafe evolution migration paths

Wed Mar 11, 2026

C# Language Design Meeting for March 11th, 2026

  • Target-typed static member access
    • Overview and smorgasbord of parts
    • Factory containers
    • Ambiguity with parenthesized expression
    • Ambiguity with conditional expression

Mon Mar 9, 2026

C# Language Design Meeting for March 9th, 2026

  • Extension indexers
    • Ordering for implicit indexers and list patterns
    • Slice extensions for range access
    • Spread optimization in collection expressions

Wed Feb 11, 2026

C# Language Design Meeting for February 11th, 2026

  • Union patterns update

Mon Feb 9, 2026

C# Language Design Meeting for February 9th, 2026

  • Closed hierarchies open questions
    • Confirming API shape
    • Blocking subtyping from other languages
    • Multiple CompilerFeatureRequired attributes
    • Same module restriction
    • Permit explicit use of abstract modifier
    • Subtype metadata

Wed Feb 4, 2026

C# Language Design Meeting for February 4th, 2026

  • Discriminated unions patterns
    • Null ambiguity in constructor selection
    • Marking unions with an attribute instead of IUnion interface
    • Factory method support
    • Union member providers

Mon Feb 2, 2026

C# Language Design Meeting for February 2nd, 2026

  • Extension indexers

Mon Jan 26, 2026

C# Language Design Meeting for January 26th, 2026

  • Alternative syntax for caller-unsafe

Wed Jan 21, 2026

C# Language Design Meeting for January 21st, 2026

  • Unsafe evolution

Mon Jan 12, 2026

C# Language Design Meeting for January 12, 2026

  • Triage
    • Relaxed ordering for partial and ref modifiers
    • Deconstruction in lambda parameters
    • Unsigned sizeof
    • Labeled break and continue Statements
    • Extra accessor in property override
    • Immediately Enumerated Collection Expressions
    • Allow arrays as CollectionBuilder Create parameter type

Overview (`proposals/csharp-7.1/README.md`)

C# 7.1

Overview (`proposals/discriminated-unions/README.md`)

Discriminated Unions

This directory explores two alternative designs for bringing the traditional programming concept of discriminated unions to C#. One builds on C# unions, the other on enums.

Start Here

Start with either of the two main proposals. Each introduces its syntax with a complete example before describing the design:

  • Discriminated unions adds case declarations to unions.

    csharp
    union struct Option<T>
{
    case None = default;
    case Some(T Value);
}

  • Data-carrying enums adds cases with associated data through enum class and enum struct.

    csharp
    closed enum struct Option<T>
{
    None = default,
    Some(T Value)
}

Readers can follow either proposal without reading the other first. Most supporting documents are shared between the two approaches.

The design comparison examines the advantages and tradeoffs of each approach.

Supporting Documents

The main proposals link to shared details as needed:

  • Common design covers contextual construction and inference, equality and hashing, nullability, metadata, and other shared behavior and open questions.
  • Non-boxed storage explores an internal layout for union struct and enum struct that avoids boxing during construction and extraction.
  • Per-case records and generated layouts explores choosing each case's record kind independently and selecting storage through attributes and source generators, including native layout and Swift interop.
  • Ref-like types explores an optional extension for ref-like payloads and its open questions. Neither main design depends on it.
  • Switch emission discusses implementation strategies and possible compiler and JIT optimizations for both designs.

Enum members is specific to enums. It proposes allowing user-declared members in ordinary enums and supports those members in the data-carrying enum design.

--- METRICS ---

Explore Related Technologies & Topics

View All 9,111+ Repositories →

Discover similar high-velocity repositories, agent skills, and OpenAPI specifications across the ecosystem.

#csharp Browse csharp catalog → #language-design Browse language-design catalog → ⚡ MCP Servers Model Context Protocol → 🧠 Agent Skills Prompt & rule files → 🔌 OpenAPI Specs REST & Swagger schemas →