|<<>>|8 of 339 Show listMobile Mode

A review of 35 Microsoft Ignite 2025 dotnet videos

Published by marco on

I watched/listened to 35 videos, each between 20 and 30 minutes long, and each listed below. I’ve grouped them but retained the order in which I watched them. I’ve left the notes mostly as I wrote them, which is kind of stream-of-consciousness, kind of snarky.

Some videos that I didn’t like got a lot of notes, some videos I liked got fewer notes. It might seem like I hated the video from my snarky notes but I still ended up rating some of them as 🆗, which means that I thought that either the video was well-presented even though the material doesn’t have much broad appeal or that I thought the material was important even though the presentation wasn’t that great.

Don’t read too much into it. The notes are just to help me remember what I learned from the videos—and can hopefully give you a bit of an idea of what the video is about and whether you want to spend 20–30 minutes on it. YMMV.

Microsoft Ignite 2025

C#, F#, & .NET

🆗 Nullable Reference Types: It’s Actually About Non-Nullable Reference Types by dotnet | Shawn Wildermuth (YouTube)
This is a decent, thorough—though somewhat slow—introduction to non-nullable reference types in .NET/C# (which have been available since .NET 3.x / C# 8). If you already know about them, then there’s nothing new here.
✅ Performance Improvements in .NET 10 by dotnet | Stephen Toub (YouTube)

An in-depth examination of performance improvements in .NET 10. He explains how the various compilers (AOT, JIT, etc.) have been optimized to eliminate allocations and just generally optimized for performance. A reduction in allocations is a multi-win: the performance is better because the allocator isn’t working, the memory usage has dropped, and the garbage collector also works less.

He compares .NET Framework 4.8 vs. .NET 9 vs. .NET 10. The most impressive improvements are from 4.8 to 9.0, of course, but he highlights some interesting places where .NET 10 eclipses .NET 9, where .NET 9 had already eclipsed .NET Framework 4.8.

The last example shows how regular expressions have been continually optimized so that an operation that took 24ms in .NET Framework 4.8 was improved by about 12x to 2.5ms in .NET 9 but has been further improved by about 62,500x to about 40ns in .NET 10.

For more coverage, see Toub’s 232-page tour-de-force on performance in .NET 10.

🆗 Community Toolkit Roundup by dotnet | Gerald Versluis, SergioPedri, Michael Hawker (YouTube)

They spent some time touting the benefits of the toolkits.

  • There is an introduction to improvements to the MVVM toolkit.
  • There is also a toolkit for Aspire, which is interesting.
  • Then there’s the Maui MVVM toolkit, which adds a bunch of media support.
  • The Windows toolkit added a lot of fixes and controls for WinUI3.

They note that a lot of stuff incubates in the toolkits and is often migrated to the official libraries after a while.

✅ C# Features you need Habits you want by dotnet | Bill Wagner (YouTube)

He introduces an existing “magic 8-ball” program, demonstrating its functionality. He doesn’t show any tests, though. That does not stop him from refactoring the app to take advantage of “newer” C# features. I write it in quotes because, while some of the features he shows aren’t necessarily new, it’s good to have a video that shows how you should be upgrading your types when you touch old code, to take advantage of better type-checking, to convert potential runtime errors to compile-time errors.

  • non-nullable references.
  • required and init properties.
  • The field element for properties, which is new to C# 14.
  • The System.Threading.Lock type instead of System.Object, which allows the compiler to generate more efficient code, all without any change in behavior of the application.
  • Using verbatim strings and the newer multi-line verbatim strings.
  • Collection expressions. (He explains how the compiler can optimize the capacity for a collection expression, where it cannot for a direct instantiation of new List<T>().)
  • The spread operator. (He uses this to replace the explicit call to ToArray(). Again, it’s easier to read and the compiler has more optimization opportunities.)
  • The with keyword. (He explains how this allows you to more easily work with immutable types and structures.)
  • Using a readonly struct (This sets immutability, which also allows much better optimization, such as lowering copying/allocation when passing data through function/stack boundaries.)

    He optimizes his pattern-matching, where the compiler helps a lot to figure out exactly how much information is needed in the pattern. If a case can’t be reached, it’s an error. He removes the lower-bound check on several cases because they’re not needed. If you remove too much, the compiler tells you.

    AnswerType type = randomIndex switch
{
    >= 0 and <= 5 => AnswerType.Affirmation,
    >= 6 and <= 9 => AnswerType.Encouraging,
    >= 10 and <= 13 => AnswerType.Uncertain,
    >= 14 and <= 16 => AnswerType. Doubtful,
    >= 17 and <= 18 => AnswerType.Rejection,
    19 => AnswerType.Redo,
    _ => AnswerType.Uncertain
};

    The following is equivalent:

    AnswerType type = randomIndex switch
{
    <= 5 => AnswerType.Affirmation,
    <= 9 => AnswerType.Encouraging,
    <= 13 => AnswerType.Uncertain,
    <= 16 => AnswerType. Doubtful,
    <= 18 => AnswerType.Rejection,
    19 => AnswerType.Redo,
    _ => AnswerType.Uncertain
};

    If you were to change the order of the cases, putting the <= 13 case at the top, the compiler warns that the <= 5 and <= 9 cases will never be matched.

    AnswerType type = randomIndex switch
{
    <= 13 => AnswerType.Uncertain,
    <= 5 => AnswerType.Affirmation,  // Compile error.
    <= 9 => AnswerType.Encouraging,  // Compile error.
    <= 16 => AnswerType. Doubtful,
    <= 18 => AnswerType.Rejection,
    19 => AnswerType.Redo,
    _ => AnswerType.Uncertain
};
✅ Smatterings of F# by dotnet | Matthew Watt (YouTube)

