>> Hi, I'm Scott Hunter.
I'm here today to talk about .NET Core 3,
which you can now use with Visual Studio 2019 RTM.
We consider .NET to be
your platform for building any type of application,
whether that's Desktop or Web.
We've added Cloud, mobile,
gaming, IoT, and AI.
Today, I'm here to talk about.NET Core 3.
We have a preview available now that runs on Visual Studio
2019, .NET Core 3 adds the ability to build WinForm,
WPF applications on.NET Core.
It gives the Desktop Developer flexible deployment,
side-by-side single EXE.
For web, we have a whole bunch of new technologies around;
building client applications, using Razor components,
using gRPC, and much more.
We have significant performance improvements.
.NET core has always been fast or making it faster.
We have new C# language features to make you more
productive and have less errors in your code.
Also,.NET Core always been our open source platform.
So as we bringing the Desktop platforms,
WinForms and WPF to.NET Core,
we've also made them open source,
all the code is on GitHub for you to
check out and contribute back to us.
Let's talk about the journey from.NET Core 2 to.NET Core 3.
With.NET Core 1 and 2, we primarily had
Web and Cloud application types in.NET Core.
We're vastly expanding the applications
you can build the.NET Core 3.
Now, you'll be able to build Desktop applications
with WinForms and WPF.
IoT applications running on
Raspberry Pi's and small devices and with ML.NET,
full support for Machine Learning in AI,
all in.NET Core 3.
Our big themes with Core 3 are,
we want to build great desktop applications.
So we've got WinForms, WPF,
we brought Entity Framework 6,
all the things make it easy to
put your Desktop application to .NET Core.
We live in a world of ML and AI.
We have a great library called
ML.NET that will ship as part of that .NET Core 3 as well.
Then, the web is the web.
We want to make sure
that we're the best platform for building web.
So we have a bunch of new features in the web space.
So let's start drilling into a few of these. The first is Desktop.
First off, we want to make sure
that as you build these desktop applications,
you can use all of our frameworks.
So we have a new feature called XAML Islands.
You can take all of the controls in UWP.
These are the touch-enabled controls,
and you can now host them directly in
your WinForm and WPF application.
Imagine, if you want to sign with
your finger in an expense report application.
Maybe you want to use the newer browser
or the newer media player in your WinForm,
WPF application, you can now drag those
in and use those directly in those applications.
And as monitors get bigger with 4K and 8K,
we want to add a better support for high DPI.
We want these Desktop applications
to be able to access all the Windows in APIs,
take advantage of the latest features
of the Windows operating system.
All these Desktop features are also
available in .NET Framework 4.8 as well.
Why Core? Why do you
want to move your Desktop application to Core?
There's a variety of reasons.
.NET Core is our modern.NET,
it's the fastest moving version .NET with all the latest features.
So, you get a bunch of cool enhancements.
You get side-by-side.
A developer could build
a WinForm application with.NET core using the latest version
of.NET Core and not worry about having
your IT team install a new version of.NET Framework.
You can install that.NET Core either machine
wide or as part of your application, and even better.
What if you don't want to install it at all? Check a box.
We give you a single EXE, copy the EXE to the machines,
and they'll run with no.NET Core installed at all.
So you can use the latest versions,
the latest features in
your application without installing anything on the host OS.
The runtime in APIs because.NET Core side-by-side,
we've been able to actually take
some of the APIs and enhance them to become
faster without worrying about
breaking the compatibility of the applications.
So by moving to.NET Core,
you get our latest BCL with
the latest features performance
because we've actually modified
some of these APIs, they are just faster.
We see typically about 30 percent improvement
when you move an app from.NET Framework.NET Core.
So those are all great reasons to move
your Desktop application to Core.
The next thing as I said, .NET
core has the latest versions of all of the technologies.
C# 8, one of the biggest feature pack versions of C# in awhile,
brings a variety of cool features.
I'm going to show a few of them here quickly.
Ranges; you can see under my get customer Async,
I pass in something and I basically can give it a range.
Instead of giving it the full array, I can say,
''Take this subset of that array and pass that into that method.''
Nullable reference types.
This is one of my favorite features.
We all have applications that we get null exceptions in,
because we didn't do the right null checks.
By enabling this, in C# 8,
it will actually force you to put
the question mark next to your customer there,
because it could be null, and it could not be null.
You can see later down there,
if name not equal null,
if the compiler will actually enforce
you to do the right null checks for it.
We introduced Async await,
years and years ago.
When we did, it could return a single type.
Now with C# 8,
Async can return a collection at IEnumerable of types.
For the first time ever, you can return more than one value
from an Async method so that Async streams.
We get switch expressions, recursive patterns,
and a lot more as part of C# 8,
but there's a lot of productivity improvements there.
The next thing is.NET Standard..NET Standard is
the contract that all.NETs must implement.
That makes it easy to share APIs across all the.NETs.
With.NET Core 3, we're introducing.NET standard 2.1.
What you see here is that basic taking,
many of those new features,
the index in range,
the IAsyncEnumerable, Span of T,
which we had in the previous version of .NET
Core and making them available as part of the standard,
we're adding these to the BCL types..NET Standard 2.1 will be
available across the XAML platform and the.Core platform.
It will not be supported on.NET Framework.
We don't expect you to move the.NET Standard 2.1 right away.
Maybe a year or so,
after.NET Core 3 is out.
We have lots of developers on.NET 3 will be the time,
but you can see we're continuing to
take the standard and improve it.
Next thing, ASP.NET..NET Core
cannot just be all about
Desktop,.NET Core 3 can't be all that Desktop.
It needs to have web as well.
So we have some amazing improvements in ASP.NET, we have gRPC.
Today, we have ASP.NET
Web API for building RESTful APIs using JSON,
but a lot of our customers enjoy having contracts which
tightly define the types that can be passed via an API.
Because these contracts can also
be binary, you get high performance.
So this is giving you high performance RPC contract
based APIs in.NET Core.
The cool thing about gRPC is
because it's a standard implementation,
it works across a variety of languages.
So it's supported on Java,
Node, and many other other platforms.
This means if you build a gRPC endpoint
in your.NET Core Application,
you can call it from a variety of languages.
At the same time, you can actually call
a GRC endpoint from .NET
if it's written in Java or something else as well.
So it gives you full winter interoperability
between all of these platforms. Worker Service.
ASP.NET has always been associated with UI,
whether it was Web Forums, or NBC,
or Razor pages, we had Web API,
but we really haven't had
a great starting point for
building micro service style applications.
So we're adding a Worker Service templates.
This template is for building something that
might run for a long time in the background,
or might listen for a message
coming in from something like Azure Service Bus.
We've got a great template for building
these types of applications
that still gives you all the great features of.NET Core;
dependency injection, log in,
and our high-performance web server on the back end.
The next thing is Azure building these APIs, these Web APIs.
We know that one of the hardest parts is securing these things.
So we're going to make it very easy to partner
with the open-source and this server project,
and use that technology to secure your APIs.
We also have a really cool feature
in ASP Core 3 called Razor Components.
You might have heard of this as
Blazer in some of the talks we've done before.
What this lets you do is build client UI in C#.
You no longer have to actually depend on a library like;
AngularJS, React or Vue.
You can instead take advantage of all the capabilities of C#.
For example, you can have a C# object on the server,
and you can pass it to the client,
and you get that strong type all
the way across both of these things.
You might ask how we do this.
We can run this on the server side
and have a JavaScript library on
the client that actually does the interrupt or even better,
we have something called Web Assembly.
This is a mechanism where you can
compile .NET into pretty much native IL.
So when it runs in the browser,
it runs at full native speed in the browser.
It requires no plug-ins.
All the browsers support this,
the mobile browsers and the desktop browsers.
Even better, this Web Assembly runs in the Sandbox of the browser.
So this is not like Active X,
or Flash, or any of the plugin technologies.
It's safe, stays within the context of the browser,
gives you that native performance.
This will give you the ability to build
awesome spy applications chest using C#.
So you see a lot of the exciting new things in .NET Core 3.
.NET Core 3 will not ship as part of Visual Studio 2019.
It'll ship later this year.
At the Microsoft Build Conference in May,
will actually announce the RTM date,
but because you're running Visual Studio 2019,
you can try the preview today
without hurting any of your existing applications.
So please, grab the preview, try it,
and send us feedback.
[MUSIC]