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

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.

     1: //Local function and Tuples preview

     2: static void Main(string[] args)

     3: {

     4:   int[] numbers = { 1,2,3,4,5 };

     5:   

     6:   // Local function

     7:   (int sum, int count) Tally(IEnumerable list)

     8:   {

     9:     var r = (s: 0, c: 0);

    10:     foreach (var v in list)

    11:     {

    12:       r.s += v; r.c++;

    13:     }

    14:     return r; // return Tuple of (int:sum, int:count)

    15:   }

    16:   

    17:   var t = Tally(numbers);

    18:   WriteLine($"Sum: {t.sum}, Count {t.count}"); // => Sum: 15, Count: 5

    19:   

    20: }

   

• 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.

     1: // pattern matching in C#

     2: var people = {

     3:               new Student("Dustin", "Campbell", 195434) { Grades = { 4.0m, 4.0m, 3.9m, 4.0m, 3.8m, 4.0m }},

     4:               new Student("Mads", "Torgersen", 193845) { Grades = { 2.0m, 2.4m, 3.4m, 1.8m, 3.9m, 0.2m }},

     5:               new Student("David", "Stephens", 230954) { Grades = { }},

     6:               new Professor("Anders", "Hejlsberg", "Programming languages"),

     7:               new Professor("Scott", "Guthrie", "Clouds"),

     8:               new Professor("Scott", "Hunter", ".NET")

     9:             };

    10:  

    11: foreach (var p in people) 

    12: {

    13:   if (p is Professor { Subject is var s, FirstName is "Scott"})

    14:   {

    15:     WriteLine($"One of the Scotts is teaching {s}");

    16:   }

    17:   if (p is Student { FirstName is var n, Gpa is decimal g})

    18:   {

    19:     WriteLine($"{n} has a GPA of {g}:N2");

    20:   }

    21: }

   

• 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.

     1: // new up an immutable object 

     2: var p1 = new Point { X = 3, Y = 7 };

     3:  

     4: // copy p1 to p2 with an X value of negative p1's X value.

     5: 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.

作者：蒋金楠
微信公众账号：大内老A
微博：www.weibo.com/artech
如果你想及时得到个人撰写文章以及著作的消息推送，或者想看看个人推荐的技术资料，可以扫描左边二维码（或者长按识别二维码）关注个人公众号（原来公众帐号蒋金楠的自媒体将会停用）。
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

原文链接