The first five minutes is an introduction to the programmer himself, which was a bit odd but it’s fine. It just might not be very interesting if you’re looking for technical guidance.

He moves on to an introduction to his blog, which he wrote with F# on the back-end, and React for the front-end. The comments section that he built uses Elmish, which is a library for emulating the highly functional Elm pattern of building code. The whole web site is functional from top to bottom so it’s kind of neat to see how that works for a real-world application.

He finishes up with five minutes on contributing to open-source code. Again, a nice touch.

✅ Rx.NET status and plans by dotnet | Ian Griffiths (YouTube)

He discusses some examples of some new methods in the 6.1 release. These are quite nice, and the concept of RX is just neat, even though I’ve only ever played with it rather than used it in production.

He discusses in detail how some of the new handling for exceptions “bridges between RX’s world of observable streams and more ordinary async programming.”

In the next section, he discusses how the RX project had to do some extra work because System.Linq.Async is no longer their responsibility. It’s now in the standard library. But they had to make sure that their version gets deprecated in favor of the new one. As a library developer, think that this detail is fascinating, because you can see the the tools available for managing changing APIs and dependencies have gotten quite good.

Finally, he discusses the feature set for Rx.NET 7.0. The functionality won’t change much; it’s mostly library and platform-compatibility. There is a fix for the “bloat” issue, which only affects projects that target UI applications on Windows. It turns out that design decision in version 4.0 left self-contained deployments with implicit references to UI frameworks, which add dozens of megabytes needlessly.

The fix causes a compile error, for which they added an analyzer that nicely explains the fix to apply. This is a neat example of how to help consumers of your library get around compiler errors, which we didn’t have available before it was so easy to write and include custom analyzers. Previously, you’d have had to jump through more hoops to avoid giving upgraders compiler errors that weren’t warnings in the previous version. Now, if something like that is unavoidable, then you can still provide guidance with a diagnostic.

I thought it was a very interesting presentation but I’m a library and framework geek. Your mileage may vary.

Migration

⛔ .NET Scores “A Perfect 10” by dotnet | Shaun Walker (YouTube)
He describes a successful migration of a large Blazor application to .NET 10 (the open-source Oqtane (GitHub)), presumably from .NET 8. This is OK, but he just describes what he did without showing it. Once he gets to the product, he actually ends up demoing the Oqtane software—and Blazor’s capabilities—more than he showed any details about what migrating to .NET 10 entailed, apart from a few sentences in the slides. Instead, he spent a bunch of time discussing features introduced by .NET 10 that Oqtane ended up using. That is, instead of covering the migration itself, he discussed the extensions to the product that were enabled by a move to .NET 10.
✅ .NET Framework 4.8 to .NET 9 Step by Step by dotnet | Michael Christiansen (YouTube)

He recommends modernizing the app before retargeting it. This means:

  • Updating to use the SDK-style project format.
  • Using package references.
  • Using the Microsoft.Extensions.* packages, like dependency injection, configuration, logging, and hosting, all of which target the .NET Standard API surface and are therefore available for .NET Framework and .NET.

After that, he recommends side-by-side versions of libraries so that you can split them up better without affecting the existing, working version of the code.

One of the projects was a tougher nut to crack: it was an old-school ASP.NET application, where the patterns had completely changed in .NET 9 and 10. For that, he managed to have Claude Code do about 90% of the conversion and finished it up manually. The process was very manual—“spec-driven development” and “very hands-on”—but Claude Code was quite helpful once he figured out how to steer it properly.

If you have a .NET Framework application, then this is a great video. He really has a lot of good advice for how to avoid certain pitfalls (e.g., platform-specific code, like Windows Services).

⛔️ Modernizing .NET Applications for the Cloud by dotnet | Matt Soucoup (YouTube)

Was there ever going to be a chance that he wouldn’t start off with telling you that Copilot can do all of the tedious work for you? No. No, there wasn’t. Was he ever going to tell you to use your mad skillz with your IDE to apply a ton of changes automatically using tools and refactoring? No, he wasn’t. Like the NuGet guy, he’s going to get copilot to spend ten minutes running a NuGet one-liner.

So like how cool is that? Not only do you have a super-old application that you never upgrade but now you don’t even have to understand what you’re migrating to! I love how he says that going from .NET Framework to .NET 10 is just soooo easy. You know, don’t make any stops along the way, just take the express train. What could go wrong?

Anyway … he shows how to install the Copilot modernization tools, then opens a .NET Framework IIS-based project. Once again, we’re watching a guy watch a Copilot chat window write a ton of text that he barely reads. He asks it to explain the security problems, as if this is something that you should do. Shouldn’t you inform yourself about the packages? Shouldn’t you just upgrade the old things? Do you really need the explanation?

And, once again, he says that “you’re giving up the reins to Copilot,” but, like everyone else, just assumes that everything that Copilot returns in bulletproof. This is still not my experience, to this very day.

Back to the update plan: I see the attraction, I really do. It’s very detailed … but who is it for? Is he keeping this upgrade plan in the repository? How much control does the plan actual give him? Doesn’t the commit that results just show the changes?

