C# 7 Feature Preview

[[165106]]

Over the past year, we have shown readers several features that were considered for inclusion in C# 7. With the recent release of Visual Studio 15 Preview, Microsoft has decided to show users these features as part of the final release of C# 7.

Tuple value types

.NET provides a tuple type, but there are various problems when using it in C#. Since the tuple type is a reference type, you are likely to avoid the GC overhead caused by using it in some performance-sensitive code. At the same time, the tuple type is immutable, which makes cross-thread sharing safer, but also means that a new object must be allocated every time a change is made.

To address this, C# 7 will provide a value type tuple. This is a mutable type, which is more efficient for performance-critical code. Also, as a value type, it generates a copy every time it is assigned, so there is little risk of multithreading issues.

You can create a tuple using the following syntax:

 var result = (5, 20);

You can also choose to name the values ​​in the tuple, which is not required, but makes the code more readable.

 var result = (count: 5, sum: 20);

You might be thinking, “Great feature, but I could have written that myself.” But the next feature is the real kicker.

Multiple return values

In C-style languages, returning two values ​​from a function is always a hassle. You can only choose to encapsulate the result into a structure or use output parameters. Like many functional programming languages, C# chooses the first way to provide you with this feature:

 ( int , int ) Tally (IEnumerable< int > list)

As you can see, there is a fundamental problem with using a generic tuple here: we have no idea what each field does. Therefore, C# chooses to name the result through a compiler trick:

 ( int Count, int Sum) Tally (IEnumerable< int > list)

We need to emphasize one point here: C# does not generate a new anonymous type, you still get a tuple, but the compiler will assume that its properties are Count and Sum, not Item1 and Item2. Therefore, the following lines of code are equivalent:

 var result = Tally(list);
 Console.WriteLine (result.Item1);
 Console.WriteLine (result.Count);

Please note that we do not have multiple assignment syntax yet. If such syntax is finally implemented, its usage may be like this:

 (count, sum) = Tally(list);

In addition to providing simple functional functions, the practicality of multiple return values ​​is also reflected in the writing of asynchronous code, because out parameters are not allowed in async functions.

Pattern Matching: Improved Switch Block Syntax

The biggest complaint from VB and functional programmers about C# is that the switch statement in C# is very limited. VB developers want range matching, while developers who are used to F# or Haskell want decomposed pattern matching. C# intends to provide both features.

When pattern matching on types, you can create a variable to hold the result of the cast. For example, when using a switch statement on a System.Object, you can write the following code:

 case   int x:

If the object is a numeric type, the variable x will be assigned a value. Otherwise, the program will check the next case statement block from top to bottom. If you want to match more specifically, you can also use range checking:

 case   int x when x > 0:
 case   int y:

In this example, if the object is a positive integer, then the x code block will be executed. If the object is 0 or a negative integer, then the y code block will be executed.

If you need to check for null value, then just use the following syntax:

 case   null ;

Pattern matching: breaking it down

So far, we've only shown incremental improvements to features already in VB, but the real power of pattern matching comes with decomposition, which allows you to completely tear an object apart. Consider the following syntax:

 if (person is Professor {Subject is var s, FirstName is   "Scott" })

This code accomplishes two things:

1. It creates a local variable s and assigns it the value of ((Professor) person).Subject.
2. It performs an equality check ((Professor) person) .FirstName == "Scott" .

If we rewrite it in C# 6 code, it would look like this:

 var temp = person as Professor;
 if (temp != null && temp.FirstName == "Scott" )
 {
 var s = temp.Subject

We expect to see both of these improvements to switch blocks in the final release.

Reference Return

Passing a large data structure by reference is much faster than passing it by value, which requires copying the entire structure. Similarly, returning a reference to a large data structure can also improve speed.

In languages ​​like C, you can return a reference to a structure through a pointer. This approach brings a common problem, that is, the memory pointed to by the pointer may have been reclaimed for some reason.

C# sidesteps this problem by using references, which are pointers with additional rules. The most important rule is that you cannot return a reference to a local variable. If you try to do so, the stack information referenced by the variable becomes inaccessible when the function returns.

In Microsoft's demonstration code, the reference it returns points to a structure in an array. Since it is essentially a pointer to an element in the array, the array itself can be modified later. For example:

 var x = ref FirstElement (myArray)
 x = 5; //MyArray[0] now equals 5  

The use case for this syntax is highly performance-sensitive code; in most applications there is no need to use this feature.

Binary Literals

This release also introduces a small feature, binary literals. The syntax is just a simple prefix, for example, 5 can be represented as "0b0101". The main use cases for this feature are setting flag-based enumerations and creating bitmasks for interoperability with C-style languages.

Local Functions

A local function is a function defined within another function. At first glance, local functions seem to be just a slightly better syntax than anonymous functions. But they actually have several advantages:

• First, you don't need to allocate a delegate to hold the function. This not only reduces memory pressure, but also allows the compiler to inline the function.
• Secondly, when creating a closure, there is no need to allocate an object for it, because it can directly access local variables. This can also improve performance because it also reduces the pressure on GC.

Following the second rule, you cannot create a delegate to a local function. This is actually an advantage for code organization because you don't have to create a separate function and pass the state of an existing function as an explicit parameter.

Improvements to some classes

***The demonstrated feature is a new way to handle partial classes. In the past, the application of partial classes was based on the concept of code generation first. The generated code would contain a series of partial methods that the developer could choose to implement to adjust the behavior of the class.

With the new "replace" syntax, developers have a new option to write code in the most direct way, then introduce code generators and rewrite these methods. The following will show the developer's code writing method through a simple example:

 public   string FirstName { get ; set ; }

It is simple and clear, but it is totally inconsistent with the writing style of XAML style application. Therefore, the code generator will generate the following code:

 private   string m_FirstName;
 static   readonly PropertyChangedEventArgs s_FirstName_EventArgs = new PropertyChangedEventArgs ( "FirstName" ) 
 
 replace public   string FirstName {
 get {
 return m_FirstName;
 }
 set {
 if (m_FirstName == value)
 return ;
 m_FirstName = value;
    PropertyChanged?.Invoke ( this , m_FirstName_EventArg);
 }

With the "replace" keyword, the generated code will directly replace the handwritten code, adding the missing functionality. In this example, we can even handle some of the cumbersome parts that developers often overlook, such as caching EventArgs objects.

Although this official example is only used for property change notification, this technique can also be used in various "aspect-oriented programming (AOP)" scenarios, such as injecting logging, security checks, parameter validation, and other tedious boilerplate code into the code.

If you want to see these features in action, you can watch the Channel 9 video “The Future of C#”.