Deep Dive Into C # 9, Hacker News

The official planned next C # release is C # 9. You can find in thislinkthe Language Version Planning for C # ·

As shown above, in the list, there are 34 proposals / features are planned for C # 9, but that does not mean that all of those proposals will be released in C # 9.

Which proposal will be released, and in which version? The .Net development team can only answerall these questions. They have the final decision, and they can change their minds all the time, both on proposed features and syntax / semantics of these features.

The most important features planned for C # 9, namely record types, potentially discriminated unions, more pattern matching enhancements, and additional target-typing of existing constructs such as ternary and null -***alescing expressions.

In this article, I will describe Record and Discriminated Unions and the other proposals I will describe them briefly.

!!!!! Important !!!!!

Particularly for both Records and Discriminated Unions, they are not in the final stage. They both still need a lot of work to move from the current strawman proposal syntax to what their final designs will be.

Records

I have been waiting for a long time for this feature. Records are a lightweight type. They are nominally typed, and they might have (methods, properties, operators, etc.), and allow you to compare structural equality! Also, the record properties are read-only by default. Records can be Value Type or Reference Type.

The Proposal in GitHubhere

The most up-to-date proposal for records ishere.

Record from the new proposal

Record would be defined as follows,

In case: Immutable Type

The proposed solution is a new modifier,initonly, that can be applied to properties and fields,

Would be equivalent to,

The final generation of the above would be

Using Records and the With-expression

Records proposal is introduced with the new proposed feature “with-expression”. In programming, an immutable object is an object whose state cannot be modified after it is created. If you want to change the object you have to copied it. The “with” help you to solve the problem, and you can use them together as the following.

The created new point (newPoint3D) just like the existing one (point3D), but with the value of X changed to 42.

This proposal is working very well with pattern matching.

Records in F #

Copy from F # MSDN example, typePoint3D={X: float; Y: float; Z: float}

The output of this code is as follows.

Point is at the origin.

Point is on the x-axis. Value is 100. 000000.

Point is at 10. 000000, 0. 000000, -1. 000000).

Record types are implemented by the compiler, which means you have to meet all of those criteria and can’t get them wrong.

So not only do they save a lot of boilerplate, they eliminate an entire class of potential bugs.

Moreover, this feature existed over a decade in F #, and other languages ​​like (Scala, Kotlin) have a similar concept too.

Examples for other languages ​​that support both constructors and records.

F #

Scala

(Equality)

Records are compared by structure and not by reference

Example

Discriminated Union

The term discriminated union (disjoint union) is borrowed from mathematics. A simple example to understand the term.

Consider the associated sets,

A0={(5,0), (6,1)}

(A1={(7,2)}

The discriminated union can then be calculated as follows,

(A 0) *********************** (⊔) A 1={(5,0), (6,1), (7,2)}

As you can see above, the discriminated union is the sum of the associated sets. Discriminated union (disjoint union) is also widely used in the programming languages ​​(especially in FP), which used to sum the existing data types.

Discriminated unions in C # 9

It offers a way to define types that may hold any number of different data types. Their functionality is similar to F # discriminated union.

The official proposalhere.

Discriminated unions are useful for heterogeneous data; data that can have individual cases, with valid and error cases; data that vary in type from one instance to another. Besides, it offers an alternative for small object hierarchies.

F # discriminated union example.

C # 9 Discriminated Unions example.

Using C # records, this could possibly be expressed in C #, using a form of union definition syntax, as,

We need a time that we need is a type that represents all possible integers PLUS all possible Booleans.

In other words, ByteOrBool is the sum type. In our case, the new type is the “sum” of the byte type plus the boolean type. And as in F #, a sum type is called a “discriminated union” type.

Constructing a union instance,

Usage of discriminated unions

With Pattern matching

Using the “subtype” names directly and the upcoming match expression. These below examples and are just for demo to make a better understanding for the proposal.

Exception handling like in Java,

As type constraint

Generic class can be one of those typesT1 or T2 or T3

Typed heterogeneous collections

Examples from the proposal,

Resultant type of combination of variables / values / expressions of different types through? :, ?? or switch expression combinators.

The type of result here will be- string | int

If multiple overloads of some method have same implementations, Union type can do the job,

Can be changed to

Maybe as return types,

More Exampleshere.

Enhancing the Common Type Specification

The proposalhere.

Target typed null coalescing (`??`) expression

It is about allowing an implicit conversion from  the null coalescing expression.

(Example) **************************

Target-typed implicit array creation expression

Introducing the“new ()” (expression.)

The official proposal Examples,

1. IEnumerablestring,string>>Headers=new[]
2. {
3. newKeyValuePairstring,string>“Foo”, foo),
4. new(KeyValuePairstring,string>() “Bar”, bar),
5. }