He says it “took about an hour to upgrade”. 😱 Oh, hell no. It just works for an hour for what he calls “a simple app”, using God knows how many tokens, and then you still have to review everything? Why not just do it yourself? He really needs to show the diffs. Show us the diffs, bro. I don’t think he’s going to show us the diffs. He’s just going to show us how he has to coddle the tool, which is basically making black-box changes. “That’s just the way it is, that’s the way it is working with AI-assisted dev tooling.”

He didn’t show the diffs. I have no idea what this tool did for him on this project. This tool is for people who would have no idea how to go about upgrading a solution on their own, who can use a chat windows but run screaming from a command-line upgrade tool.

At the very end, he runs the upgraded version but there are warnings in the build that two packages were restored using .NETFramework,Version=4.6.1 (the worst .NET Framework version ever), which strongly indicates that, even after an hour of f@&king around, the solution still references .NET Framework.

“The amount of coding that I had to do was basically zero. All I had to do was supervise things.”

Well done, buddy. You still have old packages and weird references. Check your warnings. I wouldn’t touch this tooling with a ten-foot pole.

As I wrote in a comment on the video,

This kind of workflow doesn’t translate well to a nearly half-hour-long video. There’s nothing to see. He ran a command or two. He didn’t even show the diffs at the end, to show us what the tool actually did. You could still see some odd warnings about .NET Framework in the output that he had to pretend weren’t there. He did a good job FWIW but a lot of this video is watching the Copilot chat window scroll by. The explanation is good but it would have been better as a blog post.

Tools

🆗 Visual Studio Debugger: Advanced Techniques by dotnet | Harshada Hole (YouTube)

She takes us through the various live and inline indicators in the debugger, with predictive evaluation, including highlighting of the particular part of a condition that caused it to evaluate to true or false. The debugger has moved much closer to Rider’s, showing a lot of calculated values in the whitespace next to code, so you can see return values and calculated values without having to look in the variables or watches panes. This also allows you to use more concise coding while still being able to see interim values while debugging.

When showing how to analyze exceptions, she showed how to dig down into the call stack to find out why something’s null. She used right-clicking for everything, which was already slower than it needed to be…but then she decided to ask Copilot. The “quick” analysis took 30 seconds and then she had to ask it to do a “deep analysis”, whereupon it found the error that she would have probably found manually much more quickly. Maybe a more complex example wouldn’t have had such an obvious fix. Most people suck at debugging and don’t really understand their code, so probably Copilot is better at this than they are (or ever will be). So who am I to stand in the way of progress? I’m just John Henry.

I cannot stress enough how annoying it is to have to watch people “ask Copilot” and then we all gather around the chat-window output like it’s the word of God. It’s too bad, because the first few minutes of this video showed interesting deterministic tools before devolving into an orgy of just clicking that stupid little Copilot icon everywhere and then watching the completely useless and always-disregarded text in the chat windows scroll by. I cannot recall any one of these presenters actually reading any of this text. No-one cares.

These tools are really trying to reach out to and onboard completely unskilled developers to an unprecedented degree. These kinds of presentations make me sad. It’s fine for what it is, but I don’t think that this is the final form of software-development.

🆗 New dotnet test Experience with Microsoft.Testing.Platform by dotnet | Jakub Jares (YouTube)

This is a demo video, with the presenter working in Visual Studio Code but only from the command line. He shows how the console UI has been considerably improved. He also gets into new analyzers, assertions, and attributes. The improvement to the assertions is that they start analyzing the expression tree, which I find to be more fragile than the NUnit approach, which uses an explicit API to declare the assertion, with no magic. The attributes are for extending the framework, e.g., for determining when and in which environments tests will run.

Finally, he shows how the MSTest runner has massively improved execution speed, not in this version (4.0), but already in the 3.0 version.

The video is OK but the product is quite exciting, as it is a massive improvement over the previous test-runner.

🆗 What’s New in NuGet by dotnet | Sean Iyer & Nikolche Kolev (YouTube)

He starts off by threatening us that he will show a bunch of AI stuff. First up: tell us to use the MCP server for NuGet. He uses it to show how to get Copilot to update your dependencies when you have a vulnerability. This is not a hard task and, honestly, you should be aware enough of your dependencies to solve them yourself. It’s nice that the warnings are so good now that you can get a tool to fix up all f the things that people never could figure out on their own. Dude, since assembly-binding redirects were fixed in .NET, there’s no problem anymore. I don’t understand how it’s secure to let a hallucinating machine pick your dependencies for you. Now you don’t have to understand anything!

He spends a bunch of time talking about how to avoid getting outdated implementations that aren’t in the training data using an MCP. Or you could, you know, just update to the latest version. I don’t know why they’re making everything so complicated.

In the second half, he talks about security improvements but then just starts talking about how Copilot did all of his work for him. So, like, it’s secure but also an only partially reliable machine made all of the changes and he didn’t seem to look at them.

Nikolche shows how to eliminate vulnerabilities without Copilot (thank God) and shows how to use the pruning option with the audit command to remove unneeded dependencies that might show up in audits unnecessarily.

🆗 Real-World .NET Profiling with Visual Studio by dotnet | Nik Karpinsky (YouTube)

The first four minutes is a discussion of what profiling even is, with a nice workflow diagram for noobs. Next, he grabs the NLog open-source repository and opens the solution in Visual Studio.

“Now I want to talk to the profiler agent.”

Oh no.

