Diese Präsentation wurde erfolgreich gemeldet.
Die SlideShare-Präsentation wird heruntergeladen. ×

.NET Core Today and Tomorrow

Nächste SlideShare
ASP.NET Core 3.0 Deep Dive
ASP.NET Core 3.0 Deep Dive
Wird geladen in …3

Hier ansehen

1 von 74 Anzeige

.NET Core Today and Tomorrow

Herunterladen, um offline zu lesen

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.

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.


Weitere Verwandte Inhalte

Diashows für Sie (20)

Ähnlich wie .NET Core Today and Tomorrow (20)


Aktuellste (20)


.NET Core Today and Tomorrow

  1. 1. https://live.dot.net
  2. 2. .NET Core release overview Top Features in .NET Core 3.0 + 3.1 What’s coming next What to do today
  3. 3. DESKTOP WEB CLOUD MOBILE GAMING IoT AI .NET Your platform for building anything
  4. 4. .NET ecosystem momentum Transforming .NET from Closed Source & Windows-only to Open Source & Cross-platform
  5. 5. 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
  6. 6. .NET Core What’s New?
  7. 7. dot.net/get-core3
  8. 8. What’s New In C# 8
  9. 9. 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
  10. 10. 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
  11. 11. Windows desktop apps
  12. 12. 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
  13. 13. Microservices
  14. 14. 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
  15. 15. 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 + =
  16. 16. 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
  17. 17. 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
  18. 18. 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
  19. 19. Key features - Performance • HTTP/2 multiplexing • Multiple calls via a TCP connection • Avoid head-of-line blocking*
  20. 20. <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); } }
  21. 21. Key features - Multiple languages
  22. 22. Key features - Streaming • gRPC uses HTTP/2 to enable streaming
  23. 23. 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
  24. 24. Disadvantages - Not human readable • HTTP/2 and Protobuf are binary protocols • Additional tools required to debug calls BloomRPC
  25. 25. ASP.NET Core 3.0 SPA Auth
  26. 26. Web apps with Blazor
  27. 27. https://... JS
  28. 28. C#
  29. 29. C#
  30. 30. How Blazor WebAssembly works https://... DOM Razor Components .NET WebAssembly
  31. 31. 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
  32. 32. Blazor on client or server Blazor WebAssembly Blazor Server .NET Core 3.0May 2020
  33. 33. Build your own pizza store UI with Blazor https://aka.ms/blazorworkshop
  34. 34. Focus on Blazor https://aka.ms/focusonblazor
  35. 35. • 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!
  36. 36. https://github.com/SteveSandersonMS/WebWindow
  37. 37. 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++; } }
  38. 38. Machine Learning
  39. 39. 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)
  40. 40. 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.
  41. 41. 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
  42. 42. .NET 5
  44. 44. 2014 2016 Many .NETs .NET Standard .NET FRAMEWORK .NET CORE XAMARIN / MONO
  46. 46. https://devblogs.microsoft.com/dotnet/introducing-net-5/
  47. 47. • 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
  48. 48. What to do today?
  49. 49. • .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
  50. 50. .NET Framework is supported Use Migration Guides Use C# 8 Today Stay tuned for Build Give Feedback!
  51. 51. .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
  52. 52. • .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
  53. 53. DESKTOP WEB CLOUD MOBILE GAMING IoT AI .NET Download .NET Core 3.1 Today! visualstudio.com/downloads dot.net/get-core3
  54. 54. https://aka.ms/dotnext-2019-dotnetcore-3

Hinweis der Redaktion

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

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

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

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

    -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