Let's Learn MCP: C#

Let's learn about the Model Context Protocol (MCP), a cutting-edge framework designed to standardize interactions between AI models and client applications. Through this beginner-friendly workshop, we'll introduce you to MCP and guide you through creating your first MCP server. 🎙️ Featuring: Katie Savage and James Montemagno #dotnet #mcp #csharp

AspiriFridays - James Montemagno + Feedback Flow

David, Damian, and Maddy have nabbed a real celeb for this episode - fellow MSFTie and Aspire fan James Montemagno!! James has been building an app called Feedback Flow - and even though Fowler has been helping, it STILL isn't Aspirified enough. Join us for this exciting AspiriFriday to wrap up June. 🎙️ Featuring: Maddy Montaquila, David Fowler, Damian Edwards and James Montemagno

How can I build AI apps with .NET 9?

If you want to start building AI apps with .NET 9, Luis Quintanilla breaks it down in this One Dev Question. He covers where to find docs and tutorials, which AI libraries to use, and how to tap into the growing open ecosystem. Find more resources here: https://msft.it/6056SLJ5i

.NET AI Community Standup - AI in .NET: What’s New, What’s Next

Join us for an exciting online session where we explore how the .NET ecosystem is evolving to empower AI and Machine Learning development. From tensor support in .NET 9 to a quick look at what’s coming in .NET 10, we’ll walk through the key advancements shaping the future of intelligent .NET applications. 🔗 Community Links: https://learn.microsoft.com/en-us/collections/d4gkh1tg7g3dk7 🎙️ Featuring: Bruno Capuano (@elbruno), Tanner Gooding #dotnet #ai #CSharp

Add new C# features in old .NET

The Danger of "async void" #csharp #dotnet #coding

What if your try-catch blocks suddenly stopped working? That’s the scary reality when you misuse async void. While the compiler allows it, using async void for anything other than UI event handlers is one of the most dangerous things you can do in C#. Why? Because exceptions thrown inside an async void method cannot be caught by the calling code. Think of it as firing a method into the void. If something goes wrong and an exception is thrown, it won't be caught by your try-catch block. Instead, it will tear down the entire process, crashing your application with an unhandled exception. The correct approach is to always return a Task (async Task). This allows the calling method to await the operation and wrap it in a try-catch block, giving you full control over error handling. Reserve async void exclusively for event handlers like Button_Click in UI frameworks, and keep your application logic safe and predictable with async Task.

What's your favorite OpenAPI feature?

Built-in OpenAPI in ASP.NET Core 9 skips the default UI — and that’s exactly why Safia Abdalla loves it. She shares about this and a few more of her favorite features in this One Dev Question. Read the OpenAI Overview here: https://msft.it/6059SIieH

Required members secret in C#

Stop Blocking Your Code with ".Result" #csharp #dotnet #coding

Is your app freezing or becoming unresponsive? You might be accidentally creating deadlocks with a single line of code. In the world of asynchronous programming in C#, calling .Result on a Task is a ticking time bomb. While it might appear to work in a simple console application, it's a major mistake in any UI or web framework like ASP.NET, WPF, or MAUI. Calling .Result blocks the current thread, forcing it to wait for the asynchronous operation to complete. This can lead to a dreaded deadlock, where your application just stops and waits forever. It completely defeats the purpose of writing non-blocking, asynchronous code in the first place. The solution is fundamental to modern C# development: always use the await keyword. Awaiting a task properly releases the thread, allowing your application to remain responsive and scalable. Ditch the .Result habit and embrace await to build fast, fluid, and deadlock-free applications.

100 Must Know Tips to Write Better C#