He has the agent build a benchmark for a given class. The build fails, though because the solution uses advanced trimming options. Of course, he can figure this out, but if a developer who needs an agent to write benchmarks gets this failure, their day is already over. Copilot is not going to figure something like this out, either.

He goes on to generate more code but it’s very clear that the agent is a support tool because he brings a lot of knowhow to the table. For example, he sees immediately that the agent’s proposed solution never cleared the StringBuilder, which would skew the results toward better initial performance because of thrashing caused by reallocation that affects only subsequent runs. Of course, if you don’t notice this, then you have a shit benchmark that you will trust unreservedly because we’ve all long since stopped doubting the output of our new overlords, LLM agents.

What I don’t understand is why he keeps having the agent build and run the benchmarks. There are hotkeys for this. Is the future of Visual Studio just a chat interface? Who is the target audience here?

Anyway, his new benchmark finds a problem with Boolean boxing issue and the profiler agent jumps on it, optimizing the code. He shows how tedious the stack trace would be to investigate—which is not tedious at all because he clicks through it quickly—but we’re also supposed to ignore how long that little progress circle next to “Analyzing performance trace” in the agent window is spinning. It takes long minutes while the developer has long since explained what the problem is and would likely have fixed it. The agent is really there for people who wouldn’t have understood the problem illustrated by the profiling trace and who wouldn’t be capable of judging the proposed solution.

The solution is wrong. He characterizes it as “the first time I ran it, it came up with a better solution,” but that’s a cop-out because the solution shown in the video doesn’t compile. He begs the agent to return a boolean instead of a string which, like, duh, because the whole problem was with boxing booleans. But, sure, let’s run the profiler by writing “run the benchmark again” in the chat window instead of hitting a f@&king hotkey. F@&k, people are absolutely in a cult about these agents!

“What’s really cool here is that the profiler agent was able to have a, um, successful impact on this code and help me contribute to this repository in a meaningful way when I don’t really know anything about this repository.”

WTF BRO.

You just made a video showing non-developers how to pad their GitHub commit histories with performance-improvement PRs that they don’t understand (and that might not even work) by spamming open-source projects.

I was more excited about this one, and I think it would have worked better without the agent, but he wanted to show the agent.

UIs

⛔ What’s New in Windows Forms by dotnet | Mary McGalla & Klaus Loeffelmann (YouTube)

The two presenters use a giant prompt with Copilot to build a .NET 10 Winforms app to show slides like PowerPoint. As usual, they feed this prompt in to the “planner” to get a more agent-friendly plan that they’ll send to the agent. They had to jabber quite a bit because the tool takes a long time to run.

The tool generates a list of steps in Markdown with checkboxes and a progress bar that it regenerates as it works. OK? I guess? Is Markdown a UI target now? WTF? Like, how shitty are your WPF or HTML skills when you’re hacking a new UI library on top of a Markdown renderer? Who thought that this was a good idea? I guess the last state of the UI is preserved and can be fed back in to the planner or agent?

It seems to have worked, though, … except that you can’t go to the next slide. Oh, no, wait, cursor keys are supported.

As usual, they didn’t show any of the content in the gigantic prompt that they wrote.

These two fools seem to have no idea how the tool that they spent 25 minutes using works.

Also, they barely talk about Winforms. The few things that they mentioned are better covered in the What’s new in Windows Forms for .NET 10 release notes.

This video sucked unless you enjoy watching people watch Visual Studio build code for them.

⛔ Modern Windows Development with .NET by dotnet | Roy & Michael Hawker (YouTube)

The two presenters discuss how much the community has done for WinUI3 development, with a huge style guide and much-better integration with the common MVVM toolkit also used in WPF and Maui. The WinUI3 styles can also be used with WPF, so that’s neat, I guess. They didn’t mention Maui. They talked about open-sourcing WinUI for quite a while.

They also pretty much watched Copilot do stuff like generating UI chunks from text examples, converting to JSON then to a view (I think). This was all running locally, on the NPU (Neural Processing Unit) rather than using a model in the cloud, which is kind of nice. However, it’s amazing how happy they are to demonstrate brute-forcing regeneration of a tool that generates a JSON then view from text, again and again and again.

No-one asks at all anymore whether the generated code is the same, whether it works, whether there are tests to verify it, whether it makes sense to generate umpteen copies, whether the time couldn’t be better spent on just doing it yourself, etc. etc. Of course, they never, ever show what was generated or give any indication that they have reviewed the code or consider it necessary to do so. Just run it once, look at it for a second, commit, push, and make a pull request.

Hey everyone! We’ve all been wasting our time all of these years with structured development practices. With this tool that’s right 70% of the time, you can skip all of that. Look at that UI go! Watch it flicker as it generates a whole bunch of stuff you’re never even going to bother looking at until you get a call at 03:00 in the morning because everything blew up. Just kidding. No-one’s going to call you. They’re going to call other people who were stupid enough to take jobs on an on-call team.

✅ TUIs Are Back (Although They Never Left): Creating Modern CLI Apps in .NET. by dotnet | Andres Pineda (YouTube)

He goes through the history of UIs for the first third of the video, which is kind of interesting and provides decent context for why we might want a TUI. In the second third, he presents the Spectre.Console framework for building TUIs. The initial version uses an in-memory database, then an SQLite database, and then an external database. It uses dependency injection and the by-now standard application startup.