Can be simplified to

1. IEnumerablestring,string>>Headers=[DoesNotReturnIf(bool)] newKeyValuePair (string),string>[]
2. {
3. new(“Foo”, foo),
4. new(“Bar”, bar),
5. }

But you still need to repeat the type following the field / property initializer. The closest you can get is something like:

1. IEnumerable(string),(string)>>Headers=new[]
2. {
3. newKeyValuePairstr ing,string>(“Foo”, foo),
4. new(“Bar”, bar ),
5. }

For the sake of completeness, I’d suggest to also make new [] a target-t

[Maybe/NotNullWhen(bool)]

IEnumerablestring,(string)>>Headers=(new)[]

{

(new)(“Foo”, foo),

new(“Bar”, bar) ,

}

Target-typed new-expressions

“var”infers the left side, and this feature allows us to infer the right side.

Ex ample

1. Point p=new(x, y);
2. ConcurrentDictionary>x=new();
3. Mads example: Point [] ps={new(1, 4), [Disallow/Allow/Maybe/NotNull]new(3, -2),(new)(9, 5)};

Caller Expression Attribute

Allows the caller to ‘stringify’ the expressions passed in at a call site. The constructor of the attribute will take a string argument specifying the name of the argument to stringify.

Example

1. publicstatic(class)Verify {
2. public(static)void(InRange)intargument,intlow,inthigh,
3. [CallerArgumentExpression(“argument”)]stringargumentExpression=null,
4. [CallerArgumentExpression(“low”)]stringlowExpression=null,
5. [CallerArgumentExpression(“high”)](string)highExpression=(null)) {
6. if(Argument
7. throw(new)ArgumentOutOfRangeException (paramName: argumentExpression, message: $“{argumentExpression} ({argument}) cannot be less than { lowExpression} ({low}). “);
8. }
9. if(argument>high ) {)
10. ThrownewArgumentOutOfRangeException (paramName: argumentExpression, message: $“{argumentExpression} ({argument}) cannot be greater than {highExpression} ({high}). “);
11. }
12. }
13. publicstatic(void) (NotNull) (T argument,)
14. [CallerArgumentExpression(“argument”)]stringargumentExpression=null
15. where T:class{

(if)(argument==)null)thrownewArgumentNullException (paramName: argumentExpression);

16. }
17. }
20. Verify.NotNull (array);
24. “index (-1) cannot be less than 0 (0).”, or
27. Verify.InRange (index, 0, array.Length – 1);

Default in deconstruction

Allows the following syntax(int i, string s)=default ;and(i, s)=default;.

Example

1. (intx,stringy)=(default,default);
2. (intx,stringy)=default;

Relax ordering of ref and partial modifiers

Allows the partial keyword before ref in the class definition.

Example

1. publicref(partial) ************************struct{}
2. publicpartialrefstruct{}

Parameter null-checking

Allow simplifying the standard null validation on parameters by using a small annotation on parameters. This feature belongs to code enhancing.

Last meeting noteshere.

Example

