>> Welcome to.NET Conf 2021. I'm Scott Hunter, the VP of Product at Microsoft,
on Azure and.NET. I'm excited to be here today
to share all the cool things that we built with
community, and.NET 6. First-off,.NET 6 is
a unified platform, that's one SDK, one runtime, once at a base libraries to
build all these crazy app types, whether it's Cloud, web, desktop, mobile, gaming, IoT, AI. Once you've learned.NET, and you build one
of these workloads, you can then build all of
them with the same skills. It goes beyond that, we also have amazing tools. You can use Visual Studio
family of tools to build dotted applications for.NET 6. If you want to use a
cross-platform editor like VS Code, you can do that. If you want to drop down to the CLI and do everything from the terminal, you can do that,.NET
is very flexible. We have an amazing ecosystem of thousands and thousands of packages out there that you can
build your apps with. There's a ton of amazing
projects in GitHub, and there's an amazing group of component vendors and staff
that build tech on top of.NET. It's a huge ecosystem, completely unified in.NET 6. Now, let's talk about the
momentum of our ecosystem. We have over 5.4 million
developers using.NET every day and the Visual
Studio family of tools. We have been the most
loved framework in the Stack Overflow Developer
Survey for three years in a row. The Cloud Data Foundation measures the highest velocity
projects in GitHub, and you're going to
see that.NET has been in the top 30 for many, many years. Now, even cooler, we have over 6.9 K community
contributors outside of Microsoft, that have contributed over
21,000 contributions. That's an amazing effort
considering that we only opened source.NET back in 2014. I want to step back and
say thank you to all of those contributors for
helping us drive.NET forward. Thank you to all of
those contributors. Next,.NET and performance. One of the key tenants of.NET, once we reinvented it back in
2016, has been performance. The reason you should
build your applications on.NET is they're going
to be the fastest, they're going to run the
lowest cost in the Cloud. You can see here, we
are still doing really, really well in the
TechEmpower benchmark, it's a public benchmark. You can see they were 10
times faster than Node.js, your app's going to
run very, very fast. But I'm really excited about
what we've done in.NET 6. If you look here, Entity
Framework Core Performance, that's our ORM built into.NET
for doing data access, and you can see it's 92 percent
faster than it was in.NET 5. That's a huge leap in performance. On query performance,
it's 36 percent faster. What's really cool if you take
this TechEmpower benchmark and you take.NET, you take ASP.NET Core, and you take EF Core, put them all together, with the first full-stack ORM, we show up as number
2 in that benchmark. That it shows you, building a
real application with a web, data, and.NET is going to save you. Now, let's talk about some
of the cool features that we have in.NET 6. First off, I want to lead in, would say, go download it now, there's a URL right here, get.dot.net/6, and you can grab
that to grab the newest bits. But as I mentioned before, we've got this unified common
base libraries in SDKs to build all those app types, we have industry-leading
performance, we have simplified development. If you look at development today with things
like Python and Node, they make development
studying easier. You're going to see a lot of demos
today where we show you how we made.NET 6 the easiest to
build new applications with. We've got great new releases
of C-sharp and F-sharp, we've got support for Apple
Silicon in one chip support. This is a long-term support release, so you can trust it, and trust.NET. But we didn't just ship
a new version of.NET, yesterday we also released
Visual Studio 2022. This is the version of Visual Studio designed to build.NET applications. If you want to go build a
great client-side application using a web front-end with Blazor, it's got great support for that. If you want to build multi-platform
applications using.NET Maui, it's got support for that. You're going to see
some of the really cool features today as well. Hot Reload all app types, whatever you're
building, whether it's a WinForm application,
WPF application, a web application, we've got Hot
Reload through all those apps, and even works on things
like.NET Framework as well, so that feature persist all of.NET. This release also has
great support for Git, whether you want to
use Git inside of the IDE for your source control, or you want to actually
right-click and have a GitHub Action file, so you can use CI/CD that's built in all the way from the
core of the platform. It's got IntelliCode, it'll do full statement completions, it'll suggest after you to
refactor your application. All of this in.NET, and all of this in Visual
Studio, grab it today. Now, I'm really excited about this. We've been shipping these
new.NETs since about 2016, that's the first version
we shipped.NET Core 1.0. We know we have lots
of customers out there on our older versions
of our frameworks, so we've built a new tool called the.NET Upgrade
Assistant, it's available today. You can see we've had 40,000
people tried in preview. What it will do is, it'll
help you take an application, whether it's a ASP.NET MVC, web API, it can be a console application, a WinForms, WPF, class library, it helps you take all
of those app types and move them to our new tech. It's a guided
step-by-step experience. All those project types I
just mentioned are supported. It's got support for C-Sharp, and we just added
VB support as well, and it supports.NET 6. We actually built
this tool internally as we would go out and
talk to customers, one of them was Episerver, and we helped them port one of their large applications
to the newer.NET. But I want to end
with something else, if you are using.NET Framework, you should consider moving your
tech to the newer tech because it's faster and has
the newer features, but you should feel
safe to stay there. You can stay on.NET Framework
for as long as you want, it's going to be supported as
long as Windows is shipping, but I'm excited to
announce that we have an update coming
for.NET Framework 4.8. It's going to be.NET
Framework 4.8.1, and we're going to add ARM
64 support to it as well. You can keep your older applications on.NET Framework and have a path forward into the newer silicon
that Windows supports. Now, with that, I want to talk
about simplified development, and this is what I was
highlighting little bit earlier. Newer languages get right to code, you don't have to have all
the ceremony that we've actually had over the years in.NET. First off, when I think about
simplified development, I think about Hot Reload. We all sit in a loop
where we write some code, we run it in the IDE, we look at what the output is, we could decide to change the code, so we stop the application, we change some code, we
recompile and start again. That cycle is super slow. What if you could just actually
start running your application, go in and make a change, and push a button in the IDE, or save a file if you're
in the command line, and the app would actually update
and keep all of its states. This is going to
make the inner loop, that's the action, as I said before, making some code changes, rerunning your application super, super fast. We're
going to demo that. Less time restarting,
more time coding, it's available in the CLI
and in Visual Studio 2022, and it works on all project types, including.NET Framework 4.6, but of course it's going
to work best with.NET 6. Next is C-Sharp 10. These are some of the most
exciting features I think we've done in recent years, and you'll see demos all
day of these features. One is global usings. If you build an ASP.NET
Core application, almost every file is
going to start off with this whole list of
usings at the top. We're going to let you
put those away somewhere else and reduce that code. Another thing is namespaces, if you're building lots of apps, your entire file is indented. Now we have a feature
where you can actually put a semicolon after your namespace, remove all that indentation, less stuff in your code. You can also see as well, we added a feature called
records in C-Sharp 9, and we now actually let
you use that same feature, it lets you build a class in
literally one line of code. Now, we actually let
you do structs as well. Then, finally, this is my favorite, in many cases building
Lambdas in the past, you would actually
have to use a func of string or int or whatever, now, the compiler will try to interpret that for you and do
that work for you, and mads is going to show
that in a little bit. Finally, when it comes
to simplification, if you built an ASP.NET, web API in the past, these are designed for
enterprise level applications, so they can scale to whatever level, but that cause a lot of ceremony
to be in the applications, you can see on the screen here, in literally three lines of code, I can write a simple API with.NET 6. These are going to make
your life a lot easier, build faster, write less code, less ceremony, it's
going to be great. I want to start off and
switch to my machine here, and show a few more things
about simplification. First off, if you've been using.NET
for the last couple of years, even getting started as a new
developer is a little confusing. If I run this, this is all the
things that when you say.NET new, if you're on.NET 5 you would see. We've simplified that down in.NET 6. Look here, now all I've got, is I've got these basic types here. I can build a web app, a Blazor app, a class library, a console, WinForms, the BPF. If I had the Maui
workloads installed, they would show up here as well, but this is just a getting
started experience, is simpler. Let's go take a look at
a.NET 5 application. If I build a console
application in.NET 5, it's going to look
something like this. Notice here I've got
my using statement, which we mentioned before, I've got a namespace which
indents my entire application, I've got the class, then a void static Main method
right here, to do all that. Just to write hello world, I have to have all that stuff, and we've done a bunch of work
to simplify that with.NET 6. I'm going to create a new project, let's do a console application. What's called Console
App2, that's fine. I want to show something,
this is super important. This is a new feature that
we don't talk about a lot. If you're building an
ASP.NET application, you can select which version
of.NET you wanted to use. If you built a console application,
a WinForm application, WPF application, or class
library, you can not do that. You can see we've added into
the File New experience, the ability to basically
select the framework you want and we even show you which ones are long-term support,
which ones are current. This is a much better
experience for getting started. I'm going to click.NET 6. Let me bump this up.
Now look at this, just the contrast from a.NET 5 application
with all that ceremony, a.NET 6 application basically as
Console.WriteLine Hello World, all in a single, just a single line of code,
which is the way it should be. This is one of the cool
features of simplification that we have in.NET 6. With that, I'm going
to bring Maria up, and she's going to talk
about the podcast app that we're going to build
during the talk today. >> Thank you so much, Scott. During the course of this keynote, you're going to see us build a podcast application that
highlights how we've improved our mobile desktop and Cloud-native backends in.NET 6 and what
you can look forward to. I'm just going to smooth over to this particular laptop and
show you minimal APIs. But before I jump into
our podcast application, I'm going to show you how easy it is to get started with minimal APIs. I'm just going to do File New. I'm going to select a new project. I'm going to select
empty web, hit next. WebApplication1 is a
perfectly good name , and I'm going to create it. Now, in just four lines of code, you can build a functioning API. Never has it been easier
in.NET to do this. It allows for people to build
APIs the away they want to do. Allowing for you to
build the APIs fast, quick, and get right to the code. Let's go ahead and show you how
good these things work together. I'm going to click on
here and show you how the minimal pattern has also transcended into our
other templates as well. I'm going to create a new project by right-clicking on my solution, and I will find that. I'm going to add a new project. I'm going to select Web API, and you'll see that you
have the option to build a Web API with or
without controllers, which shows you how simply these
two work perfectly together. With that being said, let me introduce you to the.NETPodcast API which has
a backend of our application. When a go over to
the.NETPodcast API, it knows a couple of things. All the things in dependency
injections that you like, like Entity Framework and
opiate API, they just work. I'm going to run this
application, and there you have. You have open API, you have Swagger enabled. These are things that people
within.NET framework love right now. I'm going to try it out. I'm going to execute it and I get
a return of all the categories. But let's say I wanted to
return all the episodes. This is another really
cool feature that we introduced in the
minimal APIs as well. An easy way to build your endpoints. I'm going to go back
to my application. I'm going to go over here, and I'm going to add a MapGet. Now because I'm an
incredibly slow typer, I'm just going to
copy and paste it in. I actually copied and pasted it in earlier because I was
looking forward to this. But you'll notice that
because of improved lambdas, we're able to build
these simple endpoints. With that being said, I'm going to introduce
my dear friend Mads, who's going to talk about how
the improvements in C Sharp have allowed us to support
these minimal patents. >> Hey, Maria. >> Hey Mads, how are you doing? >> I'm doing great.
How are you doing? >> I'm doing well. >> I'm always great when
I look at minimal APIs. I think they're a great
example of how we can do language design and
API evolution together. One of the things
you've shown here is the MapGets and MapPost here. They have some pretty significant
lambda, some of them. You look at, let's see, let's do this MapGet
up here for instance. That's actually a lot of
stuff in a Lambda here. It used to be that,
when you have a Lambda, you have to cast it somewhere
that has to be like a delegate type that exactly matches
it which hubbles API design. >> Yeah, it looked
a bit complicated. >> Yeah. What we said in the
language, you know what? The compiler should
really figure this out. I'm sure lots of you developers out there have said the same thing, why can't the compiler
figure it out for me? Now it can. What I'm going to do is, I'm going to take one
of those Lambdas, I'm going to pull it into the
pit and take the wheels off, and we can just look at
what's going on now. Let's take this Lambda, move it up here, put a little semicolon. What you see first, let's
hover on the MapGet. It just takes a delegate. We can put the Lambda here
just to make this all compile. There's not like 100
overloads of MapGet, it just takes it any delegate. >> This is really the heart of the API experience
that you get today. >> Yeah. But the problem is, delegates didn't use to be enough for the compiler to figure
out what to do with a lambda. But now it can look at
all this information, the types coming in, the type coming out and
that affected it's async, and it can just figure out
the right type for it. If you see the type
that it's inferred in the bar here, it's complicated. It's a Func of several things. The return type is a task
because this is async, the compiler figured it all out for you, you didn't have to do it. >> Wow, okay. >> You can just have one MapGet
instead of having thousand or having the user code here
cluttered with casts. That's a really
important point I think. Now, let's put this back together and head up to
the top of the file. Here's another thing. The usings. There aren't even actually
that many usings here, and we'll get back to that. But typically, ASP.NET, there's a lot of name-spaces with
a lot of good stuff and you tend to want to use a large set of them. That's on top of every file. Wouldn't it be great
if you could just not have it on top of every file, I just put it in one place. Let me cut out these
usings in quotes. Now we're going to get squiggles. But I have an ordinary
C Sharp file here, it happened to be calling
it global usings. >> Okay. >> It can be called anything. This could be anywhere
in C Sharp code. I'm going to paste my usings here. That's not going to help
because they're still only applying in this file, it's not doing anything with them. But now, in C Sharp 10, you can say global in front. Now they apply to the whole project, and so you just have one
place where you keep track of all the usings that
you need for this project and just to show you
that it really works. You can see the squiggles
have gone away. >> Round of applause online. >> Yeah, I'm sure. Please. One thing though is that you noticed and I mentioned
that the list is fairly short. If you look at, for instance,
web application here. It lives in is the
very common namespace, Microsoft.AspNetCore.Builder. That wasn't actually on my
list of things I hold out. How is it even building here? Why don't I go to squiggle? There must be something
else going on. >> What's happening under the hood? >> What's happening here
is implicit usings. That's where we figured
you can have global using, but we can give you some as well. Based on the project type, there are going to
be all these things that you're almost
always going to want. Speed on that here,
there's a list of, I don't know, 12, 17, whatever long list of
things you'll always want, including the BCL stuff as well. >> Yes. >> Why don't we just build your global using and
put it into the build, and they're implicitly there. You don't have to put them
anywhere in your source code. >> Is it on by default or
someone has to turn it on? >> In new project,
it's on by default. You can go and turn it
off if you don't like it. There's an enable here I
can turn into a disable and save and then go back to program
and let the compiler catch up. You see web application,
now it lost its color. Now, it got it squiggle. It's gone. The fact that we said yes please, which I would always do
now to implicit usings, I'm going to go and do that again, that essentially means that there's so much stuff you
never have to worry about. Imagine coming to the
library the first time. You don't even have to start
worrying about what to include. >> What to include, but
with implicit using, global usings, Lambda improvements,
top-level statements, we've really embraced
this minimal pattern, which is great for all
types of developers from newbies to people
building micro-services. >> Exactly. >> I love this. >> We did a few more things
to get you simplify it. Here's one of the APIs
that this app is using. It's very short
because it's a record, but it's still annoying
as Scott mentioned. Sometimes you have thousands of lines of class
declarations and they are all indented because of this
namespace that they have to live in. Why don't we just have a syntax for namespaces that
applies to the rest of the file without these
curies and this indentation? I can just say namespace; and all the rest is in there. Now, I can go and just have all
my things nicely left-aligned. >> I love this and
I feel like this is going to resonate so much with people coming to our platform the first time from other
languages as well. >> I hope so. The one last
thing is people really like records that's
a super terse syntax that we're using here as well. It just fits right in that gives you all a value-based functionality, but it's always a class in C-Sharp. It's implicitly a class. Now in C-Sharp 10, you can
make it explicitly a class. It doesn't change anything
other than you get to say it. But of course, what's more important is that you can also
make it a struck. Now we can build
value types that have the same terse simplicity
and minimalism as classes. We built that out fully again
for this minimal experience. >> Absolutely amazing. Everything is available
to people right now. They can download the.NET SDK, and they can try out everything that you'll be seeing throughout the day. With that being said, we'll
bring Scott back on stage. >> Welcome back, Scott. >> Thanks, Maria and
Nat. That was great. I think all of the customers
out there are going to really love all the new C-sharp 10 features that allow you write less
code for your applications. Let's next talk about
Cloud development, which is a big thing these days, and.NET is a great platform for
building Cloud style applications. People always ask me, Scott, can you give me some examples of some of the teams inside
of Microsoft that are building their applications or
their services on top of.NET? We're going to talk about
a few of these today. First off, you can see here Azure Active Directory
gateway is running on.NET. The App Service gateway
is running on.NET. I'll talk about both
of those in a second. Bing.com if you go to Bing and Bing something, that's running on.NET. If you're hitting a Dynamics
365 web application, well, the gateway in front
of that is running on.NET. You can see that Azure, Bing, Dynamics are
all running on.NET. There's lots more as well, but these are a few that we're
going to talk about today. Now, a second ago I said the
word gateway a few times. A gateway is a reverse proxy
sitting in front of an application. Azure App services is an
example of a place where this happens and so is Dynamics. We were talking to teams
around Microsoft and they needed a modern
reverse proxy and we thought that would be
a great example of something to try to
build on top of.NET 6 as a way to make sure that we're continuing to push
and drive performance. You can see here on
the slide Dynamics, which is running behind YARP, which is now available in
1.0 available to you today. You can see 100 billion
requests a month, 7.5 petabytes of data going
through this gateway, and it shows you how.NET can scale. You've got your Cloud
scale performance, highly extensible and customizable. It runs on a variety
of our.NETs and it's open-source and used by us around
some of our biggest services, so I'm super excited
about this project. The next thing I think about
when I think of Cloud is, what are some of the
common patterns that developers building
Cloud applications use? One of those is going to be an
N-tier scale web application. That's where we've
got a frontend with a backend and some
database on the backend, and.NET is great for
building these applications. It was designed for this stuff. The second type of application is the microservice
type style application. This is what's more modern. You hear words like
containers and Kubernetes, but the real point of this is breaking your application
into more pieces, and each of those
pieces can scale up and scale down independently
of each other. It also gives your teams a better
way of working because they can version each of those
components separately. The cool thing about
this is.NET is great for building all these
types of applications. One of the core tenets of our
team has been focusing on the N-tier and the microservice
style applications and we'll do a demo of some
of that in just a second. If you build those
types of applications, Azure is a great place to host them. I'm happy to announce today that.NET 6 is available in Azure App
Service in all regions, both on Windows and Linux. It's available in Azure
Static Web Applications as well, with Blazor WebAssembly, with AOT support, and it's available in
Azure Functions both in-process and isolated models. If you want to take
your.NET 6 applications, host them in the Cloud, we're
ready for you right now. Now there's a new thing
we announced just last week called Azure Container Apps. As you start thinking about building these microservice applications, we want to make sure that both Azure and.NET is completely ready for you. The big thing here is I mentioned
a lot of terms earlier, Dapr files, Kubernetes, Helm
charts, all these things. I'm an app developer. I want to focus on my app, not the infrastructure and Azure Container Apps
enables me to do just that. It's actually running on Kubernetes, but I don't have to think about
Kubernetes and all that stuff. I can just think
about my containers, publish them up, and they just work. Now you might ask, what
does it do for me? It does a lot of things for
you, it provides scale. You're going to see a
demo of that in a second. It provides the ability for each
of these apps to see each other. In a microservice world, each app has to be able
to talk to each other. It enables that because they're
running all in the same cluster, it enables you to actually see, roll forward and roll
back your applications. That's going to be
Azure Container Apps. It's a great way of building.NET
applications for Azure. I'm also excited to announce
that with Visual Studio 17.1 that's the preview of the next minor version
of Visual Studio, we've already got support for building worker
service applications. Right from Visual Studio, you can publish right to
Azure Container Apps. In the next preview version, we're going to add
all of the web types. You can build an ASP.NET
minimal weight API and easily publish it
right from Visual Studio. Now with that, I'm going to
bring up David and Scott, and they're going to
talk about how they can build these microservice-style
applications with.NET. >> Thanks, Scott one. >> Hello, Scott two. >> Hello. >> Nice shirt. That's pretty good. >> It's pretty good shirt. This is actually a
shirt the team made, actually it has the commits and on the back there is actually a button
[inaudible] about the product. >> Very cool. I like that shirt. >> Yeah. >> I want to trade. >> Not for sale. >> Not for sale. All right. Let's context setting. We saw Maria and Mads wanted
to go and they were making a minimal backend web
API because we're building a podcasting application. >> A podcast, that's right. >> What's our role in
this podcasting app? >> How do we get podcasts
in the first place? We need to figure out
how to get podcasts in the system to actually
expose it to our clients. >> Podcasts are usually RSS feeds. The naive thing to do would
be to have a client app talk directly to your podcasts
and get your RSS feed. >> Every single time. >> Well, that scale. >> It's expensive. I can't do that. Instead we want to
have the frontend API, have an ingestion
point where I can send an RSS feed and it will
put it into a background create cube because they want
to process that feed to do a whole bunch of things,
compute intensive things. >> The RSS feed gets sent
in and put on a queue and we don't know
whether it's going to be one a minute or 10,000 minute. We strike it on Hacker
News, it could be a thing. >> Could be a Buzz. Yeah, exactly. >> We need to scale a
little startup here. >> That's right. >> All right. >> We have two applications, the pockets API for the backend and a background worker and
a queue in between them. >> Background workers
have historically been complicated because an ASP.Net app is usually good for a request came in and
a response comes back. There's a long running
background thing. >> That's right. >> Then you just said
it has to scale too? >> That's right. >> Okay. That's hard sometimes. >> It's hard. But luckily we
have a first-class thing called a worker service in.Net for these background
workers, specifically. >> Let's see it. >> All right. Let's
jump to the code now. Let's go into the project. This is the back-end
API that Maria and Matt showed. Should we zoom little bit? >> Okay. >> The QueueClient right here is the address toward SDK QueueClient. I'm adding it to the dependency
injection container. I'm grabbing the connection string from configuration called phi-Q. >> Okay. >> Then we're going to scroll down, all the way down to
a minimal endpoint. It's very succinct right here. The v1 feeds endpoint is going
to inject the QueueClient via dependency injection in the
argument. It's very nice. Then we get the RSS feed
injected from the client, the client sending a
post to our endpoint. I'm going to create the
queue if it doesn't exist. Then we're going to put a binary serialized
payload into the queue. We've got our important
from the actual client. We're going to put into the queue
and we're off to the races. >> You've posted that to that endpoint and then
you have to ingest it, put it into the queue, and then some workers will pick it up later? >> That's right. >> All right. >> Let's jump to the worker service. This is a brand new.NET
six worker service, which is using minimal
API style code. There's global usings
top-level statements. Now we have, instead
of 20 lines of code, I think, let's say 40 lines of
code, not 24. That's our code. >> Twenty-four. I'm
noticing you said, this line 1, there's no line 0. >> Exactly. >> We saw what Mads and Maria showed
that the usings are implicit. We got to outdent instead of indent. >> But still work having my
code push up against the left. >> It's too far left. >> It's nice. I'm configuring Office to our Local DB,
which is SQL Server. >> Yeah. >> Our QueueClient is
being configured the same way it was configured
in the web API. Then we're going just
to add some code to handle incoming feeds off the queue. We're going to jump into
the worker service. >> We've got this ad
hosted service worker. >> Yeah, this thing runs
forever in the background, doesn't have any traffic. >> Okay. This is the
actual worker right here? >> Yeah. >> It's an internal class and it's derived from background services. >> That's right. >> It runs for a long time. >> All right. >> We grab the QueueClient, the same one that we
got in the rest API. We're dequeuing a message from that. >> Yes. >> It's going to have
a single feed item. >> The feed item comes in and
it goes into a queue and then I'm just one background server and I pick it up again and look
at it and do some stuff. >> Yeah. >> Okay. Then we do some dependency that doesn't
match, it will skip over. >> Yeah. >> Then to the important part, we grab the body of the message. >> Yeah. >> Scroll to the right.
It's a little bit. We convert that thing from JSON, because we added JSON
payload to the actual queue, and now we're going to
grab it as a record, and we can actually deconstruct it. It's pretty cool feature of records. >> What's that? What are those? >> See you've got the
record and we actually pulled out to the properties
without having to do anything else. This is the C-Sharp
feature, I believe. >> Nice. That's an unnamed
object itself record out there, just like Mads talked about. >> Yeah. >> Very cool. All right.
So that picks it up? >> Yeah, and then we
ingest into the queue. >> All right, but Hanna
was talking about Cloud Native and
containers and scale. You just showed me how one worker can pick this
thing up and do a thing. >> That's right. >> What I want to do it n times? >> If you wanted to, typically, what you would do is you
would scale out your workers on-demand based on the load
of the queue, the queue size. >> Okay. >> If I get Hacker News, if I
get spammed for some reason. >> You could be Hanselman. >> You could be Hanselman. You got a big ingestion
of queues and then you would get more worker
services to hire the load. >> All right. Well, we've
heard about containers. How do I get this into
a container then? >> All right. First, we
have to containerize the application by
adding Docker support, this is a keynote, this
has been done beforehand. >> Yeah. >> But we can do it really easily. Just right-click at
"Docker Support." Cool. >> Now we have it
for our podcast API and for our worker. There's
two Docker files there. >> Yeah. >> All right. Now
with magic demo gods, I'm going to show you the live
service running in Azure. I'm going to escape that part. >> We login to the Azure
portal on the portal, hit "Refresh" as it logged us out
because we've been hanging out. >> All right. >> It's okay. We took too
long before we were waiting. Will log you back in. >> It's running in
Azure. We promise. >> There you go. >> There's [inaudible] application. >> We've got a resource group. >> It's running as
an Azure Container because you actually
have a microservice. >> Cool. >> Here's the environments,
scroll down a little bit. >> Scrolls. >> We should see classifications, the API, and the podcasts worker and is warmer but I
won't talk about. >> We got the podcasts, we've got the ingestion. Cool. >> Yeah. >> It's up there in a
container right now. >> Now we want to show
you web-scale. Here is- >> Web-scale. >> Web-scale. I have a script that will simulate a ton of the
users here in my backend API. Right now there's nothing running
through the background queue. >> Okay. No replicas. >> I'm not paying
for any compute now. >> Cool. >> Yeah. >> We're not famous yet? >> It's free. >> It cost us nothing. >> It's free. >> Let's do it. >> Now we going to hit "Enter." >> So you're simulating
traffic right here? >> Yeah. >> You grabbing,
hopefully in my podcasts. >> I got Hacker News and
now it's going to scale up. >> [inaudible] I guess. >> I hope it's going to scale up. It's going to go from zero. >> You just did a bunch of requests
and we've got a replica here. Then how do we know
when it succeeds? >> It's going to hit
one at some point. >> Okay. Takes a couple
of 10-20 seconds. >> It's sync itself. >> It's probably already happened. >> It's possible. >> Which one of
these? This one here? >> Yeah. It probably will show up. >> Okay. Do we have to
run this multiple times? >> Let me show you one thing. >> All right. >> Let me try. >> If we figure out something, oh, you're going to run
the while statement again? >> Yeah. >> What? >> You see a movie three by three. >> You were hoping that that
would automatically update but that little sleeper
probably fell asleep. >> Yeah. Fell asleep. >> Cool. That means that
it now went from zero, no money to three, and then when it's done, it will
show back down there one or two. >> That's right, after
the whole keynote. >> After the keynote. >> It will be zero. >> Very cool. All right. >> This will web scale. >> Yeah. >> Microservices. >> Container apps. >> .Net container app Docker. >> Long-running background services. >> Yeah. >> Then, now our client team
is all set up for success. >> Yeah. >> Very cool. All right,
let's bring it back to Scott. >> Thanks, David and Scott. Let's talk about
client developments. We shipped Blazor a
couple of years ago, and Blazor is a great way of building full-stack web
applications with.NET. Blazor lets you build a modern client-side
application just using C-Sharp, you don't have to write
any JavaScript at all. We have two models of
building Blazor applications, you have a Blazor
Server application, which is when you have
the full power of.NET. Because the app is actually
running on a server, and as I make changes
to the application, a request is sent
down to the server, it sends the state back and
we redraw just the parts of the screen that need to be updated. It's an amazing tech
because it gives you a super lightweight
spa-style application, hundreds of bytes versus megs. But there's also another flavor of Blazor called Blazor WebAssembly. In Blazor WebAssembly, we use
the power of WebAssembly to run your entire Blazor application
directly in the browser. Now, this is cool because
an application like this doesn't even require the Cloud. You could actually run a full app like a game or something that runs totally in the browser with
no connection to the backend. We offer you these amazing
choices of building whatever frontend app you
want to build with.NET. It gets a lot better with.NET 6. Those Blazor WebAssembly
applications, we actually interpreted
them and using a wasm interpreter in.NET 5. With.Net 6, you can compile your entire application before we
call it ahead of time compile, which means the app will run much faster and it more native
speeds in the browser. Another thing is, I mentioned before one of the
benefits of Blazor Server is small footprints of
metadata goes to the browser. We've done a lot of work in.NET 6 to reduce the size of a Blazor
WebAssembly app as well. Dan's going to show
that in a little bit. Those are just a few of the things
I'm going to let Dan really do a deep dive into all
the cool stuff that's coming in Blazor and.NET
6 in just a second. But I'm also excited about
Blazor Fluent UI Components. About a year ago we started
working on Microsoft Teams. There's a mechanism
that you can build apps that can be hosted
inside of Microsoft Teams. If you're a.NET developer, you can build a Teams
application using Blazor. We had to make sure that
those Teams applications looked appropriate inside
of the Teams client. Teams is built using
something called Fluent UI. It's some UI standards built by
Microsoft, and what we've done, you can see here we've got
40 plus Blazor components that wrap Fluent UI, which allows you to build
applications that look amazing and look like modern Microsoft
applications using Blazor and.NET. You can see your integration
with web Windows, Teams, Office, and more. I think maybe they're going
to show a little bit of this. I know they're going
to show a dark and a light theme thing in a second. But super excited about these
new components for Blazor, so you've got all the
Blazor six features, Blazor Fluent UI Components. Then, of course, you just can't talk about
client with Blazor, we also have to talk about.NET
MAUI or.Net Multi-platform App UI. This is one of the exciting
features to me in.NET 6. It's going to ship early next year. What this is it's an
evolution of Xamarin. Xamarin was a library or a product for building iOS and
Android applications on.NET. But we thought let's take
that to the next level. Let's actually let you build
apps that run on Windows, Mac, iOS, and Android. One single codebase can target
all of those platforms. We also took the Xamarin and
enhanced it again as well. With Xamarin, you had
a project for each of these different platforms. Now, we have a single
unified project, one project can support
all of those app types. You can right-click in the IDE and deploy to the various
targets you want to do it, and I said it's going to
be available next year. Another cool part about MAUI
is it's not really a UI stack. If you look here, notice on Windows, it shows WinUI, on Mac, it shows Mac Catalyst,
iOS and Android. What MAUI actually is
doing is abstracting each of those platforms and using the actual real
underlying technology, so your Windows app, if you build a Windows MAUI app, it looks like Windows. If you build a Mac app,
it looks like Mac, and that's one of the cool
aspects of this technology. I'm super excited about it, it's going to ship early next year. Then we thought, let's take
it to the next extreme. I'm a web developer, but just
because I'm a web developer, I still might want to have
access to a desktop or a device. We're going to let you take
Blazor and.Net MAUI and merge them together into
a single unified stack. I can build a MAUI application, I can reference a Blazor project, and that lets me build a
desktop application using web, which means I can share
all my web components across all these
different platforms. Whether you're a web developer or you're a native
application developer, you get the best of both
worlds in.NET between MAUI and then Blazor and.NET MAUI. With that, I want
to move and talk to a couple of customers that
we have running on.NET. This is Powered4.tv. It's a start-up media
company based in the UK serving 65
countries worldwide. They provide independent on-demand wrestling content to their viewers, they use Blazor WebAssembly for
their frontend and ASP.Net Core on Azure and are very happy with the productivity
performance and scale. In fact, they've been using.NET 6 release candidates for
the live site for a while. Check out Steve's talk
later in the conference. Also, I want to talk
about Pronto Pay. Pronto Pay is another startup
based in Houston, Texas, that chose to go into
production with.NET MAUI because they
needed to move fast. They love the simplicity of a
single codebase that they can build to target multiple devices and the productivity
of Visual Studio. Then GE Digital Aviation, they are a group that
developed FlightPulse an app that puts data
and analytics in the hands of more than
3,000 quantize pilots to help them improve safety and
efficiency on every flight. The Config Console is built with Blazor and they were
able to work faster, share more code, and it was a lot more seamless
development experience than they had previously
had with Angular. With that, let's roll a video. [MUSIC] >> Flying an airplane
is no small feat. Commercial pilots must
make hundreds of decisions to get passengers to
their destination safely. But what if we could give pilots the tools to make better decisions? To understand how their actions
affect critical areas like safety, fuel efficiency, and sustainability. [MUSIC] GE Digital created the FlightPulse
app to meet this challenge. Connecting millions
of data points from on-board sensors to give
pilots true insight. Built on Microsoft
Azure and using Blazor, a framework for developing
web UI with C# and.NET. FlightPulse provides
crucial flight data to the people who need it most. GE developers built
the backend APIs for FlightPulse with ASP.NET core. They chose Blazor, a feature
of ASP.NET core for the UI. Because Blazor uses C# for
both client and server code, developers could
easily share code and logic between the front and backend. Backed by Blazor and other
Microsoft technology, GE was able to work faster
and more efficiently bringing flight pulse to life
in months instead of years. Now pilots can review their post flight data and
make important adjustments. In fact, pilots have increased
their performance of fuel efficiency techniques by up to 15 percent, reducing
carbon emissions. Putting useful data into pilot's
hands, benefits everyone. Together, GE Digital and Microsoft are making the
skies a better place to be. >> I'm excited to also
mention that.NET MAUI Preview 10 is available today. You just have to grab the preview
builds of Visual Studio 17.1. If you didn't know this, you can actually
install Preview Build side-by-side with the RTM build. They don't mess with
each other at all. It's actually safer, I've been
doing it for years at this point, and so if you want
to try that in MAUI, grab the Preview Build, it will not interfere
with your RTM build. The Preview 10, has a few things, Windows app SDK, fully integrated, more controls, performance
improvements for Android, and a lot of layout
improvements and bug fixes. As I said before, this is
going to ship early next year. Now that we've talked about some
of the client technologies, I'm going to bring up Dan,
to talk about Blazor. >> All right. Thank you, Scott. Hello, everyone. Well, we just saw how we can build a simple and scalable backend
for our.NET Podcast app. Now let's use ASP.NET
core and Blazor to build a beautiful modern web
UI for our.NET Podcast app. I've got the front
end application here, let's go ahead and get this running. Go ahead and build and
get going, there it is. We have this beautiful landing
page for the application. It's got a nice
modern responsive UI, looks great on big screens
and small screens. This page was actually built
using ASP.NET core Razor Pages. It's being dynamically
generated on the server. But if we sign into the Podcast app, now the Podcast app part, this was built using
Blazor WebAssembly. It's running client-side in my browser on a WebAssembly
based.NET runtime. This is full stack web
development with.NET. We've got a bunch of features
already implemented, we can check out one
of these podcasts, let's check out
the.NET MAUI Podcast. We can select an episode, let's go ahead and play that. [MUSIC] >> Yeah, I got in-browser
playback, got nice, jazzy theme song, I would definitely going to
want to listen to that later. Let's go ahead and mark it
actually to listen later using this little icon that will make that episode show up in
my listen later lists, so I can remember to listen to all those podcasts that
I want to listen to. We can also go back to the
Discover page and you saw these little plus icons
on each of the podcasts. We can select podcasts that
we want to subscribe to. What's subscribe to.NET
MAUI, maybe this one. Now I'll get notified when there are new episodes
for these podcasts. I want those to show up here
on this subscriptions page, but nothing is showing up there
yet because it's not implemented. Let's take care of that now. I'm going to snap the
browser over here to the side with Visual Studio. Let's give ourselves a little
bit more room to see the code. Here's the actual
subscriptionspage.razor file, and you can see I've left
myself a little to do here to actually add some code. We're already loading all of the subscriptions into this
show subscriptions variable. Let's render them. I'm going to delete
that and let's add, I don't know, let's
add an unordered list, and then let's do a four each over each item in the show subscriptions. There they are, great. Then inside here, let's render list
items for each one. There we go, and after we got that, we'll go ahead and, I don't know, let's just render the title of the podcasts just so we get
something on the screen. Item.Title. Okay, great. That should be good. We're looking all right here. Yeah. Now, let's go ahead and click the Hot Reload button to apply
that to our running application. Boom, it just shows up. Almost instantaneously. Hot Reload will apply
my code changes to the running app while it's running without having to
rebuild and restart. You preserve all your App
State, you can be productive, and code, and build your UI quickly. Let's add
some more stuff in here. Let's go and let's show the author, I don't know, we'll just throw
in an H3 header in here. Item. I need an at sign, so it's actually an item, author. This time instead of using
the Hot Reload button, I've already set up this
setting right here where we can Hot Reload on File Save. I'm going to hit the
Save button this time. Looks like I have a bug in
my code. What did I do? That little turn at the end there. Let's save that right here, and boom, Hot Reloads
into the application. Great. We're going
to need some images, so let's do image, source, equals and I think
on each item there is an image property that we
can use to get the image URL. Let's close that off, save one more time, and we're seeing our
images on the screen. Great. That's Hot Reload. Now, obviously, we've got
some styling issues here. We need to fix that. I've already got a
show card component that's part of this
application that I'm going to use to render each show. Let's remove all the stuff
that we hand typed before and let's just put in this
custom made component. What is this doing? Well, let's go to definition
to see what it does? In this show card component, we have a card and it
has an action menu, and inside the action menu, that's where we're actually going
to render the little plus sign so we can subscribe to each show. Then if we look at the
definition for the card, that's pretty simple, that's just divs and rendering
the picture and so forth. Let's go ahead and Hot
Reload that, we'll save. Now we're getting somewhere, so
we've got full width images, we got styling for
our title and author, we can see the little
action on each show. Now, if we unsubscribe it then disappears from the
subscription page. We can add another one
back if we want to, and that should then show up on our subscriptions page. That's good. It's not quite what
I want yet though, I really would like these podcasts to look like the ones
on the Discover page. This grid like layout. Let's see how that's done
on the Discover page. Well, it's got this grid
component that it's using to lay out
each of the podcast. Let's just copy that,
we'll just reuse that. We can get rid of our unordered
list and just put in the grid, a little formatting here. Then I think we going to
change the code up here. Let's remove this group, that value, and put in our show subscriptions. We're iterating over that, and I don't even think
we need this T item here because that should be inferred. Now when I save this, well, Visual Studio now is
telling me that this actually was a change that
can't be Hot Reloaded. Involving, a little too much
stuff, and that can happen. Some changes are not
supported with Hot Reload. We are working on expanding
the set of changes that are. But when it does, Visual Studio
will prompt you and let you know, hey, you need to rebuild
this application, which is this first option, or you can go back to editing
if you want to fix things up, and there's even
this option up here, this checkbox, so you
can say, you know what, I always want to rebuild
whenever this happens, so just go ahead and do that for me. I'm going to go ahead and go
back to the subscriptions page, rebuild and apply the changes. Hopefully if I did everything right, then we should now
see our subscriptions nicely laid out in a grid, just like they are on
the Discover page. It's rebuilding and it refreshes
the browser for me automatically. Beautiful. That looks exactly
like how I want it to. One last thing I want to fix, if
I remove all my subscriptions, I'm just going to uncheck
these, they disappear. Now I'm left with this blank
screen. That's not very nice. Let's add a little bit of UI
when we have no subscriptions. Add another little
snippet right here that I'm just going
to copy and paste, to save on some typing,
and go back to the app. In this Empty results for this grid, we're going to add that
little bit of content. Then we'll save that into
Hot Reload one more time. Boom, we've got our nice
little UI placeholder. We can go back, discover podcasts, subscribe to a couple, and now they show up on
our Subscriptions page. Awesome. That's Hot Reload. You can get productive fast. Looks like this app
is ready to publish. Let's go ahead and
publish the application. I'm going to go to the
Solution Explorer, right-click on "Podcasts server", the server project, and we're
going to publish this application. When we do that, this is
a Blazor WebAssembly app, we want to use all of the
new optimizations in.NET 6 to make this app nice
and small and load fast. In earlier versions of.NET, we could trim the.NET code to remove any code
that you weren't using. We would pre-compress the
files to make them as small as possible using
Brotli compression. But the.NET runtime itself, which was implemented
in WebAssembly, was kind of a fixed quantity.
Let me show you what I mean. Like in this app, even in
development, we can see this, If I F12 to see the
browser dev tools, make this a little bit bigger. Let's just clear out
the site data so we can see all the files
get downloaded. There's lots of stuff
that'll be downloaded during development because
it's unoptimized. But if we look at the
dotnet.wasm file, the runtime, that
guy is a little big. For a runtime, it's pretty impressive
that it's only a megabyte. This is only gzip compressed. If you Brotli compressed it, it does get smaller
like 7800 kilobytes. But can we do better? The answer is yes. In.NET 6, we can. We have this new.NET
WebAssembly build tools that you can install with Visual
Studio or with a.NET SDK. These build tools do
a number of things, they allow us to
ahead of time compile our application for much
better runtime performance. We can link in native dependencies into
our Blazor WebAssembly app. In this case, what
we're going to do, is we're actually going to re-link the runtime to remove stuff
that we don't even need. I've got the tools installed, so all I have to do is publish. If I go back to the
app, let's actually do that publish now,
right click "Publish". I've already actually
done this before. It does take a little while to
run all those optimizations, but we can go ahead to the
Published output and let's run the server. There it is. When I've done this in
the past, typically I hate this caching issues, so we're just going to
fix this real quick. This is from the previous demo. We're using the same
port as an earlier demo. I'm just going to right-click
"Empty cache" and now refresh. Now when we go to
the root of the app, hopefully, yes, we can
see the application. If we go to the podcast app, and leave the browser dev
tools up because we want to see that dotnet.wasm, there it is. If we look at its size
now, only 350 kilobytes. Dramatic size reduction. Our app loads much faster. We can do even better with.NET 6, by prerendering this
app from the server. We can take those same Blazor
components and render them server-side so that we get HTML and pixels on the screen
almost immediately. With.NET 6, we can actually take any state that you used while
prerendering, like you go, went and fetched all the podcasts, and we can persist that, into the page so that it can
be reused on the client. Notice if I refresh this
app, refresh, refresh, I can just keep refreshing, it loads almost instantly. There is no loading spinner, there is no loading... That's
because it's being pre-rendered. If we look at the
source for the page, the HTML that we got
from the server. Here's all these devs,
these are all the podcasts. They're already
rendered into the page. At the very bottom there's
this Blazor component state. That's the podcast
data that we got from the server that we can
then reuse on the client. That state preservation
during prerendering, new in.NET 6. Last thing. This thing of course is got
to be a progressive web app. You can see that Edge is recognizing that it's
a progressive web app. It's got a web service
worker and a web manifest. We can install this on our Windows machine and now
we've got a nice native shell. Looks great. We can
listen to podcasts. This is now a stunning web
application built with.NET 6. But if we really want to deliver an elevated experience
to our podcast users, we're actually going to want to have native client apps for mobile and desktop that can take
full advantage of the capabilities of those devices. Do things that you might not
even be able to do on the web. For that, we're going
to need.NET MAUI. That's what Maddy, I think, is going to show us now.
Come on out, Maddy. >> Thanks, Dan. Let me
switch over my desktop. Great..NET MAUI is the best
way to develop apps with.NET, and C#, and XAML for Windows, Android, iOS and Mac catalyst. Your desktop platforms,
your mobile platforms, all of the things you
could possibly want. Right here I actually have the same app design that
you just saw from Dan. But instead of being
built with Razor, it is built with C# and.NET. Let's take a look at
the Solution Explorer, when I come find my mouse. You can see it's kind of the
MVVM you know and love if you've built a desktop or a
mobile app with.NET before. We've got our views
and our view models, we've got some other
stuff in here for Blazor, and we'll look at that later. I just have some
pages right here and all the things I could
possibly need it to build a beautiful app with XAML, and.NET, and C#..NET MAUI, like Scott mentioned,
is really built on this foundation of
being really simple. We have one project for you where all of your code lives
and that's right here, that's this Microsoft Net
Conf 2021 MAUI project. It's got one project file, where I have all the
target frameworks listed using
multi-targeting with.NET 6. I can also set all of the attributes of my
application in this one place. It's just called.NET Pods. I have my app ID, my version, version 1, because this is the
first release of this app. Some target framework stuff for the supported operating systems
for the platforms I'm on. Then this is probably my
favorite part of.NET MAUI, all of our shared images
are declared right here. We see that we're just including the wildcard folders for
these images and fonts, which in my Solution Explorer are
right scroll, resources, here. I have some fonts, some images, I have shared strings, I have shared styles. Then I have these SVGs here as well that are called App icon and splash. With.NET MAUI you can use
SVG files right off the bat. That means they're going to
scale perfectly for you no matter what device or
resolution you are targeting and you don't
have to mess around with all different types
of PNGs and sizes. But something that we do
that's really cool is we dynamically create
for you app icons and splash screens based on the files you give us in the attributes you set
in your project file. This is just a Maui
image and you can see as my resource is the
app icon right here. I have a foreground file. This app icon back here is
actually just a background color. Then I have my foreground file, which is the foreground, so that's little logo
of the podcasts app. Then I just have is app
icon true? That's it. That tells the app that when it builds this and bundles it and makes the package native for the device or the a platform
that it's running on, to use that as the app icon. Same thing with the splash screen. The splash screen or the loading
screen or the launch screen, whatever you want to call it, we just have an SVG we give
it in a background color, and that pops right up
when we load up the app. I have it running here
already on Windows. You can see it's the same
app, but like I said, it is in XAML and C# so there's a little bit different
styling because my app isn't quite
as pretty as Dan's, but he worked really hard
on it, so it's fine. It's the same thing.
I can click around, I can see everything,
I can subscribe. This beautiful subscription
functionality is wonderful. But I have all of the
tooling that you'd get for Windows apps and this is using Winamp SDK so it's
WinUI 3, this app. I get all of that tooling inside of Visual Studio 2022,
which shipped yesterday. I am in Visual Studio
2022, Preview 1. The Preview release, which
also shipped yesterday, which is where you're
going to get all of the Maui development tools and the Maui workload installed right
for you, from the installation. Like Scott said, great to
run them side-by-side. Let's go into a XAML page here, we go into the Discover page. We've got a lot of code here. One of my favorite
things to show off the beautiful XAML Hot
Reload is to first, pop it into XAML live preview. This is actually the
same app. It's this app. It's taking a second to load. That's okay, we can restart it
if we need to. Let's do that. I played around with it
too much. That's okay. A lot of rebuilt. Then we're going to
look at live preview, which you might have seen from
some of the demos yesterday. Live preview is the
ability to actually mirror the app that's running
in Visual Studio. Instead of having to
click in between it being up and top of my
screen right now like it is, or move it to the side or
move it my second monitor, I can just pop open live preview
and I see it right here. I can add my ruler and my grids
and all the great things. On my collection view here, let me pin that, on
my collection view, which is this collection of all the different
podcasts we have here. I'm just going to add
a background color. I'm going to make it hot pink
because it's going to be very obvious when I make this beautiful hot pink
background change. I'll zoom this in a little bit. I can see that I can
add my grid lines. It's just the app that's running
right here in Visual Studio. I can also go ahead and inspect
different parts of my UI. Let's pull up this live visual
tree here and expand this app. I can see that this is a Shell App, we're using Shell to
describe our navigation. It's just four tabs, discover, subscriptions, listen
later, and settings. I could open it up and click around. I can see this collection view. I can go to where that's
defined in the code. I can really easily navigate all my XAML even on this super-constrained screen
right now because I'm zoomed way in so you
can see it and find all the different
things I need so I can make the edits I
need really quickly. Let me get rid of that
hot pink control Z. There we go. Don't want that. Let's take a look at this at the second platform I want to
show you, which is Android. I have a platforms
folder in this project, and it has some of the
native code I need to tell an app how to start on
all the different platforms, so we have Android, iOS, Mac Catalyst, and Windows. Because this app is multi-targeted, I can go into my regular
debug and deployment dropped down my platform selector,
wherever you want to call it. I can change my framework
right here to.NET6 Android. It pops up with this
long titled thing, which is a beautiful new feature of Windows 11 called the Windows
Subsystem for Android. I'm going to start building this. Give it a second. I'm going
to tell you how I did this, which is by using the
Android Debug Bridge, the ADB, which is part of the Android Development Kit that's installed with Molly
in Visual Studio. You don't have to do anything
special to get that. I opened up the Windows
Subsystem for Android. I connected to the port, and now my computer
believes that this is a physical Android device
plugged into my machine, but it's just showing up
right here on my screen. This is the same app, the same code I just had on Windows, but now it's running on Android. I can prove this to you by
doing another hot reload here. Background color is hot
pink and there we go. Nice and ruining this beautiful
app with my background colors. The Windows Subsystem for Android
it uses the Amazon App Store. If you need to use
the Google Play APIs, this might not be the
right solution for you to test that specific functionality. But you can use this
just like an emulator, except it's as you saw, a lot faster than what you
might expect with an emulator. Or you can use a physical device. There's all different ways
to debug and target Android. You can do what's best for you
depending on the needs of your app. Since this app is not using
any Google Play APIs, I have no problem using the Windows Subsystem for Android here and it's awesome
and works great. I still have my live visual tree
here so I can click around. That's 1/2 of the MAUI story. We're going to flip over to the Mac. You can tell that this is my Mac because it has all
my stickers on it. Up here I have the same app, again, the same XAML, same C# running
on an iPhone simulator. It's in dark mode because
dark mode is the best I can flip it on and off, beautiful. I could do all the code
editing I want to do here. This is Visual Studio
for Mac Preview, which released yesterday as well. We are currently working on.NET MAUI support in
Visual Studio for Mac. You're not going to have as full and robust of an experience as you
have in the Windows preview yet. We're looking at
releasing that in preview early next year for
Mac and then shipping it with.NET MAUI when we do
ship general availability. But it's still a great text editor. It's been rebuilt
from the ground up. They're moving it to.NET 6. VS Mac is going to be built on.NET
6 in just a couple of releases. It is going to have native Mac M1
support for the new processor. It's already super-fast, but
it's going to get even faster, which is very exciting. Yes, so I have it on
the iOS simulator here and I can interact
with it and all the things. It's beautiful little layout stuff that I can go tweak if I
want to because this is now rendering using the iOS controls
for the native iOS platform. Then there's one more
I want to show you. Let's pull this up and I think
I have it running and I do. Finally on my Mac. This is running natively on my MacBook using what's
called Mac Catalyst, which is Mac's and Apple's
cross-platform technology to run the same app for a MacBook, for an iPadOS for on an iPad, and for an iPhone. We can actually deploy this version of the app onto all those devices, which is really exciting,
but it's the same thing. Of course, I have my dark mode. Got a habit, it's
great. Turn that off. This is all, again the same code. I know it sounds like
I repeated myself, but I am just so excited that
we can have this one project. The same pages, the same MVVM and C# and XAML and all
the things running in all the places using the
amazing tooling that we have with Visual Studio
and Visual Studio for Mac, for iOS, Android, Mac, and Windows using.NET MAUI. >> Maddy, hold on. >> Oh, no. >> Before you wrap up, I can tell you're about to finish. I have something to show you. We just added something to
the Blazor web application. >> Okay. >> It's super cool.
Let me show it to you. Let me bring up a browser here. I'm going to go into the site
that we've deployed to Azure. When you sign in now. There was this listen-together tab. You may have noticed that
before it's now working. Yeah, go to the site on your Mac. If I click "Pick an Episode"
like, let's just pick this one. There's this icon over here
called listened together. I can select an episode and then let me type in my name
and this will create a room. Then you should be
able to join my room. >> I see it. >> This is using signal r.
It's a real-time experience. Now we can listen to
this podcast together. Let's go ahead and get to go in. [MUSIC] >> Yeah. >> Okay. >> Even better you can react. I see you're sending me some hearts. I'm going to send
you some thumbs up. I think this is a
really great experience for listening to podcasts
with your friends. >> Yeah. >> Can we get this
in the MAUI version of the app on mobile and desktop, it's just a Blazor component. >> Dan, I'm lime 10 steps
ahead of you. Don't worry. Let's take a look at
what I've done here. I brought in that same component
you're using in that Blazor App. I brought it into my
MAUI project here. I just linked, it is just a
library, Podcasts Components, and I referenced it
in this page we have, which I had app the
Listen Together page. That's just a Blazor Web view. >> A Blazor, it is like a little browser control
in your MAUI App. >> In my MAUI App. My
Listen Together component, I reference right here
this is an component type. Then in my Shell, which
is again how I describe the hierarchy of the
navigation of my app. I just added a Listen Together tab. >> Does it work? >> I go here. Let's see, it's loading with Blazor,
that's your room. >> Can you join my room? >> I'll join as Maddy 2. >> You can never
have enough Maddy's, you can never have
enough. Let's see. >> Then I'll clap. >> Yeah, we're listening to
the podcast, oh, my goodness. >> It works. >> Lots of applause. >> This player here, this is cool, is native to the Mac. That's actually built with the code necessary for Mac to have
the best player experience. That's a Web Player. On there it was the Android player. Now it's all back.
I don't want to put the crying emoji because I'm
so happy this demo worked. >> Native.NET MAUI
App with native UI controls with Blazor
Web UI altogether, cross-platform, desktop
and mobile and web. That's pretty amazing.
Thank you for doing that. >> Thank you. >> We're going to turn it
back over to use Scott. >> Thanks, Maddy and
Dan, that was great. With that you've seen a lot
of the cool technologies that we're releasing with.NET6. My ask to you is go grab.NET6 today, download Visual Studio 2022 today. Go try the upgrade assistance
and try out the MAUI previews. I will tell you, sitting back and being part of the keynote and watching all
the things that we released today is never a better time
to be a done a developer. Please have a great conference and ask us lots of
questions on Twitter. We're going to be there
all week. Thank you.
Hmm. Wonder if there'll be any surprise features like how we got Web Forms Dependency Injection support in .NET 4.7.2.
(Pretty please make ASMX web services finally respect
Application_Error.)I'm really not liking minimal APIs. Just because you can put the whole application in a single file doesn't mean you should.
I'm not sure why Server Side Blazor still exists. It looks like WASM Blazor in .NET 6 now addresses all of the problems that I had with the previous version.