He also discusses Terminal.Gui, which runs on all supported platforms and has Miguel de Icaza as a contributor. This one creates apps that kind of look the old Borland DOS-mode applications. You build them with MVVM (supports CommunityToolkit.Mvvm) and generated views (not XAML) that you build with a text-console-based visual designer. You kind of have to see it to believe it. It’s really pretty cool.

If you want to use XAML, though, you can use RazorConsole with Spectre.Console to build UIs with that instead.

🆗 Ship Faster with .NET MAUI: Real-World Pitfalls and How to Nuke Them by dotnet | Paul Usher (YouTube)

A lot of the pitfalls he discusses are relatively general: resolution, distribution, deployment, staying up to date with security, etc.

Dude recommends Console.WriteLine() as an important debugging tool. Ok, buddy. On the other hand, it’s nice to see someone who shows his whole setup in detail, which, even though some of his tools are outdated (e.g., he uses CodeRush!), is nice to see, especially if you really have no idea how to get started.

He goes on to discussing app-store-related problems and how to overcome some of them, which is also quite helpful, as this is a part of the process that few people talk about. It’s not particularly enlightening but it’s good to discuss, as you can’t deploy an app without getting on app store.

Another pitfall is dealing with lifecycle changes and interruptions: is the app in the foreground? Is the device asleep? Is there network connectivity? Is the battery low? Is the app in sleep mode? When do you perform which initialization? Which expectations can you have about connectivity? Everything is asynchronous and the situation outside the app changes all the time. You have to watch all of the events and respond appropriately.

He advises using the emulator or simulator for a tighter feedback loop but there’s no way to avoid testing on a target device—or multiple target devices, as their behavior varies as well. He mentions that two recent Android devices (a Pixel and a Samsung) had different behavior in crucial areas affecting his apps.

✅ Building Rock-Solid Avalonia Apps A Guide to Headless Testing with AI Assistance by dotnet | Dong Bin (YouTube)

Whereas Avalonia and Maui both support iOS, Android, Windows, and MacOS targets, Avalonia also support Linux targets, including Linux running on embedded systems. The target that Dong addresses though is the headless mode, which is used for end-to-end UI testing. Avalonia’s rendering is completely decoupled from the platform, with the headless platform being just another target, like Windows or Mac.

God bless him for actually showing us how to write tests in the code editor. he’s using Rider on Windows. His code uses ObservableProperty from the Community Toolkit. This is a good demo.

In an advanced demo, he shows how to use “screenshot” rendering, even in headless mode. He also shows how to test controls for performance, both in speed and memory-usage, which is very important for building controls for highly constrained environments like embedded systems.

He points out that headless testing won’t help you with testing native features, actual visual look-&-feel. Instead, you can use the Skia renderer to approximate tests like that.

Finally, he actually introduces a usage of AI that makes sense to me: helping to write all of the unit, integrated, headless, and render tests. He explains how the task is focused, verifiable, and already has a lot of context to keep the generated code on the right path.

✅ What’s New in .NET MAUI by dotnet | David Ortinau (YouTube)

This one starts with an overview of the project. SyncFusion contributes heavily, from dozens of PRs to providing over 30 controls as open-source controls.

They’re also working much more closely with the Uno platform, which is ostensibly a competing framework but seems to be merging or moving closer to Maui. They’re working on NativeAOT for Android, SkiaSharp improvements (it’s their main rendering library), as well as WebAssembly multi-threading (that’s another target that they have that Maui does not, unless you count Blazor integration).

His demonstration is kind of neat: he shows a Maui app with SyncFusion controls and Community Toolkit, all running within an Uno Platform App. He shows it running in an Android emulator. This kind of support may extend Maui’s reach without having to replicate everything. For example, the WebAssembly target Uno offers works seamlessly with .NET Maui apps. He demos a NuGet browser that was written for desktop, but now running in a browser.

Next up is a very prosaic but very welcome addition: global usings/namespace declarations for XAML files. You no longer need to use prefixes and you no longer have a clump of stuff at the top of the file. On top of that, they also now support implicit namespaces (the feature is in preview).

Now a XAML file for Maui can look like this:

<ContentPage x:Class="DeveloperBalance.Pages.MainPage"
             x:DataType="MainPageModel"
             x:Name= "OverviewPage"
             Title="{Binding Today}">

This is really nice.

There’s also XAML source-generation now. This increases speed of debugging and reduces the differences between the debug and release builds massively. This is an opt-in feature but it sounds great. You can debug the generated code instead of relying on a bunch of reflection. Debugging uses 99% less memory and view-inflation is now 1000% faster (10x). Overall app performance is 25% faster with 30% less memory usage.

He talks about support for “safe edges” (UI integration with mobile form factors) and improved support for hybrid apps. He briefly discusses Aspire orchestration, which is completely integrated. This is especially interesting with hybrid solutions because the front-end actually has two parts that need to be coordinated. Doing this with Aspire is interesting. You can use the dashboard to inspect telemetry because the standard rendering is integrated as well. This telemetry is also available on the command line if you don’t use Aspire.

✅ Build better web apps with Blazor in .NET 10 by dotnet | Daniel Roth (YouTube)

The author talks a bit about large-scale apps in the U.S. and Europe that are built with Maui and, specifically, Maui Blazor. His presentation in this part is quite stilted and seems to have been massaged by the PR department. Like, he says that .NET Aspire makes you “cloud-ready,” which, if you’ve watched the Aspire talks, is no longer the focus of Aspire, and hasn’t been for a while. Deploying to the cloud is possible and well-supported, but it’s not the main use case.