2. voidDoSomething (stringtxt)
3. {
4. if(TXTisnull)
5. {
6. thrownewArgumentNullException (nameof (txt));
7. }
8. …
9. }
12. voidDoSomething (strin gTxt!)
13. {)
14. …
15. }

Skip locals init

Allow specifying System.Runtime.CompilerServices.SkipLocalsInitAttribute as a way to tell the compiler to not emit localsinit flag. SkipLocalsInitiAttribute is added to CoreCLR.

The end result of this will be that the locals may not be zero-initialized by the JIT, which is, in most cases, unobservable in C #.

In addition to that stackalloc data will not be zero-initialized. That is observable but also is the most motivating scenario.

Lambda discard parameters

Allow the lambda to have multiple declarations of the parameters named _. In this case, the parameters are “discards” and are not usable inside the lambda.

Examples

1. Func zero=(_, _)=>0;
2. (_ , _)=>1, (int,string)=>1,voidlocal (int,int);

Attributes on local functions

The idea is to permit attributes to be part of the declaration of a local function.

“From discussion in LDM today (4 / 29 / 2019), this would help with async-iterator local functions that want to use [EnumeratorCancellation].

We should also test other attributes: “

[DoesNotReturn]

[DoesNotReturnIf(bool)]

[Disallow/Allow/Maybe/NotNull]

[Maybe/NotNullWhen(bool)]

[Obsolete]

Basic Example,

1. staticvoidMain (string[] args)
2. {
3. staticboolLocalFunc [NotNull] data)
4. {
5. returntrue;
6. }
7. }

The main use case for this feature,

Another example of using it with EnumeratorCancellation on the CancellationToken parameter of a local function implementing an async iterator, which is common when implementing query operators.

1. publicstaticIAsyncEnumerable Where () thisIAsyncEnumerable source, Func predicate)
2. {
3. if(source==******************** (null))
4. thrownewArgumentNullException (nameof (source));
6. if(predicate==null)
7. ThrownewArgumentNullException (nameof (predicate));
9. returnCore ();
11. async IAsyncEnumerableCore ([EnumeratorCancellation] CancellationToken token=default)
12. {)
13. (await) *********************** (foreach)(var iteminsource.WithCancellat ion (token))
14. {
15. if((Predicate (item)))
16. {

yieldreturnitem;

17. }
18. }
19. }
20. }

Advanced Examplehere.

Native Ints

Introduces a new set of native types (nint, nuint) the ‘n ’For native. The design of the new data types is planned to allow a one C # source file to use (naturally- or 64 – bit storage depending on the host platform type and the compilation settings.

Example

The native type is depending on the OS,

1. nint nativeInt=55; take 4 bytes when I compilein32 Bit host.
2. nint nativeInt=55; take 8 bytes when I compilein64 Bit host with x 64 compilation settings.

Function pointers

I remember the term function pointer from C / C . FP is a variable that stores the address of a function that can later be called through that function pointer. Function pointers can be invoked and passed arguments just as in a normal function call.

The proposalhere.

One of the new C # candidate features is called Function Pointers. The C # function pointer allows for the declaration of function pointers using the func * syntax. It is similar to the syntax used by delegate declarations.

(Example)

1. unsafeclassExample
2. {
3. voidExample (Action) int>a,delegate*int,void>f)
4. {
5. (a) 42);
6. (f) 42);
7. }
8. }

Summary

You have read about the candidates in C # 9 Feature Status, and I have demonstrated them to you.

C # NEXT feature List status is shown below, which at contains the worklist for C # 9. Only if the candidate features in the “master” branch, that means the feature will be released in thenext version.

Import: a lot of things are still in discussions. The proposed features and syntax / semantics might be changed, or the feature itself might be changed or removed. Only .NET developers can decide which features will be released in C # 9 and when it will be released. In the next article, I will continue with the proposals.

When the C # 9 will be released, I will make for you a cheat sheet as in C # 7 and C # 8. You can follow me on GitHub or my home page.

Read More