Browse .NET Videos (150)

Paula Santamaría and Julia Schröder Langhaeuser present a production Retrieval-Augmented Generation (RAG) architecture built on Azure Database for PostgreSQL, explaining why Postgres can be a solid foundation for RAG at scale and what it takes to move from prototype to production with performance tuning and monitoring.

dotnet explains patterns for modernizing data and migrating line-of-business applications incrementally, focusing on moving the database first and evolving the app through stable API layers and modern data access approaches.

dotnet discusses how to evaluate a 2005 WinForms line-of-business application—whether it should be treated as legacy “cold case” software or as an actively maintained asset—and what that decision implies for ongoing maintenance and modernization work.

dotnet presents a short walkthrough on modernizing existing .NET applications and quickly adding agentic (AI agent) capabilities, focusing on practical steps and resources for .NET developers.

dotnet demonstrates how .NET Aspire can modernize an existing .NET application using the Aspire onboarding flow, focusing on reducing manual setup like YAML and hand-rolled OpenTelemetry while bringing the app into an Aspire-managed workflow.

dotnet introduces the Modernize CLI and how it’s used to modernize and migrate .NET applications to Azure, focusing on practical workflow steps for moving existing apps toward cloud-ready deployment targets.

dotnet presents a session on using GitHub Copilot to modernize legacy .NET Framework applications, focusing on AI-assisted workflows to assess, plan, and execute upgrades to the latest .NET with less manual effort and lower migration risk.

dotnet discusses what comes after completing an app modernization effort, focusing on the next steps to make modernized applications “smarter” and more capable in real-world production environments.

Reynald Adolphe, Kyle Cutler, Giuseppe Ciance, and Vritant Bhardwaj recap the major Visual Studio Code and GitHub Copilot updates from the past month, with demos of features like the Integrated Browser, Issue Reporting improvements, and BYOK enhancements.

Visual Studio Code introduces “bring your own key” support, letting developers use their own model provider API keys with VS Code and GitHub Copilot without signing in, and points to the setup guide for enabling expanded model choice.

Daniel Costea shows how to use ChatClient and Microsoft Agent Framework middleware to turn a basic .NET AI agent into something you can run in production, with guardrails for safety, privacy, observability, and cost control, using an ASP.NET Core-style middleware mental model.

David Ortinau and Gerald Versluis are joined by Šimon Rozsíval to explain what moving .NET MAUI to CoreCLR in .NET 11 means in practice, and to show tooling from MAUI Labs aimed at making it easier to profile MAUI apps and reason about startup time and package size trade-offs.

Jesse Liberty introduces agentics and where agentic AI fits in the broader AI ecosystem, including supporting concepts like RAG and related building blocks developers use when designing AI-driven applications.

dotnet presents “.NET Day of Agentic Modernization 2026”, focused on modernizing applications in the .NET ecosystem, with an emphasis on agentic modernization as a theme for updating and evolving existing codebases.

Authorised Territory demonstrates how to expose a .NET AI agent through an OpenAI-compatible HTTP endpoint using the Chat Completions API protocol, built with an ASP.NET Core Empty project in Visual Studio 2026 and tested via an HTTP request file, with the agent running against a local Ollama model (gpt-oss).

Bruno Capuano and Tommaso Stocchi walk through building distributed multi-agent applications using .NET Aspire and Microsoft Agent Framework (MAF), focusing on how multiple agents coordinate across services and exchange context. The session connects these patterns to Foundry-oriented scenarios and demonstrates them with a ski resort example.

Daniel Roth and guests walk through recent Razor editor and tooling improvements aimed at making ASP.NET Core development faster and more reliable, with demos showing how the updates reduce friction in day-to-day workflows.

Visual Studio Code highlights new Integrated Browser improvements in VS Code, including saving browser favorites, taking full-page or region screenshots, and using browser content as context for GitHub Copilot and agent workflows.

Authorised Territory demonstrates how to govern a .NET Model Context Protocol (MCP) server by writing a YAML policy that prevents a specific tool from being executed, using the Microsoft.AgentGovernance.Extensions.ModelContextProtocol NuGet package.

Microsoft Developer features a conversation and live demo with Vic (creator of Gum and FlatRedBall) showing how Gum helps build resolution-independent game UI for .NET games. The video covers the Gum editor workflow, key layout concepts like Wrap and Clip, and wiring Gum UI into a MonoGame project via a Cookie Clicker-style example.

Shay Rojansky and Jiri Cincura compare how SQL Server and PostgreSQL 18 approach temporal data, digging into SQL Server temporal tables versus PostgreSQL’s new temporal constraint functionality and why they represent different concepts despite surface similarities.