He does demo some code, though. He shows passkey-integration for Blazor apps. I love how people watch this and think, “this is great; so much easier to log in,” whereas I watch it and have just watched someone log in using a 4-digit PIN rather than a safe password. How is this better? It’s similar to using a password manager on your device that’s always logged in, though. But passkeys are really replicating a bunch of the convenience that you already had with a password manager.

Next up is better integration for telemetry, which all appears in the Aspire dashboard. There are also advanced diagnostics, like being able to extract memory dumps and low-level runtime metrics from a running WASM Blazor app using a JavaScript command. The dottrace file can be easily converted to a gcdump file using the dotnet command and can then be analyzed in Visual Studio. This got very technical very quickly and I am here for it.

Blazor is also about 20% faster in .NET 10. For developers,

  • Hot Reload is better; he demonstrates an over 10x speed improvement, from 38s to about 3s.
  • Full-graph form-validation, so complex forms no longer need custom validation.
  • Automated browser/end-to-end testing using WebApplicationFactory but then also launching a full-fledged headless browser and then running Playwright tests against it.
  • Better state-persistence support, with automatic persistence on idle, pause/resume on idle, etc. This all integrates with the telemetry and can be inspected in the Aspire dashboard.

Very interesting and encouraging.

Aspire

✅ Taking .NET out of .NET Aspire − working with non-.NET applications by dotnet | David Gardiner (YouTube)

He presents a multi-language, multi-environment solution that uses Python/uv, Rust/cargo, and TypeScript/pnpm, each of which are run manually. From there, he shows a template Aspire solution with a Redis cache, an API service, and a web front-end.

He starts with a new Aspire solution, then integrates Mongo support using aspire-add-mongo and then integrates the PowerShell script that populates the data using an Aspire API. With that loaded up, he searches for an Aspire extension that works with his existing Python/uv setup. He doesn’t have to change anything; he just binds the startup of that part into Aspire so that the service is available to his “app host” (and also shows up on the dashboard). The Rust service easily follows, again by using an existing Aspire package to integrate Rust/cargo specifically. Finally, he binds the React/Vite/pnpm solution using a node.js extension from the Community Toolkit (again).

Where Aspire shines is that you don’t need to run these disparate apps from various command lines or scripts, and you don’t need to configure containers with YAML; you bind the various components and services with C# code, indicating dependencies between them, which Aspire not only handles but displays in the dashboard.

He uses this power to remove hard-coded ports from his services, using the C# variables to read the and use the dynamically assigned ports instead. Finally, he integrates OpenTelemetry into the Python and Rust services so that the various services show their telemetry in the Aspire console, structured logging, traces, and metrics views.

Finally, he adds an extra service that uses a node backend. Adding it once you have Aspire configured is very, very easy.

This is an absolutely great 22-minute video that you can send to anyone who asks “what can Aspire do for me?”

⛔ From Architecture to Docs: .NET Aspire Documented with Copilot by dotnet | Jorge Fernandez & David Oliva (YouTube)

This video explains the basics of Aspire (like, the very basics), as well as the basics of Copilot and MCP. You can skip that part, as they’re just reading from the slides, in what I am forced to note are pretty strong Spanish accents.

I honestly can barely tell what’s going on here. I feel so bad for these guys because they are probably much better in their native language but it’s so much work understanding them in English. They’re generating stuff with Copilot to generate an architecture overview for an existing solution file, using Markdown and ASCII diagrams. They then upgrade to using Mermaid diagrams. But I dare you to replicate what they did.

✅ Windows 365 Meets Aspire − Supercharging Multi-Repo Microservice Productivity by dotnet | Eric Guo & Chuanbo Zhang (YouTube)

This video demonstrates using .NET Aspire to wire up microservice servers with simulated Azure services in order to test InTune deployment software. It’s quite a complex use case. They show how you can test locally, using Docker and the Azure-service simulators, and also deploy to Azure infrastructure.

They even show how to simulate some of your own microservices by using the VS .http file format to quickly mock responses for a subset of the functionality. In this vein, they also discuss how to configure data-seeding for a stable environment, then finish up by discussing how to use XUnit to run automated tests against this entire infrastructure, both locally and in pipelines.

Although the specific use case is quite complex, there is a lot of good stuff to learn about testing automation in this talk. .NET Aspire makes it a lot easier to run locally and in the cloud without different approaches.

✅ Deep Dive: Extending and Customizing Aspire by dotnet | David Fowler & Damian Edwards (YouTube)

Fowler shows a single-project solution with a .NET Aspire AppHost project that binds non-.NET dependencies (i.e., they’re not they’re own projects). One of the dependencies is a postgres database that is absolutely a dependency but has classically been managed outside of the solution. Now, you can declare and bind the dependencies with C#. The takeaway is: a much slimmer readme file, that you just clone and call aspire run.

The great thing about this is that it has to stay in-sync, unlike a readme file.

Fowler shows the app dashboard with a lot of custom dependencies, including the .NET 10 OpenAPI replacement called Scalar, which is fully integrated into the Aspire dashboard. Fowler even shows how you can customize the dashboard appearance with C# code, using very standard options customization, as you would see in other host-based applications like ASP.Net (or many other types, Console, Windows Service, etc.).

