The .NET of Tomorrow

Ed Charbeneau(http://developer.telerik.com/featured/the-net-of-tomorrow/)

---

Exciting times lie ahead for .NET developers. During Build, Microsoft’s biggest developer event of the year, clear roadmaps were given on the future of .NET and C#. Microsoft is re-positioning .NET to be a platform that can be written anywhere and run anywhere, which is a departure from it’s long history of proprietary technologies.

Frameworks and Libraries
.NET TODAY
.NET TOMORROW
The Language of the Future is C#
ROSLYN
Conclusion

Microsoft is also reinventing itself in other ways too, like its developer tooling and the way it communicates with developers in general. This more open nature of Microsoft has even started to win over even the most skeptical of developers, such as my co-worker Cody Lindley, which you can see in his latest article, “What Has Microsoft Done For You Lately?”.

So what does all this mean for .NET developers? A well thought-out roadmap from Microsoft showing the strategy for the future of .NET. In this post, we’ll take a look at what that roadmap is.

Frameworks and Libraries

The state of .NET today is a little scattered. Restructuring projects always seem to make them worse before they get better, and this is no different. The road ahead has been a bit fuzzy since the introduction of .NET Core and perhaps got a little fuzzier with the recent announcement adding Xamarin to the mix.

While these are exciting times, they are unclear and uncertain for developers.

.NET TODAY

With the current structure of .NET, creating code that spans across different Microsoft platforms means working with portable class libraries (PCL). The PCL has shared functionality, but is very limited when compared to the .NET framework and understanding how the PCL is supported on various platforms is less than straightforward. In addition, working across the complete .NET ecosystem means working with up to three different base libraries: Base Class Library (.NET Framework), .NET Core, and Mono Class Library (Xamarin). Developer fatigue really begins to set in when trying to grasp which APIs are available for a given scenario.

.NET TOMORROW

Thankfully Microsoft understands the issue at hand and has a clear vision of how .NET things will work in the .NET of tomorrow. A big part of this strategy is to deprecate the PCL and replace it with a contract for common API support. This new contract will be called the .NET Standard Library. The .NET Standard Library will also include a specific set of reference assemblies that all .NET Platforms must support, known as the .NET Platform Standard.

The .NET Standard Library decouples the application models from the base libraries and tooling. This decoupled scenario allows for better code reuse and a shorter learning curve. Having a decoupled approach also means that the .NET Standard Library can be updated with less friction (aka breaking changes), this will mean more innovation at a faster pace. As the .NET Standard Library API surface increases with newer versions, some platforms will be left behind and become legacy. The upside is that new and yet to be created platforms have a clear foundation to build upon.

With the following table it’s easy to see that an ASP.NET Core 1.0 application has access to the full .NET Platform Standard version 1.5 APIs. In the same regard, Windows Phone 8.1 would not have access to APIs added to the standard after version 1.2.

The Language of the Future is C#

Since C# is the most popular language in .NET, it’s necessary to include it in the conversation. While C# is a very mature language, it has an exciting future as well. Much like the .NET framework, C# is being developed as an open source project. Now that C# is open source, its development will be visible to the public, including the roadmap.

Much like with the .NET Standard Library, Microsoft is promising a faster release cycle with C#. These out-of-band releases will include new language features to further enhance an already robust and mature language. In future releases we’ll see some interesting new ways for developers to write C#.

• Local functions will allow functions inside of methods that will have access to variables in scope.

• Tuples let functions return multiple results. The results can be named so that the code remains readable.
  

  //Local function and Tuples preview
  static void Main(string[] args)
  {
    int[] numbers = { 1,2,3,4,5 };
  
    // Local function
    (int sum, int count) Tally(IEnumerable list)
    {
      var r = (s: 0, c: 0);
      foreach (var v in list)
      {
        r.s += v; r.c++;
      }
      return r; // return Tuple of (int:sum, int:count)
    }
  
    var t = Tally(numbers);
    WriteLine($"Sum: {t.sum}, Count {t.count}"); // => Sum: 15, Count: 5
  
  }

   

• Pattern matching extensions for C# enable many of the benefits of algebraic data types and pattern matching from functional languages, but in a way that smoothly integrates with the feel of the underlying language. Pattern matching is able to switch on the type of data and offers greater flexibility when working with non-primitive data types.
  

  // pattern matching in C#
  var people = {
                new Student("Dustin", "Campbell", 195434) { Grades = { 4.0m, 4.0m, 3.9m, 4.0m, 3.8m, 4.0m }},
                new Student("Mads", "Torgersen", 193845) { Grades = { 2.0m, 2.4m, 3.4m, 1.8m, 3.9m, 0.2m }},
                new Student("David", "Stephens", 230954) { Grades = { }},
                new Professor("Anders", "Hejlsberg", "Programming languages"),
                new Professor("Scott", "Guthrie", "Clouds"),
                new Professor("Scott", "Hunter", ".NET")
              };
  
  foreach (var p in people)
  {
    if (p is Professor { Subject is var s, FirstName is "Scott"})
    {
      WriteLine($"One of the Scotts is teaching {s}");
    }
    if (p is Student { FirstName is var n, Gpa is decimal g})
    {
      WriteLine($"{n} has a GPA of {g}:N2");
    }
  }

   

• Immutable objects are a feature being discussed for beyond C# 7. Immutable objects are an explicit shorthand way of writing immutable classes with the added benefit of the compiler being able to identify them as immutable.
  

  // new up an immutable object
  var p1 = new Point { X = 3, Y = 7 };
  
  // copy p1 to p2 with an X value of negative p1's X value.
  var p2 = p1 with { X = -p1.X }; //=> { X = -3, Y = 7 }

   

ROSLYN

The write anywhere run everywhere strategy of .NET is really apparent with C#. Because of Roslyn, the cross platform compiler as a service, C# can be written and run on any platform. Roslyn enables C# to run in IDEs and editors and opens the door to support from any linter, refactoring tool, and code generation tooling. In the future, expect to see more uses for C# in more places.

Conclusion

.NET is always changing and improving as a platform. Because of the sheer amount of changes happening and the speed at which they are delivered, expect some difficulties along the way. However, gone are the days of Microsoft secrecy, so enjoy the new open development process and transparent roadmaps that have been outlined. There’s an exciting future ahead for .NET, it’s cross platform, open source, and full of features one would expect from a modern set of tools and languages.