There’s a lot of exciting new stuff in .NET Core, and more on the way! We’ll take a look at some top features in 3.1, including Blazor, desktop support (WPF and Windows Forms), single file executables, language features, and more. We'll also take an early look at what's on the way in .NET 5, and how you can start planning for it today.
12. Safe
Nullable and non-nullable
reference types help you write
safer code
Declare your intent more clearly
Modern
Async streams for modern
workloads like cloud & IoT
communication
Easily work with cloud scale
datasets using indexes and
ranges
Productive
Write less code using patterns
Protect data with readonly
members
Improved using statements for
resource management
13.
14.
15.
16.
17.
18.
19. Readonly members
Default interface
methods
Pattern matching
(Switch expressions,
Property & Tuple
patterns)
Positional patterns Using declarations
Static local
functions
Disposable ref
structs
Nullable reference
types
Asynchronous
streams
Indices and ranges
Null-coalescing
assignment
Unmanaged
constructed types
Stackalloc in nested
expressions
Enhancement of
interpolated
verbatim strings
https://aka.ms/new-csharp
21. Deployment Flexibility
Side-by-side deployment, self-
contained EXEs
Install machine global or app local
framework
Windows 10
Access modern Windows 10
APIs from WPF and WinForms
Use native Windows 10
controls via XAML islands
Open Source
WPF and WinForms projects
also open source on GitHub
Take advantage of
performance, runtime and API
improvements happening in
.NET Core
26. gRPC
High performance contract-
based RPC services with .NET
Works across many languages
and platforms
Worker Service
Starting point for long running
back processes like Windows
Server or Linux daemon
Producing or consuming
messages from a message
queue
Web API’s + Identity
Add security and authentication
to Web API’s
27. gRPC is…
• Popular open source RPC framework
• Largest RPC mindshare
• Cloud Native Computing Foundation project
• gRPC stands for gRPC Remote Procedure Calls
• Built with modern technologies
• HTTP/2
• Protocol Buffers
• Designed for modern apps
• High performance
• Platform independent
+ =
28. Protobuf (aka Protocol Buffers)
• IDL (interface definition language)
Describe once and generate interfaces for
any language
• Service model
Service method and structure of the
request and the response
• Wire format
Binary format for network transmission
syntax = "proto3";
message SubscribeRequest {
string topic = 1;
}
message Event {
int32 id = 1;
string details = 2;
}
service Topics {
rpc Subscribe(SubscribeRequest)
returns (stream Event);
}
5052 4920 2a20 4854 5450 2f32
0d0a 534d 0d0a 0d0a 0000 0004
0000 0000 0401 0000 0000 0000
29. Remote Procedure Calls vs HTTP APIs
• Contract first (proto file) • Content first (URLs, HTTP method, JSON)
• Contract is designed for humans
• Hides remoting complexity
• Content is designed for humans
• Emphasises HTTP
HTTP APIsRemote Procedure Calls
Performance
Developer productivity
Widest audience
Ease of getting started
34. Key features - Streaming
• gRPC uses HTTP/2 to enable streaming
35. Disadvantages – Limited browser support
• Browsers have great HTTP/2 support
• Browser JavaScript APIs haven’t caught up
• gRPC-web provides limited support for calling gRPC services
36. Disadvantages - Not human readable
• HTTP/2 and Protobuf are binary
protocols
• Additional tools required to
debug calls
BloomRPC
44. Blazor on client or server
https://...
DOM
Razor Components
.NET
WebAssembly
https...
DOM
.NET Core
SignalR
Blazor WebAssembly Blazor Server
Razor Components
.NET
.NET Core 3.0May 2020
45. Blazor on client or server
Blazor WebAssembly Blazor Server
.NET Core 3.0May 2020
46. Build your own pizza store UI with Blazor
https://aka.ms/blazorworkshop
55. Built for .NET
developers
Create custom ML models using C#
or F# without having to leave the
.NET ecosystem
Custom ML made
easy with AutoML
Visual Studio Model Builder
and CLI make it super easy to
build custom ML Models
Extended with
TensorFlow & more
Leverage other popular ML
frameworks (TensorFlow,
ONNX, and more)
56. dot.net/ml
Product recommendation
Recommend products based on purchase history
using a matrix factorization algorithm.
Sentiment analysis
Analyze the sentiment of customer reviews
using a binary classification algorithm.
Price prediction
Predict taxi fares based on distance traveled
etc. using a regression algorithm.
Customer segmentation
Identify groups of customers with similar
profiles using a clustering algorithm.
Spam detection
Flag text messages as spam using a binary
classification algorithm.
Image classification
Classify images (e.g. broccoli vs pizza) using
a TensorFlow deep learning algorithm.
Sales forecasting
Forecast future sales for products using a
regression algorithm.
GitHub labeler
Suggest the GitHub label for new issues
using a multi-class classification algorithm.
Fraud detection
Detect fraudulent credit card transactions
using a binary classification algorithm.
57.
58.
59. Supports Raspberry Pi
and other devices
You can now run .NET Core apps in
small places, including ASP.NET
Read sensor data
& write to displays
New APIs for GPIO pins that
enable using millions of IoT
peripherals
Works with
containers
Deploy apps directly onto
devices or with containers
66. • Web Forms, WCF Server and Windows Workflow remain
on .NET Framework 4.8 only. There are no plans to port
these.
• Recommendations
• ASP.NET Blazor for ASP.NET Web Forms (we will provide a migration guide)
• gRPC for WCF Server and Remoting (we will provide a migration guide)
• Open Source Core Workflow for Windows Workflow (WF):
https://github.com/UiPath/corewf
69. • .NET Core 3.1 LTS
• C# 8 with Nullable Reference TypesNew Development
• Update to .NET Core 3
• Single file publishingWindows Forms / WPF
• Look at Blazor
Web Forms
• Continue running on .NET Framework
• gRPC or CoreWCFWCF
71. .NET 5
INFRASTRUCTURE
.NET STANDARD
.NET – A unified platform
DESKTOP WEB CLOUD MOBILE GAMING IoT AI
WPF
Windows Forms
UWP
ASP.NET Xamarin UnityAzure ARM32
ARM64
ML.NET
.NET for
Apache Spark
72. • .NET Core 3.0 released
• .NET Core 3.1 = Long Term Support (LTS)
July 2019
.NET Core 3.0
RC
Sept 2019
.NET Core 3.0
Nov 2019
.NET Core 3.1
LTS
Nov 2020
.NET 5.0
Nov 2021
.NET 6.0
LTS
Nov 2022
.NET 7.0
Nov 2023
.NET 8.0
LTS
• .NET 5.0 release in November 2020
• Major releases every year, LTS for even numbered releases
• Predictable schedule, minor releases if needed
73. DESKTOP WEB CLOUD MOBILE GAMING IoT AI
.NET
Download .NET Core 3.1 Today!
visualstudio.com/downloads
dot.net/get-core3
Additional data points –
-C# moved from 7th to 5th in TIOBE Language Index 2020
-.NET Core 3 is fastest adopted version of .NET, ever
-dotnet org on GitHub has been top 3 highest velocity projects three years in a row as named by CNCF (see slide 13 for details)
Sources:
https://insights.stackoverflow.com/survey/2019#most-loved-dreaded-and-wanted
https://github.com/cncf/velocity/
https://octoverse.github.com/
https://www.techempower.com/benchmarks/#section=data-r18&hw=ph&test=plaintext
Today we’re going to show you how .NET can be used to build any type of app. We’re going to start with cloud development and microservices.
<CLICK TO NEXT SLIDE>
We’ve added Windows Desktop support with Windows Forms and WPF support. This brings the capabilities of .NET Core to these UI frameworks which millions of .NET developers are building on today. Particularly useful is the flexible deployment with side-by-side and self-contained EXEs so you don’t have to have .NET installed on the machine first anymore.
We also have some exiting new things for Web developers with Blazor, adding full-stack web development with C# and Razor, allowing you to build beautiful and responsive Single Page Apps without having to write JavaScript!
Additionally we have a ton of improvements for building better cloud native, scalable apps and microservices with ASP.NET and of course some exciting C# 8.0 language features.
<CLICK>
-There are alternative RPC frameworks, e.g. Thrift
-Developer community is unifying behind gRPC
-gRPC is run by CNCF. Microsoft contributing to CNCF
-Does not stand for Google RPC
-gRPC is not new, open sourced in 2015
-Union of two technologies, HTTP2 and Protocol Buffers
-Designed for modern apps, particularly microservices
Protocol Buffers serves three purposes:
-Language independent definition of Protobuf messages. Written in proto file that can be shared between apps
-Definition of services for use on server and client
-Binary format of messages. Small and fast, but not human readable
gRPC is an opination contract-first RPC framework
HTTP APIs focus on the shape and content of HTTP (contract optional)
proto files are designed for humans to write and read. Content is binary
HTTP APIs are the opposite: content is human readable. Optional schema is rather verbose
gRPC methods are designed to hide complexity of remoting
Call them like you would a method, no creating HTTP messages or JSON content
A key benefit of gRPC vs REST is small size of requests
-HTTP/2 is binary compared to text based HTTP1
-HTTP/2 supports header compression. Commonly occurring headers, e.g. content-type, are compressed to a few bits per request
-Protobuf is significantly smaller than JSON
JSON is a self describing format – characters are included to differentiate objects/arrays/strings/numbers
Protobuf requires the proto file to make sense of content
Simple comparison between JSON and Protobuf
Protobuf is 30% the size of JSON
Difference reduces to 50% with gzip
HTTP/2 multiplexing makes more efficient use of TCP connections
Multiplexing improves on HTTP1.1 pipelining
-Pipelining requires the order of requests and responses match
-A large image or slow API call may prevent faster requests from completing
HTTP/3 should improve this situation even more.
Code generation is at the core of gRPC
Code generation is driving by Protocol Buffer IDL
Example
-Simple server streaming call
-csproj references proto file in ProtoBuf item
-Grpc.Tools has targets to generate .NET types at design time
-Server is a base type that requires implementation
-Client is strongly typed, created with channel that specifies the server location
Proto files can be shared between servers, and languages.
gRPC is supported in every language
-Common set of interop tests
-gRPC on .NET Core is continuously tested against other implementations
HTTP/2 has excellent streaming support
gRPC uses HTTP/2 streaming to enable message streaming
Unary. Like REST. Single request, single reply
Server streaming is initiated with a request, returns a stream of responses. Example, subscribing to updates.
Client streaming is the opposite: stream requests, finish with response. Example: uploading data
Bi directional stream is streaming in both direction. Example: chat room
gRPC streaming is a really easy way to create realtime services.
Wow, gRPC is great, lets throw REST and JSON away
There are some drawbacks to gRPC
-Modern browsers have great support for browsing HTTP/2 websites
-But browser JavaScript APIs for making HTTP requests haven’t caught up
-JavaScript’s XMLHttpRequest and fetch do not provide low level access to HTTP/2 frames
-Not possible to build a gRPC client in the browser
Workaround today is gRPC-web
-Built by the gRPC team
-Provides limited support for calling some gRPC services over HTTP1
-A server proxy then translates between gRPC-web calls and normal HTTP/2 gRPC
-Does not support bi-directional streaming
HTTP/2 and Protobuf are small and fast
-But they’re not human readable
-Binary, and properly reading a gRPC message requires the proto file
Additional tools are required to debug gRPC calls
-Here I am reading a gRPC TCP packet in Wireshark. It has some support for gRPC
-It can recognize a gRPC packet from content-type headers
-It can see that this is a response for a the SayHello method
-gRPC message is still mostly binary
There are workarounds. Most gRPC services use protobuf, but JSON can be used during development
Clarify that we support ARM32/ARM64 (that’s for the Pi and friends) but also x64 for devices that need more horse power. This matches the IoT edge offering
We offer a new API, in this package: https://www.nuget.org/packages/System.Device.Gpio. Supports GPIO, PWM, SPI and I2C.
2014 – .NET Framework, .NET Core, Xamarin / Mono
Three different frameworks, hard to share code across them
2016 – Introduce .NET Standard - can write libraries that run on all the .NET’s.
While all .NET’s must implement the same API’s, their implementations are different. The Runtimes are different.
2019 – Introduce .NET 5 – Windows, Mac, Linux, Android, IOS all run .NET Core’s runtime
Same BCL used on all platforms, same runtime used on all platforms
Native code compilation on all platforms, by merging .NET Native and Mono AOT
JIT and AOT Runtime
.NET 5 is the next major version of the .NET Platform that brings technologies from .NET Framework, .NET Core and & Mono runtimes and frameworks together into one .NET platform.
.NET 5 will have one Base Class Library (BCL) that will contain APIs for building any type of application. All .NET workloads are supported with application frameworks including cross-platform web development with ASP.NET, iOS and Android mobile development with Xamarin, Windows Desktop, and cross-platform IoT.
.NET 5 will have both Just-in-Time (JIT) and Ahead-of-Time (AOT) compilation models for the multiple compute and device scenarios it must support. JIT has better performance for server and desktop workloads as well as development environments. AOT has better startup, a small footprint, and is required for mobile and IoT devices.
.NET 5 will also have one unified toolchain supported by new SDK project types, will have a flexible deployment model (Side-by-Side and self-contained EXEs) and continue .NET Core's superior performance for server & cloud workloads.
.NET 5 is the evolution of .NET Core, adding the best capabilities of Mono to provide support for small device footprints. .NET Core used the best parts of the .NET Framework as we built its initial release. .NET 5 takes the best of all of the learnings we have across our multiple implementations and brings them together into a single unified platform.
As we add more and more workloads to .NET Core, and continue to innovate and focus on modern platform capabilities, we are at a point where we will be providing only critical updates to .NET Framework. This means that applications running on .NET Framework will continue to run the same as they always have. However, this also means that any new development should be with .NET Core moving forward.
.NET is an entire software development platform that takes care of a lot of the heavy lifting for you when you want to build an application. Applications frameworks help you build the specific types of apps or workloads and enable you to literally build any app for any platform with any operating system. Each .NET workload shares a common infrastructure and base libraries ad .NET Standard. This means not only are your .NET skills portable, but your actual code is portable no matter what you’re building. This makes it easy to share libraries across the breadth of applications people build.
Additionally, there are a broad set of development tools that makes it really productive to write, debug, build and manage code bases.
See: www.dot.net