Damian points out what we’re all thinking: holy crap, Fowler, WTH you hacked everything into the AppHost.cs file, like hundreds of lines, including a custom database seeder that uses the endpoint spun up by Aspire. It’s neat to see how you can bind in that kind of code, though, to just wait until the HTTP REST server is available and then to run some C# code to seed it with data. It’s ugly and it’s hacky in his code, but it’s wonderful that you can prototype and test so quickly with disparate systems and components. He has only one C# file and orchestrates diverse other components and scripts from it.

OK, he continues to show how you can bind commands into the Aspire Dashboard that he uses to bind a “reset command” that uses the Aspire interaction service to show a message box requesting approval.

Finally, at the very end, he shows how to use an MCP integration with Aspire. This is no more exciting than watching anyone else watch Copilot stumble drunkenly around a dark room. It’s only the last two minutes so we’re not subjected to too much of this foolishness. It was still writing furiously into the chat as the video ended.

Fowler is also using Visual Studio Code rather than Visual Studio. He also speaks very, very quickly, so brace yourself.

✅ Aspire Unplugged with David and Maddy by dotnet | David Fowler & Maddy Montaquila (YouTube)

They have T-Shirts with a great sentiment on them, “Friends don’t let friends write YAML.” Except that the “Write YAML” part is really, really big for some reason, so it looks like the shirts are exhorting users to actually write YAML. Whatever.

The first question is for Fowler, who describes the impetus of Aspire. It came from the pains of configuring so many scripts for infrastructure, even with a strong tool like Kubernetes.

It grew into a “general-purpose dev tool” for any sort of environment. It was originally scoped as a cloud-native tool but it quickly became obvious that nearly every solution has some sort of orchestration and scripting that always ended up in readme files or PowerShell or Bash scripts: starting the database, starting the backend for a mobile app, whatever.

“That became one of our key things, right? Like you want to onboard someone, you model all the stuff in code and then like you don’t have to tell someone run this script, run that script, pass the output from this script to that script, string together stuff. Like you can just kind of like put it in code, have it be there.”

He gives a lot of examples and detail about how polyglot and scalable .NET Aspire is. The other video he did—Deep Dive: Extending and Customizing Aspire by dotnet | David Fowler & Damian Edwards (YouTube)—showed a lot of code for integrating JavaScript and Python services. Another video—Taking .NET out of .NET Aspire − working with non-.NET applications by dotnet | David Gardiner (YouTube)—also shows how to integrate a lot of plugins from the community, including a Rust backend service.

The next big question is about persisting containers, supporting hot-reload, which is finicky to design and increases the complexity of the architecture significantly but the upside is huge if they can get it working. They managed a huge rewrite of all of the plumbing to support this type of scenario and are much better positioned for future developments.

The next question builds on this, asking about multi-repo support, with what’s called the “AppHost in AppHost” question: can you nest .NET Aspire apps? How does that work? It would be nice to be able to group shared services into one AppHost and then reference then from another high-level AppHost (for much larger solutions, obviously). What happens to the dashboards, though?

The idea of Aspire is to work with existing solutions, so the aspire init is a much more important workflow than aspire new. That is, you’re much more likely to already have a solution into which you’d like to integrate an AppHost or set of projects around which you’d like to wrap an AppHost than you are to be green-fielding a solution and starting with Aspire.

I love the dynamic between Fowler and Maddy. You can really tell they love working together, that they really, really respect one another. They love the “adult” Damian as well.

Cloud

🆗 What’s New in Containers for .NET 10 by dotnet | Rich Lander & Chet Husk (YouTube)
The two presenters first discuss the history of containers in .NET, including operating systems, support periods, etc. The second half demonstrates using dotnet publish using AOT and multiple OS targets and then deploying them into various containers. This targets are all variations of Linux and for command-line or server apps.
✅ What’s new in Azure App Service for .NET developers by dotnet | Byron Tardif (YouTube)

He quickly covers when .NET 10 will be available in App Service for Linux (Ubuntu, not Debian) and Windows, then moves on to showing how to use .NET Aspire to build and deploy an application to App Service.

Blessedly, he’s doing it manually, following a simple guide, rather than “getting Copilot to do it for him.” This inspires much more confidence that it’s well-designed and simple enough to actually learn, rather than implying that you need to ask a black-box globe-girdling data-model in order to grok it.

He’s got the standard Aspire app and then types azd up. It takes five minutes for the system to analyze, find a subscription, determine existing resources, and then deploy, creating services where needed. Access to the deployment is automatically configured (e.g., the dashboard is only available for authorized users).

He quickly shows the Azure Portal resources that were created for the App Service. This is nice. .NET Aspire is a worthy and welcome successor to Bicep scripts.

He shows a bunch of features of App Services specifically, including scaling options.

🆗 Carbon Aware Computing − Using .NET Open Source libraries for more sustainable applications by dotnet | Aydin Mir Mohammadi (YouTube)

This video covers tactics and tooling for running data services in a sustainable manner. E.g., load-shifting from day to night, adjusting available capacity depending on local energy availability, etc. There’s a lot of telemetry and real-time monitoring needed to even begin working in a sustainable manner.

In the second half, he gets to integrating an SDK that calculated best-execution time. Even libraries like Hangfire have methods like IncludeCarbonAwareExecution() (I’m not kidding!) that wrap all of this in a very high-level abstraction.

AI

⛔️ Architecting an AI-Powered Sales Dashboard with .NET MAUI and Azure OpenAI by dotnet | Shriram Sankaran (YouTube)