Visual Studio Code shows how the Mermaid Markdown Features extension renders Mermaid diagrams directly in VS Code, including Markdown Preview, notebook Markdown cells, and VS Code Chat, so teams can keep architecture and workflow diagrams alongside their docs and code.

David Williams-Young and Stefan Wernli walk through the March 2026 release highlights for the Microsoft Quantum Development Kit (QDK), covering new capabilities like improved program composability and expanded QDK Chemistry support for a broader family of model Hamiltonians.

Authorised Territory demonstrates how to build a .NET Model Context Protocol (MCP) server over HTTP that scans for unsafe tools on startup, using the Microsoft.AgentGovernance.Extensions.ModelContextProtocol NuGet package, and pairs it with a simple .NET console client that connects to the server.

Umang Sehgal and Lily Du show how to build agents that operate inside Microsoft Teams—participating in chats, channels, and meetings—so they can automate tasks, surface insights, and take action in context without forcing users to leave their workflow.

Nish Anil, Hazem El-Hammamy, and Jeff Fritz present a Microsoft Build 2026 session on using GitHub Copilot’s modernization capabilities and agentic AI to analyze large legacy codebases, map dependencies, plan upgrades, and refactor safely with governance controls, including examples spanning mainframe and .NET modernization.

Visual Studio Code hosts a Microsoft Build 2026 live stage session with demos and discussion spanning GitHub Copilot, the Copilot SDK, and VS Code workflows. It touches on agent integration, multi-model verification, security concerns in AI code review, and developer tooling updates shared by the teams building them.

Mark Russinovich and Scott Hanselman discuss how AI agents are changing day-to-day software engineering, focusing on where agentic workflows speed things up, where they break down, and what engineers can do to adapt without buying into hype.

Microsoft Developer presents an in-depth Build 2026 session on .NET 11 improvements across the runtime, libraries, and SDK, with a focus on performance, diagnostics, and developer productivity. It also highlights work that supports intelligent, cloud-connected, and agent-driven apps, plus concrete library updates like Unicode and JSON enhancements.

Jared Rhodes demonstrates a practical .NET pattern for building apps that connect to real hardware, including device discovery over BLE and data exchange over NFC, serial, and USB. The session focuses on structuring device services, handling cross-platform differences, and choosing local connectivity when cloud APIs aren’t the right fit.

James Montemagno demonstrates how the VS Code Agents window (Preview) uses Dev Tunnels to remotely access your local developer tools, SDKs, and workspaces from vscode.dev, including using the /remote command and running a quick end-to-end demo.

Shawn Henry, Amanda Foster, and Glenn Condron go deep on building and operating multi-agent systems on Microsoft Foundry, focusing on “agent harness” patterns (including Claw) and hosted agents architecture. They cover long-running agents with triggers, state and file access, plus how Copilot SDK and Claude Agent SDK fit into coordinated workflows.

Mads Kristensen and Nik Karpinsky demo GitHub Copilot in Visual Studio, focusing on agent-style workflows that go beyond code generation: diagnosing bugs from runtime behavior, profiling performance to find bottlenecks, recommending targeted fixes, and building tests to prevent regressions for enterprise C#, .NET, and C++ codebases.

Nik Karpinsky demonstrates how to diagnose and fix modern performance issues using Visual Studio’s profiling and diagnostics tools, with GitHub Copilot and AI-powered agents helping generate, refine, and explain benchmark and profiling results for faster root-cause analysis.

Anastasiya Tarnouskaya, Aditi Narvekar, and Jordi Janer explain how to build AI-powered Windows apps that run models locally, including using Foundry Local and Windows ML to execute workloads across CPU, GPU, and NPU, plus new tooling like the Windows MLCLI preview and WebNN support for web apps.

Vini Soto and Jan Kalis demonstrate an “agentic content factory” built from multiple agent frameworks, deployed to Azure Container Apps, and wired up with Azure AI Foundry for observability and evaluations, with a focus on secure sandbox execution and controlling outbound access.

Fokko at Work demos selected updates in Visual Studio Code 1.123 with a focus on GitHub Copilot-related changes, including session sync/Chronicle and the Agents window, plus improvements to the built-in browser and screenshot workflow.

Authorised Territory demonstrates a .NET tutorial that builds an AG-UI protocol server and a Blazor client, hosting an AI agent locally with Ollama. The client sends prompts to the server and receives the model output as a streamed response.

Visual Studio Code hosts a live Microsoft Build session with the GitHub Copilot team, covering agentic development across the Copilot ecosystem. The agenda includes Copilot CLI, building with the GitHub Copilot SDK, and a segment on .NET Aspire alongside Copilot and related tooling.

Microsoft Developer shares a short announcement that Microsoft Build 2026 Day 2 is streaming live, highlighting GitHub, VS Code announcements and demos, GitHub Copilot deep dives, and live coding sessions with Microsoft and GitHub engineers.