Get 30% off everything on Dometrain: https://dometrain.com/courses/?ref=nick-chapsas&promo=youtube&coupon_code=SUMMER30 Subscribe to my weekly newsletter: https://nickchapsas.com Hello, everybody. I'm Nick, and in this video, I will show you 100 .NET Tips that I have already taught in the form of YouTube Shorts, for everyone to enjoy in a single long video. Workshops: https://bit.ly/nickworkshops Don't forget to comment, like and subscribe :) Timestamps 00:00 Intro 00:35 Tip 1: Array.Empty 01:23 Tip 2: Are you rethrowing exceptions correctly 02:15 Tip 3: Make your async code thread safe 03:11 Tip 4: Linq performance Trap 04:01 Tip 5: Write C# in your terminal 04:41 Tip 6: Fastest way to work with lists 05:22 Tip 7: Biggest Lie about the .Net Logger 06:07 Tip 8: Empty Types in C#9 06:38 Tip 9: ToList vs ToArray 07:19 Tip 10: Assembly Markers are Awesome 08:00 Tip 11: StringSyntax Attribute 08:30 Tip 12: C#12 Primary Constructors 09:04 Tip 13: UUIDv7 and why it's better than UUIDv4 09:47 Tip 14: The smallest valid C# program (and what it means) 10:16 Tip 15: CancellationToken best practices 10:53 Tip 16: Collection initialisers and new syntax 11:17 Tip 17: Checking your .NET project with `dotnet-outdated` 11:48 Tip 18: Generating nonsense with a waffle generator 12:30 Tip 19: Run and UseMap for one-line top-level logic 12:55 Tip 20: The Big List of Naughty Strings in C# 13:30 Tip 21: Parsing with interpolated strings 14:12 Tip 22: Using type aliases for `Any T `-like behavior 14:44 Tip 23: DateTimeOffset: why you probably want it 15:25 Tip 24: Architecture testing with NetArchTest 15:59 Tip 25: Alternatives to FluentAssertions 16:38 Tip 26: Exporting C# types as JSON Schema 17:08 Tip 27: For/await loops over IAsyncEnumerable 17:39 Tip 28: .NET Retest for test impact analysis 18:11 Tip 29: The `params` keyword demystified 18:36 Tip 30: Why `Monitor.Enter` can troll you 19:14 Tip 31: Private fields and the underscore naming convention 19:43 Tip 32: HttpClientFactory explained in 2 minutes 20:20 Tip 33: Snapshot testing in C# with Verify 20:54 Tip 34: Intro to Refit: type-safe REST clients 21:22 Tip 35: Avoiding thread limits with SemaphoreSlim 22:03 Tip 36: ULIDs: lexicographically sortable unique IDs 22:39 Tip 37: Better parallelisation with Task.WhenAll 23:18 Tip 38: Using `IServiceScopeFactory` for scoped resolution 23:56 Tip 39: Issues with primary constructors in large projects 24:34 Tip 40: Using UnitsNet for unit-safe calculations 25:02 Tip 41: Detecting missing `services.ValidateScopes()` 25:31 Tip 42: Null-coalescing assignment `??=` in depth 26:02 Tip 43: Initialising dictionaries: concise methods 26:44 Tip 44: class vs record vs primary constructor 27:18 Tip 45: ref structs: when and why 27:58 Tip 46: in parameters explained 28:35 Tip 47: Deferred execution with LINQ: a quick demo 29:06 Tip 48: `stackalloc` for fast allocation on the stack 29:50 Tip 49: Built-in delegates like Action, Func, Predicate 30:42 Tip 50: Base class method overrides and visibility 31:28 Tip 51: Renting arrays with ArrayPool.Shared 32:10 Tip 52: `async void`: why it’s dangerous 32:40 Tip 53: The null-forgiving operator `!` in C# 33:14 Tip 54: `using` keyword corner cases 33:58 Tip 55: Object cloning with the `with` keyword 34:36 Tip 56: Extension methods best practices 35:13 Tip 57: Collection expressions in C# 12 35:41 Tip 58: Passing `Span T` with `params`-like syntax 36:05 Tip 59: Target-typed `new()` and when it helps 36:24 Tip 60: Top-level statements cleaned up 36:55 Tip 61: Pattern matching with logical operators 37:21 Tip 62: `nameof` usage patterns 37:45 Tip 63: Writing custom deconstructors 38:07 Tip 64: Lambda attributes and metadata 38:31 Tip 65: Advanced pattern matching techniques 38:54 Tip 66: `ThrowIfNull` and guard clauses 39:22 Tip 67: Expression-bodied constructors 39:45 Tip 68: Working with `ValueTuple` 40:14 Tip 69: Tip 69 40:50 Tip 70: `ref` vs `in` parameters in method signatures 41:24 Tip 71: Comparing tuples for equality 41:45 Tip 72: Using CallerMemberName/LineNumber/FilePath attributes 42:23 Tip 73: Lesser known attribute tricks in .NET 42:57 Tip 74: Should you use `var`? 43:34 Tip 75: The good and bad of `dynamic` 44:24 Tip 76: Exceptional exception handling techniques 44:55 Tip 77: Async void in test methods 45:26 Tip 78: #region is (probably) a code smell 46:06 Tip 79: Proper use of the `[Obsolete]` attribute 46:35 Tip 80: The future of .NET (v2) 47:02 Tip 81: Global usings in .NET 6+ 47:21 Tip 82: `nameof` again? Yes, but different context 47:44 Tip 83: `InternalsVisibleTo` and its pitfalls 48:11 Tip 84: User-filtered exception handling 48:27 Tip 85: New `when not null` pattern 49:01 Tip 86: What `scoped` really means 49:27 Tip 87: Finalizers in modern .NET 49:57 Rest: Character length exceeded Social Media: Follow me on GitHub: https://github.com/Elfocrash Follow me on Twitter: https://twitter.com/nickchapsas Connect on LinkedIn: https://www.linkedin.com/in/nick-chapsas #csharp #dotnet