The app he discusses summarizes market data using AI. Did we all just choose to forget that AIs are not good at numbers? Did I miss the technology that we used to fix this problem? Remember “AIs are not good at numbers?” I do! When did we fix that?

Anyway, the UI looks decent and it’s completely cross-platform thanks to Maui. It uses SyncFusion’s controls as well as standard Maui controls. He spends quite a bit of time going over the features of his app. The AI is used to query the app data with a built-in chatbot.

When he finally gets to the code, his project is curiously not using CommunityToolkit.MVVM (all of the properties are implemented manually instead of source-generated. He eventually gets to more source but it’s not very illuminating. I can’t really recommend it.

🆗 One Question, One Answer: Designing Seamless AI Agents with C# by dotnet | Mark Miller (YouTube)

The presenter works on CodeRush for DevExpress. He uses CodeRush (I guess?) in dictation mode to build his calculator app, which, you know, is going to be something that the AI can easily build, as there are probably millions of examples in the training data. The generated code is horrifically defensive and not even close to what I would have made, or what I consider to be maintainable, but it’s fine for a prototype.

So, here we have another video that’s just showing how to program with an AI. He’s arguing for a workflow that stays in the code and is delivered via talking—because it’s 2-4 times faster than typing for most people and LLMs are very forgiving of extra words and filler words—so that you can avoid most of the pain points of working with the by-now “classic” AI-chat interface.

He talks about lot about how to optimize the context but I guess his tool does this?

✅ Overcoming the limitations when using AI by dotnet | Michael Washington (YouTube)

This guy doesn’t show up on the video. His voiceover and cadence is somewhat odd. It sounds very much like a text-to-speech engine. The whole presentation seems fake but the information is quite interesting. I guess he wrote the presentation but then had a machine read it for him.

He discusses how LLMs are bad at math, so the solution was to have the LLM create code to calculate answers. It’s wild how much f@&king processing power we’re willing to invest in getting the correct answer to 43 × 34. The LLM interprets the text, then generates an answer that includes a little Python program that it then executes in a sandbox so that i can include the output in its answer. It’s just flat-out nuts. Still, he shows off how he’s managed to work around these limitations but they are really elaborate.

Next up is that “AIs can’t write fiction”. He discusses AI story-builders, which use text-file databases in order to maintain context and continuity for stories. He found that page-by-page and chapter-by-chapter doesn’t work very well, but that paragraph-by-paragraph is the level of granularity at which an LLM needs guidance. There is a whole program surrounding the LLM’s inputs and outputs. Without it, the story goes off the rails immediately.

After that, he shows that AI cannot create applications. They can code but they have no idea of architecture and no idea how to deal with complex systems.

Find his slides and work at Overcoming limitations When Using AI.

🆗 Modernizing a 17th Century Italian-English Dictionary by dotnet | Wayne Sebbens (YouTube)
This was not uninteresting but it wasn’t a lot of programming information. Half of the video is a discussion of European martial arts and its relation to archaic Italian dialects and spellings. He basically made an app for searching these terms using vector databases and ML in .NET. If that sounds like something you want to do, check out the video and his repo (GitHub). If not, then you can safely skip the video.

Everything else

🆗 Going Passwordless − A Practical Guide to Passkeys in ASP.NET Core by dotnet | Maarten Balliauw (YouTube)
This is a decent and thorough introduction to authentication mechanisms, from passwords to MFA to passkeys, illustrating both the differences between passkeys and other methods as well as the .NET support for working with passkeys in your own applications (mostly in the last third of the video).
✅ GitHub Actions DevOps Pipelines as Code using C# and Cake SDK by dotnet | Mattias Karlsson (YouTube)

Cake is a build system written in C# with a rich .NET API. Mattias did a bunch of live-coding. The Cake scripts might be useful for defining a bunch of stuff that we currently use Azure Pipeline Definitions for. he demonstrates how provider plugins enable high-level abstractions that make it much easier to specify a declarative pipeline. It’s all in C#, so you use a code editor like Rider, with code-completion, refactoring, etc.

You continue to use the YAML pipeline definition to set up the environment but everything else will be in the Cake file. This makes a lot of sense and could be quite powerful. Instead of using a bunch of pipeline nested templates that you can’t run or debug, you could have a NuGet package with common APIs for Cake. You can also test a bunch of the Cake script locally (unless you have some highly specific steps like signing with a key only available in the cloud or calling a tool that’s only available in the cloud. You can use standard C# to make these optional when testing locally, though.

🆗 If .NET brewed beer… by dotnet | Shaun Lawrence (YouTube)

He starts with a 10-minute presentation on his home-brewing setup, finally getting to the point where he discusses the embedded device for which he used .NET: A Meadow F7v2 DevModule. For the next ten minutes, he just kind of muddles about, showing the API surface of the meadow library.

After showing how to integrate a temperature sensor, he shows how to integrate PID control (Proportional-Integral-Derivative control), again using the API. He mixes in support for PWN (Pulse-width Modulation). Both of these are commonly used algorithms to stabilize the interaction with a sensor: for interpreting and smoothing the signal and for ensuring that the written value corresponds to the desired value without slewing about. At the very end, he shows that his UI is built with Maui but he doesn’t get into it too much.

It’s nice that they provide low-level support for working directly with hardware but it’s not too fascinating. It’s good to know that C# is increasingly becoming a viable alternative to systems programming with C, C++, or even Rust or Go. He uses Visual Studio Code.

Copyright (c) 1999-2026 earthli.com. All Rights Reserved.
Powered by