.NET Core Today and Tomorrow
Download as PPTX, PDF1 like133 views
.NET Core 3.0 and 3.1 introduced significant enhancements including cross-platform capabilities, performance improvements, and new features in C# 8 such as nullable reference types and asynchronous streams. The framework supports modern application development across desktop, web, cloud, mobile, gaming, IoT, and AI, and encourages the use of tools like gRPC for high-performance communication. .NET 5 and beyond aim to unify the .NET ecosystem with regular major releases, ensuring long-term support for even-numbered versions.
![Key features - Performance
• Low network usage
• HTTP/2 binary framing and header compression
• Protobuf message serialization
0
100
200
300
400
500
600
700
800
1 2 10 20
Size(bytes)
Serialized items
JSON vs Protobuf Size Comparison
JSON
Protobuf
syntax = "proto3";
package sample;
message Test {
string query = 1;
int32 page_number = 2;
int32 result_per_page = 3;
repeated Ticker tickers = 4;
}
message Ticker {
string name = 1;
float value = 2;
}
{
"query": "myQuery",
"page_number": 42,
"result_per_page": 100,
"tickers": [
{
"name": "rPs",
"value": 9.768923
},
{
"name": "WEo",
"value": 6.067048
}
]
}
https://nilsmagnus.github.io/post/proto-json-sizes/
5052 4920 2a20 4854 5450 2f32
0d0a 534d 0d0a 0d0a 0000 0004
0000 0000 0401 0000 0000 0000](https://image.slidesharecdn.com/whatyouneedtoknowabout-200229144741/85/NET-Core-Today-and-Tomorrow-30-320.jpg)
.NET Core Today and Tomorrow
- 5. .NET Core release overview Top Features in .NET Core 3.0 + 3.1 What’s coming next What to do today
- 6. DESKTOP WEB CLOUD MOBILE GAMING IoT AI .NET Your platform for building anything
- 7. .NET ecosystem momentum Transforming .NET from Closed Source & Windows-only to Open Source & Cross-platform
- 8. June 2016 .NET Core 1.0 March 2017 .NET Core 1.1 Aug 2017 .NET Core 2.0 May 2018 .NET Core 2.1 Dec 2018 .NET Core 2.2 Sep 2019 .NET Core 3.0 Nov 2019 .NET Core 3.1
- 9. .NET Core What’s New?
- 11. What’s New In C# 8
- 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
- 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
- 25. Microservices
- 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
- 30. Key features - Performance • Low network usage • HTTP/2 binary framing and header compression • Protobuf message serialization 0 100 200 300 400 500 600 700 800 1 2 10 20 Size(bytes) Serialized items JSON vs Protobuf Size Comparison JSON Protobuf syntax = "proto3"; package sample; message Test { string query = 1; int32 page_number = 2; int32 result_per_page = 3; repeated Ticker tickers = 4; } message Ticker { string name = 1; float value = 2; } { "query": "myQuery", "page_number": 42, "result_per_page": 100, "tickers": [ { "name": "rPs", "value": 9.768923 }, { "name": "WEo", "value": 6.067048 } ] } https://nilsmagnus.github.io/post/proto-json-sizes/ 5052 4920 2a20 4854 5450 2f32 0d0a 534d 0d0a 0d0a 0000 0004 0000 0000 0401 0000 0000 0000
- 31. Key features - Performance • HTTP/2 multiplexing • Multiple calls via a TCP connection • Avoid head-of-line blocking*
- 32. <Project Sdk="Microsoft.NET.Sdk.Web"> <PropertyGroup> <TargetFramework>netcoreapp3.0</TargetFramework> <AspNetCoreHostingModel>InProcess</AspNetCoreHostingModel> </PropertyGroup> <ItemGroup> <Protobuf Include="Topics.proto" GrpcServices="Server" /> <PackageReference Include="Google.Protobuf" Version="1.23.0" /> <PackageReference Include="Grpc.AspNetCore.Server" Version="2.23.2" /> <PackageReference Include="Grpc.Tools" Version="1.23.0" PrivateAssets="All" /> </ItemGroup> </Project> Key features - Code generation • All gRPC libraries have first-class code generation support syntax = "proto3"; message SubscribeRequest { string topic = 1; } message Event { string details = 1; } service Topics { rpc Subscribe(SubscribeRequest) returns (stream Event); } public abstract partial class TopicsBase { public virtual Task Subscribe( SubscribeRequest request, IServerStreamWriter<Event> responseStream, ServerCallContext context) { throw new RpcException(new Status(StatusCode.Unimplemented, "")); } } public partial class TopicsClient : ClientBase<TopicsClient> { public TopicsClient(ChannelBase channel) : base(channel) { } public virtual AsyncServerStreamingCall<Event> Subscribe( SubscribeRequest request, CallOptions options) { return CallInvoker.AsyncServerStreamingCall(__Subscribe, options, request); } }
- 33. Key features - Multiple languages
- 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
- 37. ASP.NET Core 3.0 SPA Auth
- 39. Web apps with Blazor
- 40. https://... JS
- 41. C#
- 42. C#
- 43. How Blazor WebAssembly works https://... DOM Razor Components .NET WebAssembly
- 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
- 48. • Blazor: https://blazor.net • Docs: https://blazor.net/docs • Workshop: https://aka.ms/BlazorWorkshop • Focus Event: https://aka.ms/FocusOnBlazor • Community: https://aka.ms/AwesomeBlazor Try Blazor today!
- 53. https://github.com/xamarin/MobileBlazorBindings <StackLayout> <Label FontSize="30" Text="@("You pressed " + count + " times")" /> <Button Text="+1" OnClick="@HandleClick" /> </StackLayout> @code { int count; void HandleClick() { count++; } }
- 54. Machine Learning
- 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.
- 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
- 60. .NET 5
- 61. 2014 Many .NETs .NET FRAMEWORK .NET CORE XAMARIN / MONO
- 62. 2014 2016 Many .NETs .NET Standard .NET FRAMEWORK .NET CORE XAMARIN / MONO
- 63. XAMARIN / MONO.NET FRAMEWORK .NET 2014 Next2016 Many .NETs .NET Standard .NET .NET CORE .NET STANDARD
- 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
- 68. What to do today?
- 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
- 70. .NET Framework is supported Use Migration Guides Use C# 8 Today Stay tuned for Build Give Feedback!
- 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
Editor's Notes
- #8: 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
- #10: 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>
- #11: 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>
- #28: -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
- #29: 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
- #30: 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
- #31: 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
- #32: 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.
- #33: 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.
- #34: gRPC is supported in every language -Common set of interop tests -gRPC on .NET Core is continuously tested against other implementations
- #35: 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.
- #36: 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
- #37: 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
- #60: 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.
- #62: 2014 – .NET Framework, .NET Core, Xamarin / Mono Three different frameworks, hard to share code across them
- #63: 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.
- #64: 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.
- #65: .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.
- #68: 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.
- #72: .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