Raw string literals are awesome in C#

Cursor 1.0 Just Got Personal – and I Love It

💌 Free Developer Insights: https://guiferreira.me/newsletter #cursor #cursorai

The Wrong Way to Re-Throw Exceptions #csharp #dotnet #coding

Are your C# exception logs leading you on a wild goose chase? You might be making this critical mistake. When you catch an exception, it's tempting to re-throw it using throw ex;. On the surface, it looks fine, but it has a disastrous side effect: it completely overwrites the original stack trace. This means your logs will point to the throw line in your catch block, not the line of code where the error actually happened. You lose the most crucial piece of debugging information! The fix is incredibly simple, yet so many developers get it wrong. Instead of re-throwing the exception variable, just use the throw; keyword by itself. This preserves the entire original stack trace, ensuring that when you check your logs, you see the exact location of the initial failure. This tiny change can save you hours of frustrating debugging. Stop blaming the wrong line of code and start catching your bugs faster by throwing exceptions the right way. Are you guilty of this? Check your catch blocks now!

On .NET Live - Dynamically configure & roll out your AI app deployments with Azure App Configuration

Let's talk about using .NET options pattern and Azure App Configuration to deploy, rollout, or experiment with the LLMs in your applications. 🎙️ Featuring: Jimmy Campbell #dotnet #AzureAppConfiguration

On .NET Live | Should Entity Framework replace your repositories?

Should Entity Framework replace your repositories? This week's guest, André Baltieri, will talk with us about this question and delve into the Repository Pattern using Entity Framework and Clean Architecture. 🎙️Featuring: André Baltieri #dotnet #entityframework #cleanarchitecture

Discards are awesome in C#

Build Agentic AI Offline

In this video, we build an autonomous agent using a local LLM (Mistral-7B-Instruct) that can take user input, analyze a real database schema, generate SQL queries, execute them, and self-correct when things go wrong all completely offline. 🔧 What You'll Learn: What makes an AI system "agentic" How to build a prompt → thought → tool → reflection loop How to use a local model to query an MSSQL database How to detect and recover from hallucinations and execution errors Real code walkthrough with retry logic and schema introspection 🖥️ Tech Used: Python llama.cpp (Mistral GGUF) MSSQL pyodbc This is agentic AI in practice — grounded, functional, and private. Here's some important links: Source code: Watch previous sessions in this series as well: How to Run AI Offline with .NET https://www.youtube.com/watch?v=lc6lVCe0XHI&t=3s How to Fine-Tune AI Base-Model https://www.youtube.com/watch?v=FQr7VrK5RRQ&t=1087s How to Generate Content for Fine-Tuning Offline: https://www.youtube.com/watch?v=YB9cVyjV9Bo Make Your Offline AI Model Talk to Local SQL — Fully Private RAG https://www.youtube.com/watch?v=3jFpLNglWBc Source code: https://github.com/hassanhabib/AI.Llama.Traing.Offline/blob/main/step6_agentic.py

The Future of Thinking: Human Intelligence in the Age of AI

In this thought-provoking episode, Paul and Hassan dive into the deep questions shaping our AI-powered future: Is AI making humans dumber or just shifting how we think? Could AI have discovered electricity if it existed back then? How do we raise kids in a world where AI is everywhere? Can AI be truly creative or is it just remixing our ideas? Will AI eventually take initiative and pursue goals independently? Should governments regulate AI—and if so, who decides what it can or can't do? Is AI our rival or our ultimate teammate? Tune in for a candid, unscripted conversation between two tech minds unpacking the complex relationship between humanity and artificial intelligence. 🔔 Subscribe and join the conversation! #AI #ArtificialIntelligence #ParentingInAI #FutureOfWork #HumanAICollaboration #TechPodcast #PaulAndHassan

