8. The .NET Foundation
.NET API for Hadoop WebClient
.NET Compiler Platform ("Roslyn")
.NET Map Reduce API for Hadoop
.NET Micro Framework
ASP.NET MVC
ASP.NET Web API
ASP.NET Web Pages
ASP.NET SignalR
MVVM Light Toolkit
.NET Core 5
Orleans
MEF (Managed Extensibility Framework)
OWIN Authentication MiddlewareRx (Reactive Extensions)
Orchard CMS
Windows Azure .NET SDK
Thinktecture IdentityManager
WnsRecipe
Mimekit Xamarin.Auth
Xamarin.Mobile
Couchbase for .NET
Meet the people behind the .NET Foundation
http://www.dotnetfoundation.org/teamhttp://www.dotnetfoundation.org
@dotnetfdn
Mailkit
System.Drawing
ASP.NET 5
Salesforce Toolkits for .NET
NuGetKudu
Cecil
MSBuild
LLILC
Prism
WorldWide Telescope
Microsoft Confidential
20. .NET Open Source
• .NET Core: CoreFx and CoreCLR
• Full stack of C#, VB, and F#
21. C# Design Process
• Design meetings up to 4 times a week
• Design reviews once a month
• Proposals and design notes on GitHub
• Prototypes for early feedback
36. Trends to watch for C# 7
• Cloud & devices
• Wire data
• Performance
• Asynchrony
37. Pattern matching
if (o is Point p && p.X == 5) { WriteLine(p.Y); }
if (o is Point{ X is 5, Y is var y }) { WriteLine(y); }
if (o is Point(5, var y)) { WriteLine(y); }
38. Patterns in switch statements
switch (o)
{
case string s:
Console.WriteLine(s);
break;
case int i:
Console.WriteLine($"Number {i}");
break;
case Point(int x, int y):
Console.WriteLine($"({x},{y})");
break;
case null:
Console.WriteLine("<null>");
break;
}
39. Tuple types
public (int sum, int count) Tally(IEnumerable<int> values) { … }
var t = Tally(myValues);
Console.WriteLine($"Sum: {t.sum}, count: {t.count}");
public async Task<(int sum, int count)> TallyAsync(IEnumerable<int> values) { … }
var t = await TallyAsync(myValues);
Console.WriteLine($"Sum: {t.sum}, count: {t.count}");
40. Tuple literals
public (int sum, int count) Tally(IEnumerable<int> values)
{
var s = 0; var c = 0;
foreach (var value in values) { s += value; c++; }
return (s, c);
}
public (int sum, int count) Tally(IEnumerable<int> values)
{
var res = (sum: 0, count: 0);
foreach (var value in values) { res.sum += value; res.count++; }
return res;
}
41. Nullable and non-nullable reference types
string? n; // Nullable reference type
string s; // Non-nullable reference type
n = null; // Sure; it's nullable
s = null; // Warning! Shouldn’t be null!
s = n; // Warning! Really!
WriteLine(s.Length); // Sure; it’s not null
WriteLine(n.Length); // Warning! Could be null!
if (n != null) { WriteLine(n.Length); } // Sure; you checked
42. Local functions
IEnumerable<T> Filter<T>(IEnumerable<T> source, Func<T, bool> predicate)
{
if (source == null) throw new ArgumentNullException(nameof(source));
if (predicate == null) throw new ArgumentNullException(nameof(predicate));
IEnumerable<T> Iterator()
{
foreach (var element in source)
if (predicate(element))
yield return element;
}
return Iterator();
}
43. Other top feature ideas
Shorthand “record” types
Preferably with subclasses
Support immutable records and non-destructive mutation
Extension “everything”
Great partner feature to pattern matching
Typed “views” of wire data
Like TypeScript types? Like F# type providers?
Ref returns and array slices
For performance-critical code
Async collections and streams
Async iterators and async foreach?
Editor's Notes
Description (“what is the .NET Foundation”)
The .NET Foundation is an independent organization created to foster open development and collaboration around the growing collection of open source technologies for.NET. It will serve as a forum for commercial and community developers alike with a set of practices and processes that strengthen the future of the .NET ecosystem.
Story telling (“why the .NET Foundation”)
Three years ago we announced how some key components of .NET such as ASP.NET MVC or Entity Framework embraced a new development process that was more transparent, open, and community driven. Since then, we have only received great feedback from you. Increasing our investments in .NET, while opening the process to the community has allowed .NET to innovate faster with feedback and contributions. With the .NET Foundation we want to extend this new development model to be the norm for .NET and not the exception. We want to make sure that .NET projects (both from Microsoft and from other companies and individual contributors) have a place that provides the mechanisms to promote the openness, community participation and rapid innovation to build the next generation of the .NET ecosystem.
There are currently 31 projects and 81 repositories in the .NET Foundation. http://www.dotnetfoundation.org/projects
Check dotnet.github.io for up to date stats and update slide!
.NET Foundation foster openness, community and rapid innovation around .NET by providing legal protection, open practices & support as well as visibility to projects. The frameworks for these pillars will be defined by the advisory council and board of directors.
Messaging pillars (“what are the top three things I need to know about the .NET Foundation”)
It opens the development process for .NET: The .NET Foundation brings into one common umbrella existing and new relevant open source projects for the .NET platform, such as .NET Core, ASP.NET and .NET Compiler Platform (“Roslyn”). The .NET Foundation will provide the frame for making this the norm moving forward, so more and more components and libraries of .NET are using an open process that is transparent and welcomes your participation.
It encourages customers, partners and the broader community to participate: The .NET Foundation will foster the involvement and direct code contributions from the community, both through its board members as well as directly from individual developers, through an open and transparent governance model that strengthens the future of .NET.
It promotes innovation by a vibrant partner ecosystem and open source community: The .NET Foundation will promote commercial partners and open source developers to build solutions that leverage the platform openness to provide additional innovation to .NET developers. This includes extending .NET to other platforms, extending Visual Studio to create new experiences, providing additional tools or extending the framework and libraries with new capabilities.
Call to action: Join the conversation
We are in the process of defining the advisory council with the community and getting the .NET Foundation activities off the ground. We’ve been taking feedback from the community from the start. Join the conversation on our forums at forums.dotnetfoundation.org. Meet the team behind the foundation at dotnetfoundation.org/team
Getter-only auto-properties (can also be set from the constructor)
Expression-bodied methods and properties
Using static
Null-conditional
String interpolation
Expressions, full IntelliSense & refactoring support in the holes.
Nameof
Index initializers
Exception filters & await in catch and finally
Java: somewhat uncool, great ecosystem, evolving again
“Systems”: performance-productivity-reliability triangle
“Functional”: Decidedly cool, and on the right side of history, but also elitist
“Compute”: captures lots of cloud cycles
JavaScript: it’s everywhere, getting better, and is helped by TypeScript
Swift: captive audience, mainstreaming advanced features, has lots of mindshare
Wire data: untyped, semi-structured; translating to strong types is expensive and lossy; bad match for OO: functions are not on the inside of the objects.
Perf: devices get smaller; in the cloud, time and space are money
Async: latency must be taken into account; current model deals with single values, not with collections that can be asynchronously enumerated