ASP.NET Community Standup - ASP.NET Core updates in .NET 6

[Music] [Music] do [Music] [Applause] [Music] and we're live welcome to the asp.net community stand-up i'm john galloway i'm a pm on the.net community team and i have tricked daniel roth into joining me today welcome daniel wait we're live we are live we're live and we're talking about brand new stuff in dotnet six for asp.net core and you've confessed to me you have all kinds of franken bits and something's gonna explode crazily all sorts of unnatural matchings on my uh on my computer yes you know that's part of the fun like that's what community stand up started as and i hope we always stay with some of that like some demo fails should be expected so i'm just setting you up for you hopefully awesome well uh i know you're tight on time after this and i've got some community links so i will jump into those and then we will head over to your awesome exploding demos so sharing out the community links in the chat and let's throw this up on the screen there we go all right so these are community links for today i'm starting off with a big one this is amanda silver and a cast of thousands uh writing this post so this is about our vision for visual studio 2022. there's a lot in this post and this is this is kind of high level like this is looking at some of the things we're aspiring to do in the next release of visual studio so the big one that got people's attentions 64-bit more bits many more number of bits 1600 projects i don't even know what's going on there so so that's exciting there's also some good stuff with uh inclusivity um with with uh designing for accessibility so that is really cool more personalization and then a lot of kind of like the kinds of apps you can build azure cross platform.net um i hear that.net's a thing that's a that that looks it's a big thing i i got i got to give some demos with maui uh friday late friday night or i guess early saturday morning i was speaking romania and i gave a demo on windows on arm running on a macbook with a vm and my head exploded i didn't even know what was happening very nice very nice good stuff yeah and then uh i always have to call so there's all the productivity features um we have a section in here about what we're doing with visual studio for mac really focusing on that uh native ui so moving everything to native mac ui which lights up a lot of stuff for accessibility and and performance and reliability and stuff so wonderful things read the post let us know what you think in the comments uh okay this is cool so tom's continuing a series on c-sharp nine features these are really cool um they're relatively you know short to the point posts uh just digging into the different features and uh it's it's been fun seeing some of these pop up in hacker news and people are saying what is going on c sharp and red hat and all the you know like people late to get the memo about all that stuff um but so init accessors uh and records are super awesome i'm hoping to write some more code soon where i can dig into more record fun uh what else do we have jeff sandquist so he uh tweeted about this new thing so this is every time i've tried to set up aks it's a bit of work there's there's a lot of steps um involved and so he uh he tweeted about this and this is an example microsoft learn uh thing where you can go through and what's nice with this is it'll provision the stuff for you and this is all for free so the the two things that i've run into going through kubernetes on azure is there are a lot of steps in the tutorial a lot of provisioning things and then also it's very easy to leave stuff running and spend some money that you didn't intend to spend so it's nice that this is all provisioned for you and and uh managed and everything and free we're getting some questions john people want to know if dot maui is already is already here like like what is done maui available so dot net maui let me break from the script uh if i go to github swapping live is all about on the phone okay you can start playing with net maui now so these are like the early releases of it it's pretty darn easy to get going with so uh what i did with this is i used maui check and that's it's linked from that readme and you use maui check so it's a global tool and then you just run maui check and it's like magical it goes through and it checks what all is installed and it says notice you don't have this android sdk do you want me to install it for you notice you didn't have this and it just goes through and sets everything up for you so you can start working with maui maui is a feature in net six which is still in preview and if you wanna know more you should check out dot net uh we have regular community stand-ups that have uh that have covered this so they're they're better um we're on live right now it's a bit of inception but uh if you scroll back through previous ones you'll see we've got some maui shows um so i don't know you scroll down a little bit we've had several shows on them and they also link to them in their repo so if you scroll down in here you'll see so david and maddie um and you know just brandon like talking through all the good stuff so yeah this is this is where to keep up yeah maui.net multi-platform app ui it's basically the evolution of xamarin forms for folks that are asking like what is dot maui it's cross-platform uh uiwith.net it's uh evolution of xamarin forms but extend it to desktop scenarios with a modern modernized architecture and yeah you can try it out in preview now like it's it's available with the.net 6 early previews it's still pretty early without it maui so you know just to set expectations like expect some rough rough edges it is available to try now but and and i think the picture in this blog post really kind of sums it up pretty well the idea is writing the same app in xaml mobile desktop running on windows with uh with win ui 3 running on mac with catalysts running all the places so it's um yeah cross-platform client applications which is important for folks asking about vs2022 that's not available in preview yet they just uh posted a vision blog post about what's coming but previously coming soon yep so this is where we're where we're going and read the post so it goes into the details on that all right let me keep moving along i want to give you time for your demos okay so uh laurent talking about accessing dapper secrets using our secret building block using the dapper.net sdk so the scenario he's walking through here is he has twitter api keys that he needs to store and using a dapper sidecar you can then securely access that so he goes through and shows how to set that up shows uh for instance here he's got a secrets json and then shows uh you know starting up configuring the dapper sidecar and then accessing it so pretty cool it's neat to see uh dapper and i'm learning more about how to like think about it as part of a distributed application uh so got a couple of good ones here meaty posts on integration tests so this is integration test using sql server and docker uh sql server is available as a docker image you can see from the scroll bar this is a big post there's a lot of code here there's a lot of walk through yeah so i'm not going to review this entire post i'm going to say it is uh it's very interesting uh there's there's a lot going on it's like i said there's a lot of code it includes all the stuff but the goal here is to be able to run your integration test against a database so not an in-memory database this is a real like you want to test how things are going to run against the sql server instance and the great thing with docker is spin it up run your test kill it you know like just you can spin up a new instance of your uh docker container every every test substantiation so a lot of stuff here great post another in the mini 2 block of integration testing is anthony and he's talking about using calzolari which i probably said wrong which is which is a project he set up for fluent integration tests and so here's his uh the end goal is we're writing integration tests that looks look like this um and so he shows how to go through and set that up uh configuring with any framework fluent assertion assertion.web and x unit so um again anything with with integration tests is usually a pretty non-trivial post and there's there's some stuff uh set up here but as always he includes a link over to his github code and uh nice post all right uh rendering dynamic content in blazer webassembly using dynamic content right so christopher yeah christopher walking through a use case so first he shows uh setting up and displaying a grid that could be templated so he shows a um let me see where's my trying to find here he shows out like writing out multiple things and then he goes through and shows moving that into i'm scrolling way too fast and trying to move through quickly he shows moving that into components so moving those into templates um so that is pretty neat a template i have not done a whole bunch with these template i've looked at code but i have not written templated components they look pretty cool they are yeah you get a little snippet of razor that you can just like stamp out wherever you want in your component yeah it's uh it's a nice feature very nice okay um so andrew has been doing a series on configuration values in asp.net core and some of the things recently has looked at it are things like uh being able to see where your values are coming from like tracing and debugging and understanding them what's interesting here is you may have had a configuration value that's overwritten by something else because it's kind of layered and different it's kind of last one wins uh precedence and so this here he's looking at being able to look up those values so he does a recap of recent blog posts uh looking at this get debug view oops which is on i configuration route so he shows that and then he's shown also using the oakton library that was a previous post which gives you this kind of nicer thing and here he showed doing that from command line so being able to from your startup configure that and view your configuration values and then he shows this beautiful layering diagram and then now he's showing extending all of that and showing the actual overridden values as well so uh need to kind of splunk through and trace all the stuff to make sure that you've actually got all the configuration that's provided so quite a bit here but uh this is definitely useful especially if you're trying to debug why is my configuration value this i expected something else all right and then we're actually these ones are all hoaxes because they were just things i listened to this is you this is your blog host very very nice oh man i wish i still looked like that and that would be nice like probably okay so i'm gonna i'm gonna turn it over to you because you've got a whole slide presentation talking through something i got a whole thing we'll see how much we get through and we'll see how much actually works wonderful yeah so hi everyone um so i'm dan roth program manager on the asp.net team and it's great to be here on the community stand up again uh we're going to be talking about what's coming to asp.net core in dot net six and uh i created this diagram for a different presentation about all this stuff that's in asp.net core it's pretty it's pretty shocking like i remember when when we started with net core 1 you know the first version of a speed on a core it did not look like this but now that we're up to net 5 like asp.net core is your modern web framework for net it's got pretty much everything you need uh to build ui to build backend services under the hood we've got a powerful and flexible hosting model we've got high performance servers with kestrel and iis we support hp sys and of course we got a rich set of built-in middleware that just comes out of the box so a lot of great stuff uh in in ace bit core but of course there's always room to make it better and so that's what we're working on for for net six the next wave of improvements to net web development is coming in net six later this year the work plan for dot net 6 is actually broken down into various themes that are published on a public site on the themesof.net site which happens to be a blazer site by the way um so if you're curious about what our planning is it's actually an open planning that we're doing for dot net six we're trying to be as transparent as possible about what we hope to accomplish of course we'll see how far along we get with that plans always do change but the main themes for dot net six are making it easier for new developers to get started with net expanding support for building cross-platform native client apps with dotnet maui ensuring that.net has everything you need to run natively in the cloud ensuring that enterprises relying on long-term support lts support have a smooth upgrade path dotnet 6 will be our next lts release um we're working on strengthening the.net ecosystem making development with net faster and more productive we'll talk about that today and then lastly just making sure that we continue to deliver on all the promises of the dot-net platform basically finishing all the stuff that we've started and making sure it's good and solid and has a really great experience for developers now asp.net core has a part to play in pretty much all of the.net 6 themes and to make it easier to find all of the asp.net core related work uh we've collected all the relevant github issues into the asp.net core in.net 6 roadmap issue which is linked to from the themes of.net site so you can go to themesup.net and just click on the the aspect core roadmap issue and that will show you all the things that we're working on uh how did we need this what's that let me go back to that real quick okay so the naming is slightly clumsy but people ask us about this all the time and so i just wanna it's asp.net core and net six so it's not dot net core six like we've gone from dot net core three dot net we just went to dot net five and now.net six but the name of the product is still asp.net core the name of the yeah asp.net core is the framework is still named asp.net core all those name spaces are still asp.net core um yeah.net six oh really.net five actually is really.net core like if you're following.net core train.net six was really the next version don f5 was really the next version of net core but we changed the the name to simplify it to really signal that this is the future path like dotnet framework is still there it's in windows and it'll be supported as long as it ships in in windows which there's no plans to ever remove it but there's not ever going to be like a net framework five um the plan is that the future of investmentper.net is on the.net core based stack and so to signal that we call it.5 now and then stop at 6.7 uh that's the the name for the platform but asp.org is a web framework still called asb.net core all right naming is hard right it's one of the hardest problems in computer science well part of the thing way back when we actually announced the original release of what was asp.net core one the original name for it we talked about was asp.net 5. that never happened i know we've if we've gone to all there are erased that all right let's move on to the fun stuff all right cool i just want to make sure you everyone understands how did we decide on this work because i think that's important um the uh we we picked these themes and the specific work items based on feedback from the community from folks like you and we want to continue to invite you to participate not only in the planning process but in the execution process now as we go to implement these features and there's lots of ways that you can participate your your thumbs up on github issues they do matter so please do that if there's an issue that's that's important to you comment on issues with details about your scenarios your requirements how the issue impacts you we do look at that information and evaluate that uh we're going to be you should already be seeing design proposals showing up on the github issues for the work that we're doing in dot net six take a look at those proposals see if it uh if that proposal works for your specific scenarios comment on the implementation prs we want your your feedback there and then of course try out the preview releases.net 6 previews are already coming out they're going to come out every month from now until we ship in november try them out and give us feedback on the actual implementations this is a screenshot of a tool that we actually use internally to rank our backlog for asp.net core and it's it does a ranking based on the github reactions the number of comments and also our best assessment of the issues impact like we look at issues and trying to evaluate like how many users does this impact how blocking is it for those users when they when they hit this and that all gets factored in into into how we look at our backlog now this isn't the only way that we look at our backlog there's other uh factors that come into play but it is an important one and it's one that you you can influence so please give us your feedback comment give thumbs up that's all that's all very very helpful all right with that let's take a look at what's actually coming in.net 6. so getting started with asp.net core in dot-net 6 we want to be easier than it's ever been before we're dramatically simplifying what is required to build your first asp.net core app uh you should be able to build your first app with one file with a single file and just a few lines of code we're simplifying the asp.net core hosting model to make this possible and we're adding support for building apis with minimal effort that don't compromise on features or productivity but still avoid a lot of unnecessary uh ceremony as your app grows you can still evolve to use the well-established patterns that we have today for large maintainable apps all right so let's let's take a look at this let's see what it's what it's going to take now to get started with asp.net core in.net 6. all right so i have um this is visual studio code and i just have an empty folder open uh this is min web app and i'm starting with visual studio code here because we think this is a really natural place for a lot of developers that are new to net and new to asp.net core to get exposed to.net for the first time and i'm i've got dotnet six installed i actually have a build of dot net six preview four which has not been uh shipped yet but uh it's got some new fancy stuff in it that i wanted to take advantage of and i'm just gonna create a new empty web application so dotnet new web that's going to use our empty web app template and we'll let that go ahead and generate all right now you um but for empty uh this doesn't look completely empty and we got this startup file we got these app settings files we got this properties folder and of course visual studio code is kind enough to show me my bin and obj folders let's just delete all that i don't want any of that i want a truly empty app in fact let's go into program cs and we're just going to delete all the code there okay that looks much better that is an empty web application all right now i am going to add one thing back i'm going to do one little thing uh this is won't be necessary when we actually ship this feature is not even actually in the dotnet six builds yet but i'm gonna add up just one package this uh demo is based on the feather hd prototype if you're familiar with that some work by david fowler and a bunch of other folks um that package won't be necessary when we actually ship but at least for now it is so all we've got then is we've got a project that targets.net six got that one package ignore that for now they won't need to be there when we actually ship and an empty program cs file let's go ahead and create our app so app and let's create a web application and hopefully visual studio code will resolve that name space for me it does and we're just going to create it right and then we're going to await app dot run async to run the app and that uh to do it and now i'm going to dotnet watch my application so yeah we're using uh c sharp nine top level programs here to simplify our lives a little bit let's go ahead and open up the browser and you can see we have a running app it doesn't doesn't do anything yet doesn't have any endpoints but it is actually running like we do have a server that is listing on an address with just three lines of code okay and we don't have any endpoints yet so that's why we can't actually hit anything but that is all you're gonna need to build an asp.net core app let's go ahead and add an endpoint so i'm going to app dot map get let's add the endpoint to the root of the application and it looks like based on the intellisense i can add a request delegate here so let's take add a little lambda expression that takes the hp context and we're going to do something with it let's just write to the response stream so response write async i think i need to resolve a namespace for that yep and we'll just say hello hello everyone all right and that should be good document watch is doing its thing and it looks like it started and so now if i refresh the browser okay we now have our first endpoint all right cool so very simple very lightweight um yeah but i mean so the like from some of the chat you know some people are like i don't like the style or whatever but i think there's a real like so obviously like razor pages and npc are still available like if you're writing a a web application in most cases you're going to want to use that sort of thing but oh yeah the stuff that you know yeah is not changing like we we are not going to break anything for the stuff that you know so api controllers having a startup class that factoring you you can grow like you can start like if you're a new user who's never done aspirin core before um getting uh confronted with all those concepts can be kind of overwhelming this is a way to have a like a smoother on-ramp like you just wanna get your first app running you just want to stand up some end points once you get to like you know a couple of uh of resources you're probably going to want to factor those out into something like a controller maybe you decide to factor out your startup logic into a startup class so that's easier to maintain with a larger team and all those things but instead of having that big cliff to jump up in order just to get started this is trying to create a smoother a smoother path cool and web ui actually we'll get there like it's give me some yeah we'll get to why in just a second okay now i'm going to make paula the coding with request delegates is pretty low level like if you're writing an api controller you don't mess around with the http context directly typically um typically you'd actually have like a method that takes no parameters and then maybe you just like return a string right and that would be the simplest way to return some text content and this is actually something that we want to enable with documents so this line of code will work when we ship it doesn't work currently because of a c sharp limitation where c sharp can't actually tell the return type return type of that lambda expression so we we can let's let's uh let me copy yeah but let me uh put this here in a comment just to say that's what we're aspiring to and then let's work around the issue for now this is something that we're actually planning to fix in c sharp 10. so you won't have to do this but for now we do this will come with knit six but for now we're going to add a little workaround to actually cast the return type to function string okay and just to show that this is actually doing something let's change the route to hello and i'm going to browse to slash hello actually let's browse to the root to show that there's nothing there now okay there's nothing at that route if we go to slash hello we're all good okay so that's um what we're trying to head towards and we can do more than just return strings like you want to return obviously complex objects and adjacent and all that stuff so let's define a little record type here let's um do a dog since everyone is getting a dog these days right john have you got your dog yet i don't have a dog quite you know no dog yeah everyone's supposed to be getting dog i don't know i go into something everyone's having to chase their puppies around their house because of that oh god dogs all right let's add another endpoint cap.map get and we'll get a dog like everyone else in the pandemic and we want to have a little lambda expression here that returns a new dog we'll call our dog fluffy and in honor of ryan novak we'll make it a corgi and of course this won't compile yet because of the return type but that's but that's what we're aiming for we want to be able to do this so let's go ahead and comment this out so that we keep in mind what we want to be able to get to and let's have over here let's return oh my gosh can't type uh funk dog just wrap that up okay so we just basically have a lambda expression that's returning a dog and hopefully yeah that should work okay so now we're getting our dog and as you can see it's already being formatted as json automatically we just handle that that stuff for you now you can also uh bind myself a little bit more space you can also bind to like route values and input values um for example let's say instead of just hello we wanted to actually be able to bind to a name here like something like this you know just binding to route values that's pretty normal in asp.net core normally the way you would do that is you would just add a string parameter to your api controller action a string name uh even in a controller action this wouldn't be enough you typically have to attribute it to say that i want this to come specifically from the routes from the route information okay and then over here we would use some like string interpolation to say like hello okay wherever you are right and then now we're returning a string we're taking a string and returning a string so we got to do that work around uh again okay so that's a little a little bit hairy let's remind ourselves what this is supposed to look like we don't want all this stuff we want none none of this funk stuff and in fact i i just thought today that there's even a change where they're working on trying to even get rid of this from route attribute so ideally when you shift down to six it would just be that which looks pretty clean yeah you can see that this still isn't compiling though even with all the the ugly work around stuff and that's because you can't actually add parameter attributes and lambda expressions today that's something again we're trying going to try and fix that in c sharp 10. uh for now we can work around this by using just a local function so i'm going to add a little function here like get message and then i'm just going to copy to copy this thing and put that as the body of my local function great and then we can just pass in the name of our local function here that let's do it oh i'm missing a space dot well goodnight.netwatch.watch says yes okay so we should be able to go to hello and still see hello and now if i go to like slash hello world we get uh finding your route value so you can wow very nice vibes as well that's it i'm not seeing near enough demo fails yet by the way we'll get there i'm sure um that's apis but of course you can do ui as well and the ui model is the same because it's it's really no different um wiring it up is really simple let's say we want to add a razor page to this app razer pages is really nice for getting started because it's just a single cshtml file uh to do a razer page we actually need to add the razer pages services like there's a bunch of services to set up you know the mvc stuff under the covers so we need a builder in that case so let's do web application dot create builder this time and then we'll grab the we get access to the services collection right right here on our builder okay and so now we can add razor pages and for some reason ah there we go so there's a namespace and then down below in our routing information we say app.map razor pages and that's all we need to set up razor pages so now we should be able to go and just you know add a folder and uh let's have the let's add a razor page just call it time.cshtml because everyone knows that the most important razor page is printing out the time on the server every razor page needs to have that page at the top and then we'll just add some html in here i'm putting in all the html headers because i don't have a layout but that's fine and then let's go ahead and put a header that will print date time datetime.now okay and then i think i forgot one thing which is i need to actually build the app now instead of just creating the builder and building the app all in one step i'm going to actually do builder.build and that will create the web application for me and hopefully that will do its thing yup looks like that's good and now we can go to slash time that would be the route and there it is so there's the ui it's just a page and a couple lines of code to like set up razer pages in the application so yeah this is this is we hope is a a simpler way to get started we are leveraging a bunch of things here some new c-sharp features also coming uh and we hope this will make people's on-ramp easier and then once once your app gets bigger and you've got lots of code you want to factor into classes and you can of course do that you grow up to the api controller pattern so i like how this is because things over time like when when asp.net course started like way back in the dnx and project k it was like they were pretty small and you almost could like write it by hand and then over time the configuration and all the namespaces and everything kind of grew and file new project is kind of meaty and so it's really nice to see this kind of simplified down if i want it right and like you said both getting started and the um like just if i've got a bunch of tiny little micro services being able to write a micro service and 20 lines of code or whatever is pretty cool for simple things it's simple for things that get big and you need to actually scale up the app you we have we already have the structure for that what we don't really have a great story for is what if i just need like one api like why do i have to have all these files you don't you don't won't need all those files anymore in dotnet 6. that's the idea if you don't like it of course you could continue to use the existing patterns that that are there today cool right so that's minimum apis minimal api what else are we doing okay so once you've gotten started with your application we want to make sure you have a fast and fluid and iterative dev experience so in.net 6 we're doing a bunch of work to speed up build times and also make development more productive we're making optimizations across the.net platform to speed up builds and to improve app startup performance one of these optimizations is switching our razer compiler from its current two-phase approach to use the new source generators feature from from roslyn which makes building your views your pages and your blazer components much much faster this work also paves the way to finally support uh visual studio edit and continue in razer files in.net six so that will that's coming in this release as well and we're also adding support for net hot reload in uh net six this is not just for web this is across the stack for mobile desktop web hot reload is the ability to rapidly update the code of your app while it's running without losing any of the app state asp.net core and blazer will fully support hot reloading.net six so whether you're doing razer pages or mvc or blazer you'll get dotnet hot reload in the sixth time frame i think sofia showed a little bit of that uh last week but i'll show it again but just real quick this is these are the performance numbers that we're now seeing for razer build performance uh with the new razer compiler based on source generators and that smaller here is better and you can see that uh with the new compiler we're like the build time's like twice as fast which is wow fabulous all right let's take a look at hot reload for those who who missed it who didn't see it it was sort of tucked in with a talk on octane let me um let me open up a different project i have this blazer server app already created there we go okay and what do you want to do here um actually yeah i think this one did i already mess around with this app to make sure i've already touched this no it looks good okay so let's go ahead and open up a command prompt and to get this running i'm just going to run.net watch and this app actually has one additional little tweak to it over your vanilla blazer server app which is when i created it the template added this hot reload profile for asp.net core so this is what's turning on hot reload for this app you can also turn it off if you decide hot reload isn't working out for you in your particular dev workflow um so dot net watch will actually pick up on that and you can see there it's saying hot reload is enabled and it's all set to go it's actually popping up the browser for me on my other screen but i'll bring that over here and there we go let me make this a little smaller so we can see that looks good all right so hot reload is supposedly enabled well let's see if we can give myself a little more space and let's try it so let's go into the pages folder i'm going to turn on autosave it's already on and then let's go into the index.razer file and let's add some excitement to this hello world and look no hands and there it is whoa now that's because autosave kicked in it saved the file and then we calculated a il diff for what needed to change like the this this this is a component so this component got compiled into a c sharp class turned into some dot net il we figured out what exactly changed in the dotnet dot that il and inserted that into the running app without restarting it so it's actually really fast like it's faster than you can like even see sometimes so like if i change i can change c sharp strings too this is a c sharp string being passed into a component isn't this so cool and it hands off and it just updates um we can add component tags as well like without a counter no hands and there it is of course that counter works because it's just a counter component all right there we go and why have one counter two counters there's a second counter the thing i want you to notice is that the count from the initial counter didn't go away the app state was preserved this is really powerful like if you're deep into a complicated ui let's say you have a really big form and you've already navigated a bunch of stuff in the ui and you want to tweak just one thing hot reload enables you to do that without losing that app state or maybe you're like deep into a nested tree view and you don't want to lose where you're at you just want to tweak the ui right there hot reload will let you do that app state is preserved you're not restarting the app anymore like hot reload currently does it's just leaving the app running and patching the the running bets so so the big difference between like we've had.net watch over time but netwatch actually like watched things and restarted your app all the time right restart the app and then um in more recent releases like in five it will even refresh the browser for you like it'll restart the app and refresh the browser so you get the new bits which works pretty well for a lot of scenarios hot reload is faster and it will preserve app state that's that is a big deal we can even mess around with our counters like let's make the counter instead of incrementing by one let's make an increment by two that just says then we click the click now we're going up by twos instead of buy ones um there are some changes that are not supported by hot reload there are some things that we can't actually like hot patch into the running app um for example let's say i wanted to add a component parameter to this uh component i'm gonna add a property there's my prop there let's call it increment amount and let's default it to one and that already you can already see that the thing there uh already did what i was about to show because i didn't type fast enough let's wire this up here all right so you can see that in some cases that app actually did do a full restart like it it detected that there was an edit that it couldn't actually hot reload into the app and then dotnet watch falls back to um doing a full restart and a browser refresh so you can stay in the flow of doing your edits and getting the changes to showing up in the browser um but some changes might actually involve a restart in fact sometimes you might even want to force that oh here let me let me let me do a change that actually will um require restart i'm going to add a parameter attribute attributes are something that you can't hot reload so that did a restart let me now change uh the initial value of the increment amount parameter to something like five okay so now i would expect that i should be incrementing by five and i am and that's because it restarted why did that restart oh that must be new that's interesting okay that actually um in the past i've had that will um will not restart and that would actually hot reload um did i just okay now okay i don't know why that that that did a full restart that previous time so the previous it was five i changed it to four and now you can see in the output it said that it uh that it hot reloaded that change so the code to initialize this parameter is now four instead of five but if i click it's still incrementing by five and you might be like well hold on dan you told me this is like updating the app why is it now incrementing by five when it should be incrementing by four and the reason is that we hot reloaded code that's initialization code it's code that got updated but it didn't get a chance to rerun if that makes sense so if you're like mess around with like uninitialized or like a constructor of something sure we can patch that code but unless something actually happens to cause it to re-run you won't actually see the impact of that new code which is one thing you kind of have to think about when you're doing hot reload if you're done editing continue this is a similar issue that occurs with edit and continue as well so in a case like this you might actually want to force a restart so that your initialization code reruns and there's a gesture to do that you can just hit control r on the command line and that will force a restart as well so that's the falling back to restart and then having a gesture to also force a restart if you want to um what else i want to show you oh yeah there's an error experience like if i uh accidentally leave off a semicolon so i've introduced a compilation error you get a nice warning in the browser letting you know like hey i can't i can't even build this so i'm certainly not going to be able to hot reload that change and then when i fix it actually let me add some clicks and now add in reintroduce the error [Laughter] so fixing compilation errors should normally not cause the app to restart like it should uh if the change was a hot reload would change it should have sort of should have worked actually i'm not sure what happened there let me try that again let me try one more time so we're fixed let me force a restart oh oh okay i'm getting um some sort of like uh file locking issue that that okay let me let me try again try again i told you folks we're going to say we knew we were going to have some something in here now i'm not even getting my components that's interesting i think we're still locked oh we try yeah there's magic going on right with the like i think there's a something being held on to in uh this guy maybe kill some kills and.net processes yeah no you won't need to do this actually let me try it one more time all right so here we got the browser pop it back over no i'm not that something's still not updating huh that's interesting i i force a hot reload reload for some reason we are still locked in like not even having the new code oh well um maybe we can i promise some demo fails but yeah i don't know is it cached i don't even know what's going on with it like i restarted the app completely the people are saying save the file oh maybe but uh but everything failed to save content that follows newer please compare version what the heck i don't know what's going on let me try uh don't save try this this is good it's good it's good testing it's good yeah why why why do this why why not just test on a live stream [Laughter] well i mean people want to see the live previews right i mean this is like this is what you're working on unresponsive like what is going on maybe i could just open up from the command prompt again i don't know what's going on let me try closing this all my visual studio code instances let's close that one flip that one try one more time all right here we go okay all right are we good now okay required assets that looks promising we've got some okay can you recognize that as a component yeah i can i know you can but it doesn't code is reloading well we might have to move on but uh yeah i don't know what's going on here uh that's really weird i think it was like working super beautifully for a while and then if i let it run does it still do that too is it the it's just the right directory and everything okay oh even that's even that's showing the the old code it's not even recognizing the the files as uh as a thing [Music] yeah people are saying the counter was a blank file oh is it oh snap so well that's obviously why it's not a component anymore uh okay um that's fine that's fine okay so well we'll move on i want to make sure that people see that you can also do uh through css so counter is no longer component that doesn't make sense now that's why we're not getting um let's least mess around like you can also do css changes like if we go into the the main layout css i think and then let's say we want to play around with this gradient up at the top let's change the starting color to like white and let's change this to gray and as i just type you know css changes also are getting pushed into the application so you get that uh fast iterative workflow the kind of workflow that you would usually have with like the browser dev tools but just with your normal source uh source files when you're doing uh hot reload as well all right well there's our first demo failure that was great i mean we figured it out it was the file was overwritten so yeah yeah okay now how do i go back here okay all right let's talk about cloud and cloud native um so we also of course uh want net to be able to run great in the cloud it already it already does run really really well uh where's my my notes sending my notes back up okay there we go so we're do but we're doing a bunch of investments to make dot net in the cloud even better we're improving uh the observability of your cloud hosted apps with open telemetry and i'll talk a little bit more about that in just a bit and hopefully have a demo that works on that one we've added support for client retries and load balancing to grpc so that it works great in orchestrated environments we're also making it easier to build minimum apis as we saw earlier those of course are the backbone of cloud-based applications there's also a bunch of work ongoing to make sure that.net runs great in containers we're enabling even smaller container sizes when using.net we're making sure that.net performs well under pressure in constrained environments and we're also simplifying the configuration that you have to do with net to make it run well in orchestrated containers now open telemetry is kind of interesting if you haven't heard of it open telemetry is a community effort to define a vendor-neutral spec for logs metrics and distributed traces it's part of the cloud native computing foundation the cncf the open telemetry distributed tracing spec is now stable and it's also supported uh in dot net and asp.net core uh with open telemetry you get cross-cutting uh a view of your app and you can easily correlate your logs and your traces um we're also collaborating with the open telemetry community on future observability efforts uh like metrics uh that you can find out more about at opentelemetry.io and so i thought we'd take a quick look at what open telemetry does for you all right so i have an app that one of my colleagues was kind enough to set up for me let me see if i have it open here that's car checker i need the trivia app all right so this is an app that's like a simple little trivia game and it's got a client piece a server piece it's got uh proto files for grpc services that are used to communicate between the front end and the back end and then it's using a bunch of cncf technologies for dealing with traces and logs through open telemetry now to run this app i'm actually going to run from the command line because it's set up to use tie so let me go over here and i will do tie run it's got everything's all set up as containers and all that stuff that stuff you know that cloudy stuff technical way of referring to it all right there it goes uh let's go ahead and pop up the thai dashboard so we can see what this app offers okay so we got the client we have a server and then it's set up to use zipkin which is a cncf technology for a system for dealing with distributed traces and it's also got seq which is a logging back end also in the the cncf but let's just take a look at the app first uh here's our little trivia front end little blazer front end and then we have a little bit of ui also on the server where we can see the score of anyone who's playing the current trivia game so let's play some trivia what is your name dan let's start this okay first question what does the g in grpc stand for and i'm going to look at the chat i'm going i'm using my whatever picture can i help it sam i don't know i'm pretty i happen to know for a fact that it is not google like that is not is not the google rpc protocol grpc general purpose or good google no no it is not google yeah right good it actually and originally it's i'm told it stood for grpc it is the g and grpc stands for grpc it's the grpc remote procedure calls one of those like inception things although i hear more recently they've decided to change what the g means with every release like there's like a wikipedia page for what the g means every time they update the the the release for the protocol so grpc i believe is the correct answer and it looks like i got a point and the real time dashboard is telling me so okay what is not hard in computer science off by one errors naming things building a grpc implementation or cache invalidation well that one's easy because i mean with net building a grpc implementation is just trivial so yeah i got two out of two all right so that's our simple little uh trivia game um the point though is not so much the app but the telemetry and the observability that we get into this app so i'm now going to go take a look at zipkin this is a tpcp address i'm going to switch this to the http and there's the zipkin ui and i'm going to run the query so we can look at all our traces here's the one we just did not too long ago and there you can see we get this really nice visualization of everything that happened in our app like we can see the original client request to start the trivia game that's where i'd like typed in my name here's where the client is then making a request the server to get all the questions and the questions get streamed back to the client over grpc and then this final request is the like get me my score like what what did this user score with all those question answers so you get a nice visualization to what's going on and then there's this trace id up top um remember these last four digits like zero eight uh d f okay we're gonna go now look at seq which is our logging backend and let me find like like here's the trivia score request let's look at this yeah zero eight df was the trace id that we had before i can now filter based on that trace id now here's all the logs just for that one game that one uh sequence of actions so this is what open telemetry gives you is a cross-cutting distributed tracing and the ability to correlate your logs to those traces and the way this was enabled was using uh net support for open telemetry we can go look in the project files for the client and here you can see it's using all of the open telemetry instrumentation packages to instrument into the hosting layer into asp.net core into the http stack into the grpc client and then it's got an exporter for zipkin and the logging extension for seq and all those are just getting wired up in startup so that's how all of the instrumentation is being added to my app and then the specific uh exporter for for zipkin so that's how you get all that and this actually is available for net5 today you don't need to wait for net six uh although all the work like the spec didn't actually go stable until after dot net five had shipped and all these packages came out later so it's kind of part of the the dot net five wave and of course it will just keep getting better uh with with dotnet six so that's a little view into open telemetry let me make sure that i shut that down so i don't have a whole bunch of containers ready very cool and some of the stuff you're showing here we've done shows like we did a show on open telemetry and we did one on we've done a few shows on project tai which are showing there so for people that are interested in microservices development and and orchestration and all this stuff like there's some some longer shows on those too cool go back and check that out for the deeper dive uh what about our servers so we're adding support for http 3 um hp it feels like we just did http 2 but uh http 3 solves uh an important issue that can happen with http2 hv2 moved everything like onto a single connection so you could like um tunnel a bunch of hp requests over a single connection which was really nice but one thing that can happen with hp2 is an issue called head of line blocking where if something happens like at the tcp layer where packages packets get lost then that can gum up the traffic for all your all your other requests hp3 addresses that by adding a new transport called called quick which is udp based so it doesn't have that that same problem we will support http 3 in net 6. we're starting the work now now it's a little early because the hp 3 spec i believe isn't even fully completed yet but we're trying really hard now with asp.net core to stay ahead of the curve with the the latest uh iterations of the you know web based protocols we're also adding support for shadow copying a form of shadow copying for iis based deployments in it six now you already have a way to deploy to iis of course with that with dot net f5 and earlier um there's even a feature where you can like deploy an app offline file to shut things down so that you can deploy your files one of the common issues with dotnet is once the app is running the files get locked and you need a way to sort of unlock them so that you can publish your files and there is a way to do that with you know standard um high availability patterns with asp.net core today but for some simple scenarios where you just want to ftp a bunch of bits onto a server uh it can be more troublesome it can it can be problematic to deploy in those those types of environments so we are adding a form of shadow copying uh in dot-net six where you'll be able to just uh enable some options in your uh publishing settings so that you can deploy the files have them be pushed into a different folder and then have them swapped in so look for that in upcoming.6 previews i know they're definitely looking for for feedback on how well that works for people that have been asking for shadow clocking support uh let's move on performance oh yeah so lots of great performance work is happening in dot net six a lot of work has actually already happened um for http apis we're trying to make them as pay for play as possible we're already seeing a five percent uh request per second gain throughput gain uh for raw middleware in dot net six that's as measured on linux um the new minimum api program model that i showed you earlier one of the additional benefits of that model besides being simpler is that it's also really fast there's very little overhead in that model um it's twice as fast actually as uh the equivalent code in api controllers and pretty close to being on par with uh raw middleware scenarios so great performance boost there faster jot authentication is coming in.net six that's thanks to an upgrade to the uh our jot token support to the job token package um mvc is also getting faster in dot net six uh nvc on linux in particular is now currently 12 percent faster uh for throughput uh thanks to faster logging um you know every platform is a little different and there was some like logging id that we were generating that on linux just happened to be particularly slow and we fixed that and got a huge perf boost across the board when running on linux environments uh there's a faster memory cache in dotnet six that gave us a 10 boost already on the cash tekken power benchmark uh really big drops in uh memory usage for https connections uh this was done using zero byte reads uh we're actually seeing a forty uh working sat reduction for jason our jason hbs middleware benchmarks um we're doing a bunch of perf work on http 2 because hp2 even though hp3 is coming it's not here quite yet um but we're improving uh the hp client to have better connection management for http 2 scenarios um and also we sped up grpc uh by speeding up uh protobuf uh protobuf is actually about uh 20 faster now with with.net 6. this is just the beginning like i'm just telling you the stuff that's like already there in the latest.net 6 previews of course there'll be a lot more uh perf work that will come as the release progresses and usually that's kind of how things work right we add in more of the features and the bigger things and then over time the perf like continues through the pro like a lot of time you'll see more of the perf towards the end of the dev cycle yep yeah cool uh mvc what's happening in mvc well we're adding support for css isolation this is actually a feature that we added for blazer originally this is a way to have a css file that is scoped to a particular component or now to a particular view or page so your styles don't impact other parts of the of the application it's done at build time and we did it for blazer and now we're bringing it to the rest of the the ace minute core stack we're adding support for streaming so that you can use ice ink and um without having any buffering uh in the in the stack that's being plumbed all the way down through the the serialization layer uh so that's coming soon that's i think the the system text json work just finished and we're just now um uh plumbing that all the way through for preview for so hopefully with the preview for release you'll be able to see that uh that would be for like streaming a file result kind of thing or streaming what would you use so like if you have um like an async [Music] yield pattern in your like you're synchronously enumerating a bunch of results uh right now we have to buffer all that at the serialization layer before we actually write it out with this pattern you'll be able to just write out chunks as they get uh yielded uh from the from the control action like if you return i think an enumerable result uh icing disposable we're gonna we're adding support for net six we're gonna move to bootstrap five as soon as it uh ships a stable release i think they're up to beta three now so we'll update our bootstrap uh styling across the board uh and a bunch of improvements to our open api support like um a bunch of bug fixes and just usability improvements for folks that are doing http apis with open api i thought i would quickly show the css isolation if you haven't seen it for for blazer it's kind of fun i'll show it for mvc now so let me pull up my mvc this is actually a razer pages app which is just based on mvc while you're doing this i just want to say this is really cool to see i know we're we talk a lot about the absolute newest shiniest stuff here's some stuff we're doing for microservices here's stuff we're doing with blazer and all this we've got a lot of developers that are building nvc and razer pages applications and it's good to remind everybody like we're continuing to improve those and you know like i don't i don't know it's cool to see new features coming oh yeah like it's it's part of our web ui story like i think um like i work on blazer a lot obviously so a lot of people ask me like do i need to migrate my mvc or razer pages code to blazer and the answer is no like that's that's actually not what blazer was meant for at all blazers specifically for client-side ui was it was it was meant to fill a gap like if you felt the need to write some angular code or react code or some javascript code that ran in the browser if you wanted to do stuff in the browser you didn't have any way to do that with net and blazer filled that hole but on the server there's still plenty of scenarios where you'll want to server render some html or server render some ui and that's what you use mvc and razer pages for so it's to have the full stack story uh you need both it's actually both intended to be to be used together and so of course we're going to continue to invest across the stack on the server and on the the client okay so here's my little razor pages app and it looks lovely but i'd like to add some more color so let's open up i'm going to open up the site.css file this is just the global css file for the application and i'm going to add a style for the h1 tags and change it to hot pink we'll save that and there it goes okay so now it's hot pink and we've got a couple pages in this app that uh we should like we have the privacy page as well and that the h1 tag there also updated to be hot pink now to use um css isolation all you need to do is uh use a particular convention where you define a cshtml.css file that's a companion to your razer page or your your mvc view and now anything any css styles that are put in this file will be scoped to just that particular page or view now currently i don't have anything in this file but let's let's go ahead and add some styles so that this privacy page has its own styling now i could use like a css selector to specifically pick out this h1 tag for this page but instead because this is isolated i can just add another h1 selector here and change the color to light blue and we'll save that and in this case i have to have to actually restart the app because it needs to rebuild and after we do that now if i go to the privacy page we can see that only the privacy page is picking up the light blue styling for the h1 tags while the rest of the h1 tags in my app continue to be hot pink so that's css isolation now available for mvc and razer pages that is handy yeah i've done that with like page based classes and all kinds of stuff but it's nice to just have that and and being able to organize it like that with the nested css if you're like using razer class library style approach to package up a bunch of pages that you want to reuse some place you can now package the styles with those pages and have them be isolated to just those pages so they don't pollute the rest of the application that's also something that you can do okay spa spa support you know that's that's another we still also do support the javascript story like if you if you we have lots of people that are using uh existing javascript front-end frameworks to build asp.net core apps we want to continue to invest in and improve our spa story so we have a number of goals with this effort we want to continue to have a really great dev experience with popular spa frameworks you should be able to just create an app and run it and publish it and have that all work without having to do a whole lot of setup we'd like to do a better job of keeping our spot templates up to date right now we update our spot templates for angular and react whenever we release which right now is once a year um and that means that we're usually one if not two maybe even three versions behind on some of the these spa frameworks uh we'd like to do a better job with that and actually keeping up to date with the latest versions of those of those frameworks we'd also like to unblock people who want to use other spot frameworks than what we ship out of the the box make that easier to do like if you want to use vue or if you want to use spelt or you want to use banana like whatever the the new spa framework is yes by the way banana is the new that's the new you learn it here uh you should be able to do that with asp.net core and we'd like to enable an ecosystem of community templates actually and um community participation in updating the the spa templates so the approach that we're uh planning to do is uh well we're gonna ship try to ship the spa templates faster try and decouple them a little bit more from the uh the sdk so we can ship them at a faster cadence or maybe just ship the up faster updates in the sdk we're doing a bunch of infrastructure work to automate uh keeping the templates up to date with the latest uh latest versions of this uh front-end frameworks uh we're also trying to work on establishing a common pattern for these uh spa apps that can be then be reused across um whatever with whatever front-end framework you happen to be to be using and the one approach that we're looking at for doing that is actually leveraging the webpack dev servers proxying support today when you use asp.net core with a front-end framework we set it up so that we actually proxy requests during development through the acemic core app to the dev server for that front-end framework like to the angular dev server or the react dev server so that it still feels like one app um but you still get the functionality of the dev server for that for that particular framework um the idea here is what if we switch that around like these it turns out a lot of these front-end frameworks already have proxying support what if we put the front-end dev server in front and then proxy to the ace bit core back end that's a little bit more canonical in terms of how these apps are typically set up and enables us some additional flexibility and i have a little prototype here that i can show you of what that looks like let me open that up and this one okay so in this solution i've got a few different apps i've got you know we've got angular we got react and then there's the prototype bits and then we also have a view project in there which is cool okay i'm just gonna hit f5 to show you what this how this app works now when this starts up it's going to start up the ace net core process and then the acema core process is going to try and check to see is the is the angular dev server running then you better catch it no no if it's not then it starts it up and you can see here it's starting up the uh the angular dev server as well um so that's actually very similar to what we do today but instead and here's the actual running app but instead of the browser being pointed at the acemic core app you know being pointed at localhost 5001 which is where the acemicrop is currently listening you can see that it's actually pointing at 5002 and that's where the the angular server is listening so we're proxing through the angular dev server um and you know everything still continues to work like we can click on our counter the fetch data page pulls down the the web weather forecast data from the ace bit core api but this has a couple of benefits like if we go look at the code for the app the project is really simple like here's here's that same client app folder um this is just the angular template code uh but in here there is in package.json we can see that we're setting up the normal proxy config settings so that we can proxy to the acemic core back end and then when we look in the startup file for the actual hdmi core part of this app there's no like spa anything in here like i don't i don't need any like spa specific middleware to handle proxying like my code is untouched um uh yeah pretty clean um and because this pattern is very common with front-end frameworks it's really easy to duplicate with other frameworks when the dev javier was the one who put this together when he showed this to me i was like well can we can we do view and he's like oh yeah sure and so we copied the angular project and created this view app project all we did is then we just ran the view cli to change let me give myself a little more room here to change the client app folder to have view code we then had to go figure out and view how you uh configure the proxy settings because it's a little different for each of the frameworks in view they have their own javascript file but there's there's the proxy set up to tell you to please proxy to the acemic core backend and uh yeah that was it so now if we uh set up a startup project actually i need to stop my previous app make sure everything is terminated okay that one's done let me close the and where's the angular one so this is configured the idea is this is configured in the template and the launching is done via webpack and the front end cli and then it kind of call it's what what actually kicks off what launches oh you still you're still just like before you're still running the net app the asp.net core app it has a little bit of uh infrastructure in it that then looks to see if the dev server is available and if it's not then it will it has a little bit of like logic in it to know how to start up the the corresponding dev server for the front of framework that it's in so that's the little piece and we also we do a little bit of extra magic to make the acemicore hbs uh development certificate also work with the front-end dev server so we do that okay then it just fires up the front end dev server which is now going to proxy to the acemic core background okay it's the reverse of what we do today um and as a result it's really easy to add like if you want to view it it took us like less than 30 minutes to create a view app using this pattern so we're looking at updating our spot templates to use this pattern in dot net six and uh hopefully well this would then enable us to start a you know community effort where we can have a whole bunch of templates that support vue or banana pineapple whatever right app we want to support yeah so that's spa in.net 6. it's coming let us know what you think about that if you like that pattern um if you don't that's cool to let us know and hopefully we'll make spa better okay what else do we got all right last wait how much time oh my god i'm so supposed to be done i know you have a meeting agreement oh look at all this stuff there's a lot of blazer stuff coming maybe we've saved a bunch of this stuff for our future talk um yeah we are doing a lot of laser things hot reload you already saw webassembly aot is coming in.net six maybe i'll do that as my last demo i know we showed it also the last talk is as well um we're also doing a um a whole bunch of component model uh improvements that i don't know we don't unfortunately don't have time to go through all of these but there's a lot of great stuff coming to blazer go check out the ace midcore roadmap issue and look through the the get of issues we're doing a bunch of really great work um performance is getting faster for webassembly and dot net six even if you don't use aot like the the interpreter itself is already like ten percent faster for rendering uh from dot net five to dot net six and json serialization is 20 faster in indonesia from.net 5 so that's good but of course real big perf boost is coming with uh with aot i have one more demo that i'll squeeze in here so i uh for my demo i know i think sofia did like an image processing uh demo which was super cool uh i took um conway's game of life uh you know popular little like box-based simulation and this was actually based on a blazer app a blaze report of conway's game of life that was done by [Music] this gentleman here i just took his blazer app and i ported it to webassembly and updated it.net six thank you david he has a nice blog post on it as well and let's go ahead i'll run it twice i'm going to run it using um just on it run which will use the interpreter so we won't not not aot run this server all right and i think this is 100 by 100 grid if you haven't seen conway's game of life you're like what the heck is conway's game of life it's like a a simulation of a bunch of little blocks that have a bunch of rules that they either live or die based on how many blocks is around them and so it makes these really kind of cool patterns and shapes and it's been shown to be like a full a full computer like you can do full compute using this model okay and i need a little more space how do i get this to be yeah so depending on the surrounding a cell's neighbors depend on whether it will flip colors okay so down the bottom hopefully you can see the count like this is how fast it's able to do the generations you know a couple of seconds a couple of generations per second not too bad it's all these blocks like live or die based on a calculation that involves every single grid uh um in this space okay that's without aot now i enabled aot for this application and ran it now there are some trade-offs with aot the app just get bigger um and it does take a while to aot like i think it's like three minutes to run aot on this app which is a thing hopefully we'll be able to make that a little bit faster but you do it basically like on publish it's like an optimization step you do when you're publishing your app and if we run the the published version of this app this guy and let me bring that back up the browser a lot more jitter it's like i think five times faster when i was uh doing some little tests like it's just ripping through the the generations um in some cases depending on what you're doing like there's still a bunch of dom manipulation happening in this app so that that that the dom manipulation doesn't get impacted by aot but any cpu uh compute uh intensive stuff gets a dramatic perf improvement this is like four or five times faster if you're just doing raw compute uh you can see you know 10x improvements in some cases so it's not no longer interpreting and running like the il and a vm it's actually compiled to webassembly native web assembly code yep then i'll show you that i know i mentioned that there is a trade-off with download size so i'll show you that real quick let's uh do a refresh i think i have to actually have to clear out the cache clear the site data and let's do a full refresh again so the the compressed uh the void app size now is 3.7 megabytes like a default blazer app uh six comes in at about two megabytes that's including all the css styles the javascript infrastructure bits so you get about a 2x sizing increase um with uh when you aot the app so that's something you also need to consider it will impact load time you're trading off some load time and build time to have faster cpu uh uh faster compute performance during during runtime okay that's aot yeah well as we're wrapping up because i know we're about out of time we can we can uh we have a monthly blazer community stand up and so we can dig deeper into some of these blazer things um but one of the most important uh questions people have been wanting your desktop or your your wallpaper i think i got it from chris st oh wow he gave it to me like this one right yeah yeah yeah yeah just gave it to me i don't remember where he got it from but yeah um so ping him on he's on twitter yeah i don't know if i can i i'll ask chris i thought he was on earlier today he might have been on probably yeah i think it was he if it's not him everyone's gonna be pinging him be like chris we want the wallpaper and he'll be like yeah i'm talking about it i think it was them wow i'm happy to share it um i didn't create it i can't take credit for it but it is pretty nice well this is very cool i will also share the link again to your blog post which goes through all this stuff and tells you how you can try it out and get started and everything so this is amazing dan thank you very much thank you everyone for listening lots more coming stay tuned and insects all right thanks for [Music] watching [Music] [Music] [Music] do [Music] you

Channel: dotNET

Views: 32,593

Rating: 4.9487181 out of 5

Keywords:

Id: Mot8qAWEnj8

Length: 79min 32sec (4772 seconds)

Published: Tue Apr 20 2021