Super Fast Regex in C#

Developing UI Components in Blazor MAUI (Part 3)

Welcome to Part 3 of our Blazor MAUI series! In this video, we dive deeper into building reusable, maintainable UI components in Blazor Hybrid apps. You'll learn how to structure your components for performance and clarity, bind data efficiently, and apply styling that works across platforms. 🔹 What’s covered: Component structure & reusability Binding and parameter passing Styling & layout tips Platform-specific considerations 💡 Whether you're new to Blazor MAUI or building a production-grade app, this video will help you level up your UI architecture. 📌Watch previous videos here: https://www.youtube.com/watch?v=YVuaFvA0k64&list=PLan3SCnsISTSfXyWBmR0NNnTYJqrapaR_&index=7 👍 Like, share, and subscribe for more practical Blazor content! #BlazorMAUI #UIComponents #DotNet #Blazor #MobileDev #XamarinReplacement #DevTutorial

Aggressive Inlining in C# is insane

ASP.NET Community Standup - Behind the Scenes: Building the .NET Aspire Dashboard

Join us for a behind-the-scenes look with James Newton-King on how the .NET Aspire team builds the .NET Aspire Developer Dashboard with .NET, AI, and Blazor. Community Links: https://www.theurlist.com/aspnet-standup-20250701 Featuring: Daniel Roth, James Newton-King #dotnet #aspnetcore

AspiriFridays with David, Damian, and Maddy - Ed Keilholz aka Hex Master

Happy AspiriFriday! For our fourth AspiriFriday, join David, Damian, and Maddy as they take an already Aspirified app and Aspirify it even further!!!! Eduard Keilholz, aka hexmaster, is bringing his codebase to the Council of Aspirations for another chaotic Friday stream. Follow along youtube.com/ ⁨@aspiredotdev⁩ ⌚ Chapters: 00:00 Intro - you're in the right place even though the countdown says On .NET Live 🤓 02:53 Welcome 04:00 AspiriFridays Bingo - https://aspireify.live 06:20 Eduard Intro 07:51 Demo - adding more Aspire to conference organizer app 02:07:30 Wrap 🔗 Links: Bingo: https://aspireify.live https://learn.microsoft.com/en-us/azure/cosmos-db/emulator-linux#feature-support https://github.com/Azure/azure-cosmos-db-emulator-docker/issues/152 https://github.com/MicrosoftDocs/mcp 🎙️ Featuring: Maddy Montaquila (@maddymontaquila.net), Damian Edwards (@damianedwards.com), David Fowler, Eduard Keiholz (@hexmaster.nl) #dotnet #dotnetaspire

.NET Data Community Standup - Microsoft.Extensions.VectorData - Access Vector databases in AI apps

Join us for another .NET Data Community Standup where Shay tells us about Microsoft.Extensions.VectorData. ⏲️ Chapters: 00:00 Countdown 02:50 Welcome 05:11 Highlighting recent Microsoft announcements 18:45 Demo - Microsoft.Extensions.VectorData 56:54 Documentation 01:01:15 Q&A 01:07:14 Wrap 🔗 Link: Out-of-the-box Vector Store Connectors: https://learn.microsoft.com/en-us/semantic-kernel/concepts/vector-store-connectors/out-of-the-box-connectors/?pivots=programming-language-csharp 🎙️ Featuring: Jiri Cincura, Shay Rojansky (@ShayRojansky) #ai #efcore #dotnet

Languages & Runtime Community Standup - What's coming to dotnet test in .NET 10

Join members from the Microsoft Test Platform team to talk about what is new and coming to dotnet test in .NET 10! ⌚ Chapters: 00:00 Countdown 02:42 Welcome 03:30 What's coming to dotnet test in .NET 10 03:50 Today's agenda 04:50 What are Test Platforms? 06:00 What is Microsoft.Testing.Platform (MTP) 07:42 Key benefits 10:51 Demos - MTP 22:30 Demo - New features in dotnet test in .NET 10 37:00 Evolution of dotnet test with MTP 37:46 Key benefits of MTP with dotnet test 39:10 Mixed Project Compatibility 42:00 Q&A 51:07 Wrap 🔗 https://aka.ms/dotnet-test 🎙️ Featuring: Mariam Abdullah, Youssef Fahmy, Amaury Levé, and Jon Galloway #testing #visualstudio #dotnet