The Morning Brew: Recent Episodes
None
The Morning Brew will take its summer break from Monday, likely returning to publication on Monday 19th August
Information* Visual Studio Code – July 2024 (version 1.92) – Visual Studio Code Team and contributors * The Singleton Pattern in C# Today Is Not Your Dad’s One! & Adding Serilog to ASP.NET Core: a practical guide – Metalama Team * ICYMI: Video Series on TCP/IP Application Protocol Design – Stephen Cleary * The Worst .NET Bug I’ve Ever Fixed – Aaron Stannard * The Definitive Guide to Building and Deploying Avalonia Applications for macOS – Mike James * Open source AI coding assistance with the Granite models – Cedric Clyburn * Begging for Bounties and More Info Stealer Logs – Troy Hunt
Information* Enhancing #help in F# Interactive – David Schaefer * Critter Stack Roadmap for the Rest of 2024 – Jeremy D Milller * Blazor Basics: Uploading Files in Blazor Server Web Apps – Claudio Bernasconi * Davide’s Code and Architecture Notes – Web APIs vs REST APIs vs pseudo-REST APIs – Davide Bellone * Optimizing facets query performance in Corax – Oren Eini * AI for Developers – Matt Graven
Information* Azure Functions Best Practices for Performance, Reliability and Security – Chris Pietschmann * Creating source-only NuGet packages – Andrew Lock * Fix .NET MAUI MissingEntitlement and Provisioning Profiles Issues – Khalid Abuhakmeh * ASP.NET Core Basics: Working with JSON – Assis Zang * Using Entity Framework Core with MongoDB – Beau Carnes * Create a .NET PlantUML Markdown Render Extension – Rick Strahl * .NET 6: Don’t Panic Yet – But .NET 6 End of Support Is On The Horizon – DeeDee Walsh * Highlights from Git 2.46 – Taylor Blau * The React useSyncExternalStore Hook – Hassan Djirdeh * React Hooks vs. Redux in 2024 – Prashant Yadav * There is no mystery over who wrote the Blue Screen of Death, despite what some may want you to believe – Raymond Chen * AWS CodeCommit quietly deprecated – Simon Willison * Instead of restricting AI and algorithms, make them explainable – Martin Fowler
Information* Easily Create Bindings for .NET MAUI with Native Library Interop – Rachel Kang * Sign VSIX packages with Sign CLI – Maia Kelner & Dominic Nahous * Metalama 2024.2 Generally Available: Class Introductions, Observability, and Much More – Gael Fraiteur * Making Marten Faster Through Table Partitioning – Jeremy D Miller * How many API’s does .NET have? – Steven Giesel * Checking the Health of an ASP.NET Core Application – Ricardo Peres * Replacing IdentityModel with MSAL’s support for generic OIDC-compliant authorities – Anthony Simmon * My Love Hate Relationship With Pattern Matching – Adam Storr * Cloud-Native .NET Aspire 8.1 Targets Building Containers, Orchestrating Python – David Ramel * Using Ports and Adapters to persist restaurant table configurations – Mark Seemann * AI and NET: AI in Action in Real-World .NET Applications – Bruno Capuano
Information* Announcing TypeScript 5.6 Beta – Daniel Rosenwasser * Uno Platform 5.3 Release: Full Rider Support and 350+ Enhancements – Uno Platform Team * Avalonia 11.1: A Quantum Leap in Cross-Platform UI Development – Steven Kirk * Windows resiliency: Best practices and the path forward – John Cable * Introduction to TypeGraphQL – Hassan Djirdeh * Back to Basics: Await a Task with a Timeout – Rick Strahl * .NET Aspire Developers Day – dotnet Youtube * On .NET Live – Introduction to .NET Aspire with Azure Container Apps – YouTube – Viswanatha Swamy * Absolute cache expiry corrupts absolutely? – Alastair Crabtree * Generate and Share Screen Recordings with Media Capture API – Ifeoma Imoh
Information* Developers want more, more, more: the 2024 results from Stack Overflow’s Annual Developer Survey – Erin Yepis * The Memento Design Pattern in C#, Practically With Examples [2024] – Metalama Team * Three data architectures for the server – Mark Seemann * En Provence [Some thoughts about npm package provenance – and why I have not enabled it] – David Anson * API naming principle: If there is no direct object, then the direct object is the source object – Raymond Chen
Update: Corrected attributation on the ‘Blazor Basics’ article – thanks to those who let me know
Information* How use a Blazor QuickGrid with GraphQL – Frank Boucher * Visual Studio tip: Using Ctrl-L to delete a line with and without Clipboard backup – Laurent Bugnion * Marten 7.25 is Better, Faster, Stronger – Jeremy D Miller * Unleashing Powerful Axios Features – Ezekiel Lawson * Work around the WebView2 NavigateToString() 2mb Size Limit – Rick Strahl * Blazor Basics: Controlling the HTML HEAD Section in Blazor – Claudio Bernasconi
Information* Announcing .NET Conf: Focus on AI – August 20th 2024 – Mehul Harry * What’s new in .NET Aspire 8.1 for cloud native developers! – Mitch Denny * Combining .NET Aspire, Docker (Remote), and Machine Learning Models for Summarising Photos – Sy * Health Checks for ASP.NET Core and Entity Framework Core – Khalid Abuhakmeh * ASP.NET Core Basics: Manipulating Databases – Assis Zang * ReSharper 20 years! – Anastasia Kazakova * Navigating the new web accessibility ruling in the U.S. – Caro Sotillo Silva * What’s New for JavaScript Developers in ECMAScript 2024 – Mary Branscombe
Information* Add AI to Your .NET Apps Easily with Prompty – Bruno Capuano * Overriding MSAL’s HttpClient with IHttpClientFactory – Anthony Simmon * The state machine in C# with async/await – Steven Giesel * Stop a script when an error occurs in PowerShell – Gérald Barré * Web Styles in Native Apps – Sam Basu * Add a SignalR hub to ASP.NET Core & connect using JavaScript – David Grace * A quick look at large language models with Node.js, Podman desktop, and the Granite model – Michael Dawson
Information* ILSpy for macOS: First Public Beta Release – Jumar Macato * Multithreading in Blazor WASM using Web Workers – Kristoffer Strube * Composing Linq Queries – Shawn Wildermuth * Migrating .NET APIs with Obsolete Attribute – Isaac Abraham * Auto-document dotnet CLI tool via dynamically generated markdown readme fragments – Daniel Cazzulino * ASP.NET8 using DataTables.net – Part4 – Multilingual – Mark Pelf * EF Core – The conversion of a datetime2 data type to a datetime data type resulted in an out-of-range value – Bart Wullems * Array Grouping in JavaScript – Peter Mbanugo
Information* NuGetAudit 2.0: Elevating Security and Trust in Package Management – Andy Zivkovic & Jon Douglas * C# Design Patterns – Iterator – Language Features – Liam Mooney * ASP.NET Core Basics: Dealing with Backend Validations – Assis Zang * Is Vertical Slice Architecture better than Clean Architecture or Ports and Adapters? – Derek Comartin * AI Tooling for Software Engineers in 2024: Reality Check (Part 1) – Gergely Orosz & Elin Nilsson * Don’t talk about non-functional requirements, talk about quality attributes – Bart Wullems
Information* Making Visual Studio a bit more visual – Mads Kristensen * Building a Safer Future – How NuGet is Tackling Software Supply Chain Threats – Jon Douglas * .NET Aspire vs Docker. – Phil Haack * How To Fix .NET Nullability Warnings For Guarded Members – Khalid Abuhakmeh * Disambiguating types with the same name with extern alias – Andrew Lock * Debug your .NET 8 code more efficiently – Bart Wullems * Using AZD for faster incremental Azure Container App deployments in Azure DevOps – John Reilly * Lessons learned in 35 years of making software – Jim Grey * UX Crash Course: Wayfinding – Kathryn Grayson Nanz
Update: Corrected the post title for ‘Enable NuGet auditing for your .NET projects’ – the copy paste gremilins had crept in there, but have now been banished!
Information* .NET 9 Preview 6 is now available! – .NET Team * Announcing OData .NET 8 Release Candidate 1 – Elizabeth Okerio * Enable NuGet auditing for your .NET projects – Gérald Barré * How not to benchmark! – Steven Giesel * Fastest C# Enum to String – NDepend Team * .NET 8 Data Annotations Validation – Ricardo Peres * Building Your First Use Case With Clean Architecture – Milan Jovanovic * The end of trust? – Mark Seemann * Data Dimensionality Reduction Using a Neural Autoencoder with C# – Dr. James McCaffrey * Temporal cattle and other important jargon – Oren Eini
Information* Local AI on Windows: Explaining the Audio Editor app sample? – Zachary Teutsch * Create a Windows Hello login app – Alvin Ashcraft * Git–Dubious ownership – Bart Wullems * Load Balancing – Sam Rose * 5 Ways to Maintain Your Eye Health When You Work in Front of Screens – Suzanne Scacca * Jeremy Bytes: “Very Bad Idea” prototype v0.1 – Jeremy Bytes
Information* Why and How to Execute GraphQL Queries in .NET – Frank Boucher * Deploy a Phi-3 model in Azure AI, and consume it with C# and Semantic Kernel – El Bruno * Snapshot Testing in .NET with Verify – Khalid Abuhakmeh * EF Core – Query splitting – Bart Wullems * ASP.NET Core Basics: 12 Questions ASP.NET Core Basics: 12 Questions and Answers for Beginnersnners – Assis Zang * Which is more suitable to use, isNaN or Number.isNaN() in JavaScript – Dhananjay Kumar * Dark Mode Now Available on NuGet.org – Allie Barry & Martinruiz
Information* Announcing SSMS 20.2 … and getting feedback for SSMS 21 – Erin Stellato * Uno Toolkit – an Uno Tech Bite series – Uno Platform Team * Loading aggregates with EF Core – Bat Wullems * From Microservices to Modular Monoliths – Steve ‘Ardalis’ Smith * Does code rot over time? – Oren Eini
Information* C# 13: Explore the latest preview features – Kathleen Dollard * .NET and .NET Framework July 2024 servicing releases updates – Tara Overfield & Rahul Bhandari * Adding support for collection expressions to your own types – Behind the scenes of collection expressions – Part 5 – Andrew Lock * Lessons from election night – Jon Skeet * Secure cross-platform and file-based token cache for MSAL.NET – Anthony Simmon * Adding Antivirus to .NET Aspire Systems – Jeff Fritz * HTML Datalist for ASP.NET Core Inputs – Khalid Abuhakmeh * Setting Up Renovate as Azure DevOps Pipeline for Automatic .NET NuGet Package Updates – Niels Rasmussen * Entity Framework Core– Avoid losing precision – Bart Wullems * Building a .NET TWAIN Document Scanner Application for Windows and macOS using MAUI – Xiao Ling * Deactivating an API, One Step at a Time – Bruno Pedro * The React useId Hook – Hassan Djirdeh
Information* Demystify history with GitHub Copilot commit explanations – Jessie Houghton * UUID v7 in .NET 9 – Steven Giesel * Simplify Your .NET Aspire Caching With Metalama – Metalama Team * Capture and review .Net Profiler Traces on App Service (Windows) – Kunal Vaidya * Should interfaces be asynchronous? – Mark Seemann * Network Round Trips are Evil – Jeremy D Miller * Failing to map: a tale of false hopes in mmap land – Oren Eini * CS0012: The type ‘System.Object’ is defined in an assembly that is not referenced. – Bart Wullems * How to use VS Code to develop and build a .NET application – David Grace
Information* Tracing External Processes with Akka.NET and OpenTelemetry: Part 1 (The Code) – Elton Stoneman * Discovering .NET codebases using code coverage and NCrunch – Tore Nestenius | Trainer and Senior Software Developer – Tore Nestenius * Avoiding long-running HTTP API requests – Derek Comartin * A Brief Comparison of Modern Programming Languages – TypeScript vs Golang vs Elixir vs Rust vs F# – Hamilton * Visual Studio–View .NET Counters while debugging – Bart Wullems * Reading unfamiliar codebases quickly: LMDB – Oren Eini * Generative AI for Beginners – Full Videos Series Released! – Korey Stegared-Pace
Information* Visual Studio AI Toolkit : Building Phi-3 GenAI Applications & Visual Studio AI Toolkit : Building Phi-3 GenAI Applications – Shreyan Fernandes * Elevating BFF Apps with .NET Aspire – Andreas Helland * .NET Aspire Developers Day is coming up! – Bart Wullems * How do I produce a Windows Runtime asynchronous activity from C#? – Raymond Chen * WebAssembly vs JavaScript: A Comparison – Kaan Güner * Navigating Corporate Giants Jeffrey Snover and the Making of PowerShell – CoRecursive Podcast – Adam Gordon Bell
Information* Visual Studio Code – June 2024 (version 1.91) – Visual Studio Code Team and contributors * Cloned Dictionary vs. Immutable Dictionary vs. Frozen Dictionary in high traffic systems – Oren Eini * The Anatomy of .NET Aspire Application – Fiodar Sazanavets * Elevating BFF Apps with .NET Aspire – Andreas Helland * TDD. You’re Doing it Wrong – John Borys * The history of Alt+number sequences, and why Alt+9731 sometimes gives you a heart and sometimes a snowman – Raymond Chen
Information* Dive into native Windows development with new WinUI workload and template improvements – Duncan MacMichael * Exploring the generated code: the spread element – Behind the scenes of collection expressions – Part 4 – Andrew Lock * Readonly, Immutable, and Frozen Collections in .NET – NDepend Team * HTML Range Inputs with ASP.NET Core TagHelpers – Khalid Abuhakmeh * Building Intelligent Applications with Local RAG in .NET and Phi-3: A Hands-On Guide – Bruno Capuano * Binary Classification Using LightGBM – Dr. James McCaffrey * SQL Server–Does a ‘LIKE’ query benefits from having an index? – Bart Wullems * The React useDebugValue Hook – Hassan Djirdeh
Information* Open Source ‘Eclipse Theia IDE’ Exits Beta to Challenge Visual Studio Code – David Ramel * RavenDB News: June, 2024 – Oren Eini * Publish a console app as a single executable – Bart Wullems * Is Your ASP.NET Core Application Running In A Container? – Adam Storr * WinMerge 2.16.41 Beta – WinMerge * Saving Data Historically with Temporal Tables: Part 1: Queries – Boris Novikov * Code in the cloud: Explore tools, training, and resources – Matt Graven
Information* Dev Proxy v0.19 with simulating LLM APIs and new Azure API Center integrations – Waldek Mastykarz & Garry Trinder * Is .NET Aspire NuGet for Cloud Service Dependencies? – Phil Haack * Refactoring a .NET MAUI app to a Declarative UI using C# Markup – Richard Woollcott * Tentative Roadmap for Wolverine 3.0 – Jeremy D Miller * 5 things we learned from sponsoring a sampling of our open source dependencies – Emma Irwin * The Final Windows Handle Leak Guide – Alois Kraus * Blazor Basics: Styling Blazor Components with CSS – Claudio Bernasconi * Azure Static Web Apps–SWA CLI behind the scenes – Bart Wullems * Open challenges for AI engineering – Simon Willison
Information* Join Us for .NET Aspire Developers Day – Elevate Your Cloud Native Skills! – Mehul Harry
* ReadOnlySet
Information* Code Assessment with .NET Upgrade Assistant – McKenna Barlow
* Exploring the generated code: T[], Span
Information* Let’s Learn .NET Aspire – Start your cloud-native journey live! – James Montemagno * Programmatically monitoring and reacting to resource logs in .NET Aspire – Anthony Simmon * Primary constructors – class vs record – Mark Downie * Read-Only Entities in EF Core – Ricardo Peres * What You Need To Know About EF Core Bulk Updates – Milan Jovanovi? * A mutable priority collection – Mark Seemann * Semantic Kernel–Change timeout value in C# – Bart Wullems * GitHub Copilot Extensions are all you need – Isidor Nikolic * Web Workers, Comlink, Vite and TanStack Query – John Reilly * The State of Data Breaches – Troy Hunt
Information* Dev Home Preview v0.15 Release – Kayla Cinnamon * Getting Started with Azure App Service: A Beginner’s Guide to Web App Deployment – Mahnoor Javaid * Modeling Navigation Properties Between Aggregates or Modules – Steve ‘Ardalis’ Smith * Building an election website – Jon Skeet * UniformItemsLayout from the .NET MAGetting Started with UniformItemsLayout from the .NET MAUI Community ToolkitUI Community Toolkit – Leomaris Reyes * How to Build a Fullstack Webapp with F# – Hamilton * No known bugs – Garry Shutler * Introduction to Building AI Agents with Microsoft Semantic Kernel – Chris Pietschmann * llama.ttf – Simon Willison
Information* Announcing TypeScript 5.5 – Daniel Rosenwasser * Announcing Third Party API and Package Map Support for .NET Upgrade Assistant – Marco Goertz * Multi-Tenancy: Mixed Modes with Marten – Jeremy D Miller * Blazor Basics: Dealing with Complex State Scenarios – Claudio Bernasconi * Enums aren’t evil. Conditional statements everywhere are – Derek Comartin * Take the challenge! How Fast Can You Bootstrap an Uno Platform Project? – Uno Platform Team * GraphQL–Application Insights integration for HotChocolate 13 – Bart Wullems * Let’s Bring Science Into API Documentation – Svetlana Novikova
Information* Keep Visual Studio automatically updated and secure through Microsoft Update – Christine Ruana * Using Phi-3 & C# with ONNX for text and vision samples – Bruno Capuano * Retiring Lamar and the Ghost of IoC Containers Past – Jeremy D Miller * How to Use C# to Properly Follow OAuth Authentication Flows – Peter Smulovics * Azure Application Insights–Collect Performance Counters data – Part II – Bart Wullems * Aspire Dashboard – A free & open-source OpenTelemetry dashboard for deep insights into your apps on your local development machine. * Recording: Building a Database Engine in C# & .NET – Oren Eini * Static Web Apps CLI: improve performance with Vite server proxy – John Reilly * JavaScript Framework Maintainers on Unification Potential – Loraine Lawson
Information* Privacy and security improvements in .NET modernization tooling – Mike Rousos
* Easily navigate code delegates while debugging – Mark Downie
* .NET Inline C# Action Feature in Logic Apps: More Flexibility and Control for Developers – Steef-Jan Wiggers
* Exploring the generated code: List
Information* Refactor your code with default lambda parameters – David Pine * How to achieve high HTTP scale with Azure Functions Flex Consumption – Thiago Almeida * Process Monitor v4.0 and Sysmon 1.3.3 for Linux – Alex Mihaiuc * Health Checks in Your OpenAPI Specs – Shawn Wildermuth * Beyond the Basics: Screen Recording in .NET MAUI – Leomaris Reyes * Setting up NGINX load balancer for .NET WebApi – Oskar Dudycz * The Arm development ecosystem is ready – Mark Downie * A failed attempt at priority collection with inheritance – Mark Seemann * Understanding open source LLMs – Rakesh Arunachalam * Docker Logging Guide Part 1: Basic Concepts and Importance – Bravin Wasike
Information* Announcement: Introducing .NET 8 Custom Code support for Azure Logic Apps (Standard) – Preview – Divya (Shree Divya) M V * Use custom Bicep templates – David Pine & James Montemagno * F# + Entity Framework – Group By Aggregation Could Not Be Translated – Hamilton * C# Version String Formatting – Rick Strahl * ASP.NET Core Basics: Introduction to Big O Notation – Assis Zang * API Monitoring- Key Metrics and Best Practices – Chisom Kanu * Comparing Unit Testable Code with Maintainable Code – Steve ‘Ardalis’ Smith * Build Chatbot with Large Language Model (LLM) and Azure SQL Database – Hristo Hristov * Technical Pattern: Build Your Own AI Assistant – Dale Jacques * Dual Publishing ESM and CJS Modules with tsup and Are the Types Wrong? – John Reilly
Information* Using PostgreSQL with .NET and Entra ID – Aaron Powell * Microsoft.AspNetCore.OData 9 Preview Release – Elizabeth Okerio * Goodbye, long procedural code! Fix it with workflows – Derek Comartin * Differences Between Span and Memory in C# – Bozo Spoljaric * The “Critter Stack” Just Leveled Up on Modular Monolith Support – Jeremy D Miller * Simplifying Light and Dark Mode in .NET MAUI Apps – Leomaris Reyes
Information* The .NET MAUI Extension for Visual Studio Code is now Generally Available – Maddy Montaquila * Catch up on the latest Git tooling features in 17.10 GA – Jessie Houghton * Simpler encapsulation with immutability – Mark Seemann * Build AI Applications with ease using Semantic Kernel and .NET Aspire – Sophia Lagerkrans-Pandey & Vic Perdana * Blazor Basics: Blazor Render Modes in .NET 8 – Claudio Bernasconi * Weak Events in C# – Satya Prakash * Comparing Unit Testable Code with Maintainable Code – Steve ‘Ardalis’ Smith * Keeping your AI out of trouble – Marco Aurelio Cardoso * TypeScript 5.5 Adds ECMAScript Set Support – Ian Elliot * Absolute positioning with CSS grid – Elaina Natario
Information* Building Generative AI apps with .NET 8 – Jordan Matthiese & Luis Quintanilla * Visual Studio 2022 – 17.10 Performance Enhancements – Ashok Kamath * Introducing collection expressions in C#12 – Behind the scenes of collection expressions – Part 1 – Andrew Lock * Does an HttpClient await the Header and the body? – Steven Giesel * How To Encrypt ASP.NET Core Route Parameters – Khalid Abuhakmeh * Using .NET Aspire eShop application to collect all the telemetry – Harry Kimpel * 5 Practical Ways to Add Polly to Your C# Application [2024] – Metalama Team * Export and Quantize Models like Llama-3-8B-Instruct with Model Builder for ONNX Runtime GenAI – Niels Rasmussen * Sonar Webinar, end to end security of a web application – Damien Bowden * The Red Hat cloud native architecture solution patterns – Bart Wullems
Information* Getting started with UI testing .NET MAUI apps using Appium – Gerald Versluis * Visual Studio Code AI Toolkit: Run LLMs locally – Shreyan Fernandes * MPS 2023.2.1, 2023.3.1, and 2024.1 EAP2 Released With Platform Updates – Vaclav Pech * Sneak Peek of Strong Typed Identifiers in Marten – Jeremy D Miller * Sharing the Renovate configuration across multiple projects – Gérald Barré * Now that I can write React Native, what should I test? – Oluwatomi Oluwafemi Alu * The Most Popular Build Tools for React Developers in 2024 – Peter Mbanugo
Information* Announcing the official OpenAI library for .NET – .NET Team * Announcing TypeScript 5.5 RC – Daniel Rosenwasser * Using Postgres with C# – Bryan Hogan * Using WebAssembly for Extension Development – Part Two – Dirk Bäumer * Why pair programming should be your default way of working – Bart Wullems * Sails.js for web development – Goodness Woke
Information* Using Phi-3 & C# with ONNX for text and vision samples – Bruno Capuano * Debugging Semantic Kernel in C# – Bart Wullems * Bouncy Castle Cryptography Library for .NET – Alvaro Montoya * Clean Code—A Practical Introduction in ASP.NET Core – Assis Zang * Beware! Anti-patterns in Event-Driven Architecture – Derek Comartin * Auditing SQL Server – Part 1 – Discovery and Documentation – Ben Johnston * Test-Driving HTML Templates – Round-trip to the server – Matteo Vaccari
Information* MSTest 3.4 is here with WinUI support and new analyzers! – Amaury Levé & Marco Rossignoli * Visual Studio Code – May 2024 (version 1.90) – Visual Studio Code Team and Contributors * How Akka.NET Actors Process Messages – Aaron Stannard * Phi-3-vision in 50 lines of C# with ONNX Runtime GenAI – Niels Rasmussen * State Machines, Light Switches, and Space Travel with Stateless and .NET 8 – Khalid Abuhakmeh * Debugging the Smart Paste UI component & .NET Core–Check if console app is running with administrative privileges – Bart Wullems * Creating and downloading a PDF or DOCX in ASP.NET Core – Damien Bowden * CSLA Sync API Poll Results – Rockford Lhotka * The signs of a new era: Prompt Injection – Dennes Torres * An animated introduction to Fourier Series – Andrei Ciobanu / Simon Willison
Information* A beginner’s guide to mapping arrays in EF Core 8 – Arthur Vickers * Automate your .NET SDK updates for consistent and reproducible builds with global.json and Renovate – Anthony Simmon * Blazor in .NET 9 Takes Shape (Preview 4 Highlights) – Jon Hilton * Encryption At Rest: Whose Threat Model Is It Anyway? – Simon Willison / Scott Arciszewski * New Signals Proposal Seeks to Formalize Reactive Programming Primitives in JavaScript – Bruno Couriol * Get Hands-On with Visual Studio and Azure: Live at Microsoft HQ this August! – Jim Harrer
Information* Refactor your code using alias any type – David Pine * Introducing the Revamped Visual Studio Resource Explorer – McKenna Barlow * Local Development using Azure Cosmos DB Emulator at no Cost – Kevin Gatimu * Highlights from Build and what’s new with .NET – Matt Graven * Giving the .NET smart components a try–The Smart Paste button – Bart Wullems * Fast and Compact Structured Logging in C# Using String Interpolation – Metalama Team * Create a multi-arch Docker image for a .NET application – Gérald Barré * Multi-Tenancy: Database per Tenant with Marten – Jeremy D Miller * You’ll regret using natural keys – Mark Seemann * Vertical Slice Architecture: Structuring Vertical Slices – Milan Jovanovi? * React Basics: Microfrontend vs. Monorepos – David Adeneye Abiodun
Information* What’s new in the Windows Subsystem for Linux in May 2024 – Craig Loewen * Metalama Status Update, May 2024 – Gael Fraiteur * Failed to start Dapr – file does not exist – Bart Wullems * Create a Jenkins pipeline to deploy Desktop Apps as MSIX – Part 2: Packaging a Visual Studio solution – Luis Demetrio * A beginner’s guide to the Git reftable format – Patrick Steinhardt * Writing Quality Method Docs – Joël Quenneville * ECMAScript 2024 features: resizing and transferring ArrayBuffers – Dr. Axel Rauschmayer
Information* Catch Up on Microsoft Build 2024: Essential Sessions for .NET Developers – James Montemagno * Building .NET apps for Linux from any operating system – Uno Platform Team * The Bulkhead Pattern: How To Make Your System Fault-tolerant – Derek Comartin * ASP.NET Core Basics: Getting Started with GraphQL – Assis Zang * Why, after 6 years, I’m over GraphQL – Matt Bessey * Building a serverless secured dead drop – Oren Eini * Test-Driving HTML Templates – Level 3: testing HTML behaviour – Matteo Vaccari
Information* F# developer stories: how we’ve finally fixed a 9-year-old performance issue – Petr Semkin * A modern Extension Manager has arrived with Visual Studio 17.10 – Maia Kelner * Weakly and strongly typed values in .NET – Yoh Deadfall * ASP.NET Core Updates in .NET 9 Preview 4: Support for OpenAI Doc Generation, HybridCache and More – Robert Krzaczy?ski * Cancel WhenAny – linked CancellationTokenSource – Steven Giesel * Running a Hosted Service in a Console Application – Bryan Hogan * Cooking with Semantic Kernel – Bart Wullems * 9 Things You Didn’t Know About JetBrains Rider’s NuGet Support – Khalid Abuhakmeh * Avoiding interactivity with Blazor? – Jon Hilton * Blazor HTML Forms, Submitting, and Antiforgery Tokens – Khalid Abuhakmeh * Blazor Basics: Child Routes & Optional Route Parameters – Claudio Bernasconi * Data Fetching Patterns in Single-Page Applications – Prefetching – Juntao QIU
Information* VisualStudio.Extensibility 17.10: Debug your extensions with the Diagnostics Explorer – Maia Kelner * “Highly Technical Talk” with Hanselman and Toub | BRK194 – Scott Hanselman &r Stephen Toub * Blocking primary constructor member capture using a Roslyn Analyzer – Andrew Lock * re: Secure Drop protocol – Oren Eini * OWASP Dependency Check – Improve update speed – Bart Wullems * Small Language Models with Phi-3 Cookbook: A Guide – Lee Stott * Snake draft sorting in SQL Server, part 4 – Aaron Bertrand * A beginner’s guide to the Shenandoah garbage collector – Francisco De Melo Junior
Information* Introducing links to source code for .NET API Docs – Min Huang & Matt Trilby-Bassett * Playwright in Action: From Setup to Best Practices | Azure Developers JavaScript Day 2024 – Glaucia Lemos * How to test a Roslyn analyzer – Gérald Barré * Clean Architecture Sucks – Steve ‘Ardalis’ Smith * Web Application Security: Broken Authentication vs. Session Management – Ezekiel Lawson * Continuous delivery without a CI server – Mark Seemann * Understanding Supply-Chain Attacks and OWASP Dependency Check – Bart Wullems * Challenges in Uploading Files Over 2GB via HTTP Protocol in IIS Web Server – Archi Chakraborty * Deprecating CSLA Synchronous APIs – Rockford Lhotka * Implement a Microsoft Entra ID external authentication method using ASP.NET Core and OpenIddict – Damien Bowden * Configure Custom 404 Not Found Page with Azure Static Web Apps – Chris Pietschmann * City In A Bottle – A 256 Byte Raycasting System – Frank Force
Monday is a public holiday here in England, so as is usual The Morning Brew will be taking a break, returning on Tuesday.
Information* Developing cloud native apps with Aspire – Mark Downie * Entity Framework Core 8 provider for Firebird is ready – Ji?í ?in?ura * Locking In On Concurrency Control – Derek Comartin * Clean Architecture Sucks – Steve ‘Ardalis’ Smith * Attack Techniques: Full-Trust Script Downloads – & * Attack Techniques: Remote Control Software – Eric Lawrence * Data Fetching Patterns in Single-Page Applications – Code Splitting – Juntao QIU
Information* First preview of Visual Studio 2022 v17.11 – Mads Kristensen * Must-have resources for new .NET Aspire developers – Anthony Simmon * Fix Missing OpenAPI Elements From ASP.NET Core Minimal API Apps – Khalid Abuhakmeh * AWS Platform Guide: A complete guide on how to build your infrastructure on AWS – Clarissa Lima Borges * The road toward AI: Fundamentals – Maarten Vandeperre * Authenticode in 2024 – Eric Lawrence * VBScript deprecation: Timelines and next steps – Naveen Shankar & Srirama Mogali
Information* General Availability of .NET Aspire: Simplifying .NET Cloud-Native Development – Damian Edwards * .NET Announcements & Updates from Microsoft Build 2024 – .NET Team * Visual Studio 2022 17.10 and GitHub Copilot: Your Coding Partner for Faster and Smarter Development – Mark Downie * Maximizing joy and minimizing toil with great developer experiences – Amanda Silver * Announcing NuGet 6.10 – The NuGet Team * Unlock a new era of innovation with Windows Copilot Runtime and Copilot+ PCs – Pavan Davuluri * Announcing the AI Toolkit for Visual Studio Code – John Lam * Thoughts about primary constructors: 3 pros and 5 cons – Andrew Lock * Project Legion – Jenny Lawrance & Cary Chai * Data Fetching Patterns in Single-Page Applications – Fallback Markup – Juntao QIU * Test-Driving HTML Templates – Matteo Vaccari * The React useState Hook – Hassan Djirdeh
Information* Roslyn analyzers: How to – Gérald Barré * EF Core Migrations: A Detailed Guide – Milan Jovanovi? * Reimagining Pong Wars with C# and MVUX – Uno Platform Team * How to use HttpClient correctly to avoid socket exceptions – David Grace * The Decorator Pattern in Modern C# & NullReferenceException? Object reference not set to an instance of an object. – Metalama Team * Fundamentals – Mark Seemann * Multi-Tenancy: Marten’s “Conjoined” Model – Jeremy D Miller * The CHECK() Constraint – Joe Celko * Meta Releases Open Source React Compiler – Loraine Lawson * Five Tips for Starting a New Developer User Group – Todd Anglin
Information* Multi-Tenancy: What is it and why do you care? – Jeremy D Miller * Building Better Apps: Better Together – Grace G Taylor * Discriminated Unions Part One – The F# side of things & Discriminated Union Part Two – The C# side of things – Tore Aurstad * Using Source Generators to Validate IOptions in ASP.NET Core – Ivan Gechev * Problem with NaN equality – Jind?ich Ivánek * Two Ways To Tune A Slow Query In SQL Server – Erik Darling * Programming mantras are proverbs – Luke Plant * Feedback loops in software development – Bart Wullems * ECMAScript 2023 feature: symbols as WeakMap keys – Dr. Axel Rauschmayer * The Guide to Modern Redux—Say Hello to Redux Toolkit and Redux Toolkit Query – Thomas Findlay
Information* Improve your code quality with GitHub Copilot in Visual Studio – Cynthia Zanoni & Laurent Bugnion * Wolverine’s Test Support Diagnostics – Jeremy D Miller * XUnit–Improve type safety – Bart Wullems * ASP.NET Core Basics: Authentication and Authorization with JWT – Assis Zang * ECMAScript proposal: duplicate named capturing groups for regular expressions – Dr. Axel Rauschmayer * Generate http files from a swagger definition – Steven Giesel * JavaScript Nulls and Programming Minutiae – Dan Lew
Information* .NET and .NET Framework May 2024 Servicing Updates – Tara Overfield & Rahul Bhandari * The .NET Generic Math Library – NDepend Team * Scheduled Message Delivery with Wolverine – Jeremy D Miller * Get Ready for Visual Studio at Build 2024: Join Thousands Online! – Jim Harrer * Parallel Data Fetching – Data Fetching Patterns in Single-Page Applications – Juntao QIU * Podman–Pull images from Docker Hub – Bart Wullems
Information* Announcing NuGet Commands in C# Dev Kit – Allie Barry * Mastering Slash Commands with GitHub Copilot in Visual Studio – Cynthia Zanoni & Laurent Bugnion * A Complete .NET Developer’s Guide to Span with Stephen Toub – Stephen Toub & Scott Hanselman * An introduction to primary constructors in C#12 – Andrew Lock * Wolverine’s HTTP Model Does More For You – Jeremy D Miller * Serialising ASP.NET method calls for later execution – John Reilly * ASP.NET Core, SSR Web Components, and Enhance Wasm – Khalid Abuhakmeh * C# in Browser via WebAssembly (without Blazor) – Nick Polyak * Modeling: Date vs. DateTime – Oren Eini * Data Fetching Patterns in Single-Page Applications – Juntao QIU * ECMAScript proposal: Promise.withResolvers() – Dr. Axel Rauschmayer
Information* What’s new in Orleans 8 for Scalable Distributed Applications – Mike Kistler * Building Resilient Cloud Applications With .NET – Milan Jovanovi? * CronJob – Big Updates – Steven Giesel * C# .NET 8 — MediatR Pipelines – Gabriele Tronchin * Writing “string.IsNullOrEmpty” using pattern matching and comparing the resulting code – Ji?í ?in?ura * How to avoid conflicts when testing your dotnet templates locally – Gérald Barré * Using SonarCloud with ASP.NET Core, Angular and github actions – Damien Bowden * Azure Static Web App–Deploy using Bicep – Bart Wullems * Before you try to change something, make sure you can change nothing – Raymond Chen * Gratification – Mark Seemann * The Modern Guide For Making CSS Shapes – Temani Afif
Information* General Performance Tip: Type Conversion – David McCarter * Controlling Parallelism with Wolverine Background Processing – Jeremy D Miller * How to (and how not to) design REST APIs – Derek Comartin * Wasm vs. Docker: Performant, Secure, and Versatile Containers – Savannah Ostrowski & Sohan Maheshwar * Kubernetes–Limit your environmental impact – Bart Wullems * Crafting Future-proof Apps with JavaScript & Azure Cosmos DB | Azure Developers JavaScript Day 2024 – glaucia_lemos86
Information* .NET 9 LINQ Performance Edition – Steven Giesel * Windows Terminal Preview 1.21 Release – Christopher Nguyen * Using WebAssembly for Extension Development – Dirk and the VS Code team * Blazor Basics: 9 Best Practices for Building Blazor Web Applications – Claudio Bernasconi * Fast Search and Replace in Large Number of Files: A Practical Guide – Brian C Hart * NL to SQL Architecture Alternatives – Mark Remmey * Join the .NET Team at Microsoft Build 2024! – Mehul Harry
Information* Refactor your code with C# collection expressions – David Pine * Azure Developers – .NET Day 2024 – Recap – Bruno Capuano * Scaling Marten with PostgreSQL Read Replicas – Jeremy D Miller * String Performance: Checking for a Character – David McCarter * Enforce architectural constrains using NetArchTest – Dennis Frühauff * Kubernetes–Setup a local cluster through Podman Desktop – Bart Wullems * Modern SQLite: Generated columns – Anton Zhiyanov * TypeScript Meets API Design in Microsoft’s Game-Changing TypeSpec – Darryl K. Taft * Sharing Styles in Declarative Shadow DOM – Rob Eisenberg
Information* Package Management & improved .NET Aspire support come to C# Dev Kit – Wendy Breiding * Using GitHub Copilot as your Coding GPS – Cynthia Zanoni & Laurent Bugnion * Deep Dive into RegEx with Stephen Toub – Scott Hanselman & Stephen Toub * .NET Core – Renew localhost certificate – Bart Wullems * Linked Lists in Real Life – Jeremy D Miller * EF Core Performance Optimisations – Ricardo Peres * How to add HTTP headers to Blazor Components with RazorComponentResult – Khalid Abuhakmeh * ERR_BLOCKED_BY_CLIENT and HTML5 Sandbox – Eric Lawrence * Better Protecting Next.js Applications Against Cross-Site Request Forgery (CSRF) Attacks – Ifeoma Imoh
Information* Sep 0.4.0-0.5.2 – Insanely Fast Single- & Multi-threaded .NET CSV Parsing (up to 35x faster than CsvHelper) – nietras * C#: How to Enumerate over Enum values and names – Chris Pietschmann * Proactive Architecture Guarding – Bnaya Eshet * Implementing API Gateway Authentication With YARP – Milan Jovanovi? * .NET Core – View outdated packages – Bart Wullems * Recent Marten & Wolverine Improvements and Roadmap Update – Jeremy D Miller * Disabling .NET Aspire authentication to skip the login page – Anthony Simmon * How to check if a DLL and an exe is a .NET assembly – Gérald Barré * Large Language Models, Open API, View Models and the Backend for Frontend Pattern – John Reilly * Conservative codomain conjecture – Mark Seemann * The biggest effect on code quality – Bart Wullems * Deniable Encryption – Oren Eini * What is platform engineering and why do we need it? – Markus Eisele * Exploring State Management Solutions Beyond Redux and MobX – Chinedu Imoh
Monday is a Public Holiday here in England, so as is Brew tradition I’ll be taking a break, returning on Tuesday
Information* Visual Studio Code April 2024 (version 1.89) – Visual Studio Code Team and Contributors * Exploring .NET Aspire: Building Cloud-Native Apps with Ease – Chris Pietschmann * Critter Stack Improvements for Event Driven Architecture – Jeremy D Miller * Checking your solution for NuGet vulnerabilities or deprecated packages – Steven Giesel * ASP.NET Core API Versioning – Ricardo Peres * Multi-Class Classification Using LightGBM – Dr. James McCaffrey * Blazor Basics: Globalization in Blazor – Claudio Bernasconi * WinGet: Enabling experimental features in production – Roy MacLachlan * Azure Static Web App–Data API Builder – Bart Wullems * The BASIC programming language turns 60 – Benj Edwards * JetBrains .NET Days Online 2024 – Call for Speakers – Maarten Balliauw
Information* Beyond Boundaries – Networking Programming with C# 12 and .NET 8 Book – Chris “Woody” Woodruff * OData .NET 8 Preview Release – Clément Habinshuti * Native Desktop UX with .NET MAUI for Windows and macOS Apps – Rossitza Fakalieva * Run Phi-3 SLM on your machine with C# Semantic Kernel and Ollama – Laurent Kempé * Marten, PostgreSQL, and .NET Aspire walk into a bar… – Jeremy D Miller * .NET 8 – Warning AD0001: Analyzer ‘Microsoft.AspNetCore.Analyzers.RouteHandlers.RouteHandlerAnalyzer’ threw an exception of type ‘System.InvalidOperationException’ – Bart Wullems * The Backend for Frontend Pattern – Andrea Chiarelli
Information* Secure your container build and publish with .NET 8 – Richard Lander * Creating a .NET AsciiMath parser and using it in a Markdig extension – Andrew Lock * Some more C# 12 – Tom Deseyn * Working with Rust Libraries from C# .NET Applications – Khalid Abuhakmeh * ASP.NET Core -Updating the OpenTelemetry configuration – Bart Wullems * Marten, Metrics, and Open Telemetry Support – Jeremy D Miller * Announcing the General Availability of PostSharp 2024.1 & Metalama Status Update, April 2024 – Gael Fraiteur * Embrace AI-Driven Productivity in .NET with JetBrains AI Assistant in ReSharper – Sasha Ivanova * My approach to HTML web components – Jeremy Keith
Information* The Journey to Accessible Apps: Keyboard Accessibility and .NET MAUI – Rachel Kang * .NET Aspire is the best way to experiment with Dapr during local development – Anthony Simmon * ASP.NET Core Hosting Module with Shadow Copy Not Starting: Separate your Shadow Copy Folders! – Rick Strahl * The Decorator Pattern is sometimes helpful – Jeremy D Miller * Service compatibility is determined based on policy – Mark Seemann * TypeScript compiler trick – Bart Wullems * Demystifying Azure Open AI for App developers – Avneesh Kaushik * Updating Documents in MongoDB – Robert Sheldon
Information* Announcing TypeScript 5.5 Beta – Daniel Rosenwasser * Adventures serializing absolutely everything in C# – Isadora Sophia Rodopoulos * An even DEEPER Dive into LINQ with Stephen Toub – Stephen Toub & Scott Hanselman * Switch expression for void methods – Bart Wullems * Phi-3-mini in 30 lines of C# with ONNX Runtime GenAI – Nietras * Blazor Basics: Localization Using Resource Files – Claudio Bernasconi * Google hates this one weird trick for having NO bugs! – Joost Kaptein * Unleashing GitHub Copilot for Infrastructure as Code – Murugesan U * Stop Using Regex for Connection Strings – Adam Storr * React 19 Beta Released! – Kathryn Grayson Nanz * Measuring Performance with the JavaScript Performance API – Hassan Djirdeh * Open sourcing MS-DOS 4.0 – Scott Hanselman & Jeff Wilcox
Information* What’s new for .NET in Ubuntu 24.04 – Richard Lander * C# 13 Params Collections – Fons Sonnemans * Securing identity: Exploring application types and authentication flows – Adam Matthews * First Class Event Subscriptions in Marten – Jeremy D Miller * Code It Any Way You Want: Comparison of Passing Parameters in Methods – David McCarter * Type pattern matching in C# and TypeScript – Bart Wullems * Implementing a functionality with GitHub Copilot for Visual Studio – Laurent Bugnion
Information* Introducing .NET MAUI Community Tookit v8: TouchBehavior support is here! – Gerald Versluis * .NET JsonElement and Schema Validation – Ian Griffiths * Thoughts on Primary Constructors in C# – Jeremy Clark * Giving the .NET smart components a try–The Smart TextArea – Bart Wullems * Working with IAsyncEnumerable in C# – Camilo Reyes * HSTS Header Implementation in ASP.NET Core – Muhammed Saleem * How to upload a file with Blazor SSR in .NET 8? – Jon Hilton * Embedding Database Migrations with Weasel – Jeremy D Miller * Akka.NET, ASP.NET Core, Hosted Services, and Dependency Injection – Aaron Stannard * Introducing our Security 101 course for beginners! – Sarah Young * Vertical Slice Architecture Myths You Need To Know! – Derek Comartin * Join us for Azure Developers – .NET Day on April 30! – Jon Galloway
Information* Refactor your C# code with primary constructors – David Pine * Exploring the AskVS command in GitHub Copilot for Visual Studio – Cynthia Zanoni & Laurent Bugnion * Tales from the .NET Migration Trenches – Authentication – Jimmy Bogard * Hacking together an AsciiMath parser for .NET – Andrew Lock * Async APIs – don’t confuse your events, commands and state – David Hope * Does readonly make your code faster? – Steven Giesel * Mastering SOLID Principles in C#: A Practical Guide – A. Yohan Malshika * Fix Unable To Resolve DbContextOptions For EF Core – Khalid Abuhakmeh * WIP is waste – Jared Turner
Information* Don’t Do This With Extension Methods – Adam Storr * Introduction to Distributed Tracing With OpenTelemetry in .NET – Milan Jovanovi? * C# 12: Collection expressions and primary constructors – Tom Deseyn * Minimal APIs Nuget Packages – Shawn Wildermuth * Strict Ordered Message Handling wth Wolverine – Jeremy D Miller * How to Convert a String to Byte Array in C#: Encoding and Decoding Simplified – Nick Cosentino * Using type aliases to make code clearer with generics – Gérald Barré * Configure Renovate to handle nuspec files – Anthony Simmon * XML External Entity Attack and .NET Core – Bart Wullems * We Migrated a Legacy App with ChatGPT: Here’s What Happened – DeeDee Walsh * Will Visual Studio Be Migrated to .NET Core and Become Multi-Platform? – NDepend Team * Fitting a polynomial to a set of points – Mark Seemann
Update: Corrected the mangled link to VSCode Day and Azure Developers .NET Day are coming! from Bart Wullems – thanks to those who let me know
Information* Wolverine’s New PostgreSQL Messaging Transport – Jeremy D Miller * API Key Authentication Middleware In ASP NET Core – A How To Guide – Nick Cosentino * How to create an F# / dotnet 8 Replit Instance – Hamilton * VSCode Day and Azure Developers .NET Day are coming! – Bart Wullems * Using GitHub and NextAuth.js for Single Sign-on in Next.js – Peter Mbanugo * Extending Copilot for Microsoft 365 using TypeScript | Azure Developers JavaScript Day 2024 – Glaucia Lemos * Navigating the Edges of Technology in Software Development: Bleeding, Leading, Dull, and Rusting – Steve ‘Ardalis’ Smith * Building a Culture of Data: The Technical Aspects – Ben Johnston
Information* WPF File Dialog Improvements in .NET 8 – Dipesh Kumar * Building a Resilient Email Sending Method in .NET with SmtpClient, Retry Support, and the Outbox Pattern – Steve ‘Ardalis’ Smith * NuGet – Package Source Mappings – Bart Wullems * .NET Performance on Arm64 & Running ASP.NET Core Web Server on Arm64 – Dawid Borycki * Introducing MSAL.Browser v3: What developers need to know – Emily Lauber * The Power of Automation: Enhancing Your Manual Code Review Process – Kerry Beetge
Information* Visual Studio Code – August 2023 (version 1.82) – Visual Studio Code Team and contributors * Top 10 Web Application Security Risks in Microsoft Azure and Ways to Mitigate Them – Chris Pietschmann * Null conditional await – Bart Wullems * Blazor SSR Gets Auto Render Mode in the Latest .NET 8 Preview – Jon Hilton * Drop git pull for fetch and rebase – Yftach Herzog * Results of Major Technical Investigations for Storm-0558 Key Acquisition – MSRC * A freestanding JavaScript function that uses this is easily mistaken for a constructor – Raymond Chen * Using Labeled Loops In JavaScript – Ben Nadel * Threading in JavaScript – Remy Porter
Information* Demystifying Retrieval Augmented Generation with .NET – Stephen Toub * Elevating Debugging with Auto-decompilation and External Sources – Harshada Hole * Tales from the .NET Migration Trenches – Empty Proxy – Jimmy Bogard * Exploring Blazor Changes in .NET 8 – Auto Render Mode – Jon Hilton * Landscape of .NET Parallelism – Bnaya Eshet * Decorator Pattern – How To Master It In C# Using Autofac – Nick Cosentino * Scheduled or Delayed Messages in Wolverine – Jeremy D Miller * Walkthroughs in the Windows Terminal Repository – Mike Griese * Enable passkeys in .NET with Bitwarden Passwordless.dev – Anders Aberg * Sep 0.2.3 – .NET 8 and AVX-512 Preview – nietras * The 2 rules of software architecture – Bart Wullems * AWS Toolkit for Visual Studio adds support for Arm64 Visual Studio – Christopher Christou & Saurabh Ajmera * Libraries and Frameworks and Platforms, Oh My! – Rob Eisenberg
Information* Keep your casing with Case-preserving Find and Replace – Leah Tran * Exploring the .NET 8 preview – Part 8 – Introducing the Identity API endpoints – Andrew Lock * Multi-tenancy with ASP.NET Core and FinBuckle.Multitenant – Khalid Abuhakmeh * Event Counters – Running Locally – Paul Michaels * How To: Dictionary in C# Simplified – Nick Cosentino * Turn off monitors when locking the computer – Gérald Barré * Build your UI as a finite state machine – Bart Wullems * Testcontainers – Integration Testing Using Docker In .NET – Milan Jovanovi? * Weighted k-Nearest Neighbors Regression Using C# – James McCaffrey
A short edition today as my feed reader was also quite empty due to the US Labor Day holiday
Information* Decomposing CTFiYH’s sample code base – Mark Seemann * Closures in C# demystified – Mark Pelf * Azure Pipelines – Batching your CI builds – Bart Wullems * Optimizing a three way merge – Oren Eini * OSS Power-Ups: bUnit – Webinar Recording – Matthias Koch
Information* C# Threading and Multithreading: A Guide With Examples – Juan Reyes * Tail recursion – Matt Gallagher * .NET 6 – Async scopes – Bart Wullems * Optimistic Concurrency in ASP.NET Core Web API – Muhammed Saleem * 7 Command Prompt Techniques in Windows You Should Know – Michael Shpilt * Pair programming a game with GitHub Copilot and a human – Chris Noring * Generative AI and .NET – Part 1 Intro – Aaron Powell
Information* Introduction to TDD & Testing C# with F# – Ian Russell * Plans for Marten V7 and Beyond – Jeremy D Miller * Playing MIDI through SoundFonts with NAudio and MeltySynth – Mark Heath * Use explicit Lambdas with LINQ – Bertrand Le Roy * NuGet – Lock files – Bart Wullems * Use multiple Microsoft Entra Verified ID credentials in a verification presentation – Damien Bowden * A Definitive Guide to Using the Web Share API – Ifeoma Imoh
Monday is a public holiday here in England, so as is tradition there will be no edition on Monday – regular posting will return on Tuesday Information
And we are back – bumper catchup edition today, and back to a more normal service tomorrow Information
The Brew will be taking its summer break starting today, and will return on Monday 21st August Information
Information* What’s New in SSDT 17.6: Ledger, Performance, Copilot – Subhojit Basak * Implicit Operators in C# and How To Create a Multi Type – Nick Cosentino * .NET Micro-Optimization and Refactoring Trick – Patrick Smacchia * Refactoring Change Preventers in C# – Code Maze * The Git repository that vanished – Mark Seemann * ASP.NET Core authorization using Entra External ID CIAM and Azure AD security groups – Damien Bowden * Run WebAssemblies in VS Code for the Web – Dirk Bäumer * Demystifying WebAssembly: What Beginners Need to Know – Robert Kimani * A guide to Generative AI terminology – Colin Eberhardt * Why Test-Driven Development? (Part 1) – Alex Bunardzic
Information* Announcing TypeScript 5.1 – Daniel Rosenwasser * Announcing an update for .NET Upgrade Assistant with a new CLI tool! – Olia Gavrysh * Dev Drive: Performance, Security and Control for Developers – Bridget Tueffers * Create ready-to-code dev boxes using config as code – now in preview – Jordan Matthiesen * Reduce heap allocations by using static anonymous functions – Bart Wullems * Blazor Basics: Getting Started with Blazor Development in Visual Studio 2022 – Claudio Bernasconi * How to Build Dynamic Queries With Expression Trees in C# – Code Maze * SQL Server 2022: Capture SQL Anti-Patterns – Dennes Torres * The many ways to select the n-th character from a string. – Christian Heilmann * GitHub Secure Code Game – Bart Wullems * Cecil Phillip – Building payment flows with Stripe and Azure – Webinar Recording – Khalid Abuhakmeh
Information* New Terminal logger for .NET 8 – Steven Giesel * Memory Allocation Optimization With BenchmarkDotNet – Code Maze * Replace JS with no-JS (or lo-JS) Options – Aaron T. Grogg * Hashing String Data in JavaScript, C#, C++, and SQL Server – j2inet * Gaussian Naive Bayes Classification Using the scikit Library – Dr. James McCaffrey * Hacking with Windbg – Part 2 (Minesweeper) – Sarthak S
Information Speech Recognition in .NET MAUI with CommunityToolkit – Vladislav Antonyuk * Software Design – Private by default – Bart Wullems * ASP.NET Core Basics: Sharing Code via NuGet Packages and DLL Files – Assis Zang * Easily Replicate a Sign-Up UI in .NET MAUI – Leomaris Reyes * Underrated skill as a developer – Derek Comartin * Engineer the Sht out of Errors – Everywhere – Charlie Kindel
Information* Introducing Dev Home – Kayla Cinnamon * Open at Microsoft – Dapr – AugustaUd * Create a Microsoft Power App for your ASP.NET Core Web API – Julia Kasper * Iterating on your Welcome Experience feedback – Grace Taylor * .NET 7–Serialize private fields and properties – Bart Wullems * nameof get’s a bit better in C# 12 – Steven Giesel * SciFiDevCon 2023 – Check your Thermal Exhaust Port – 10 Vulnerabilities Your Web Application Probably Has Right Now – Scott Sauber * ASP.NET Core authentication using Microsoft Entra External ID for customers (CIAM) – Damien Bowden * JavaScript Import Maps For ASP.NET Core Developers – Khalid Abuhakmeh * TypeScript Tuple Types: The What, Why, and How – Sachin Chaurasiya * The Prickly Case of JavaScript Proxies – Rob Eisenberg * Privacy Enhancing Technologies: An Introduction for Technologists – Katharine Jarmul
Information* 9 Announcements in Microsoft Build 2023 and their Implications for the Future – Michael Shpilt * Monoliths – Good or Bad? – Mark Heath * Favour flat code file folders – Mark Seemann * Tips and ?ricks to ?odernizing Your App with Blazor – Galina Jordanowa * Getting .NET Library Projects to Output Dependent Assemblies – Rick Strahl * Is C# faster than F#? – Hamilton * Disabling HSTS for localhost on Chromium-based browsers – Gérald Barré * Manage multiple Node.js versions – Alexandre Nédélec * The Impact Of Agile Methodologies On Code Quality – Sarah Oke Okolo * Unmasking SQL Server Dynamic Data Masking, Part 1, Intro – Ben.Johnston * Lawyer cites fake cases invented by ChatGPT, judge is not amused – Simon Willison
Monday is a Public Holiday here in England, so in keeping with customs there will be no edition of The Morning Brew on Monday, and posting will resume on Tuesday.
Information* All-In-One Search available in 17.6 – Leah Tran * Unified Settings: Share Your Feedback! – Grace Taylor * Announcing Azure Data Studio 1.44 – Erin Stellato * Microsoft Build Book of News – Microsoft * Building (and Testing) Minimal APIs in ASP.NET Core 7 – Peter Vogel * BEWARE of Consumer Lag! – Derek Comartin * Deno 1.34: deno compile supports npm packages – Simon Willison * Upskilling: ChatGPT Prompt Engineering for Developers now in C# – Mike Francis
Information* Dev Drive for Performance Improvements in Visual Studio and Dev Boxes! – Grace Taylor * .NET Framework May 2023 Cumulative Update Preview Updates – Salini Agarwal * .NET Core–Monitor cache misses – Bart Wullems * .NET 7: Simplify Patch requests with PatchAsJsonAsync extension – Anthony Giretti * Swashbuckle vs. NSwag in ASP.NET Core – Code Maze * Embed C# in the heart of the SQL Query Engine – Mihailo Joksimovic * Introducing GitHub Copilot for Azure Data Studio – Drew Skwiers-Koballa * Visual Studio Code snippet to make URLs relative – Mark Seemann * Windows 10 April update can cause data corruption – Alois Kraus * How to Handle the Safe Area Layout for .NET MAUI in iOS – Leomaris Reyes * Building a Signal Analyzer with Modern Web Tech – Casey Primozic * A Different Approach to Understanding Array Reduce – Marina Mosti * What runs ChatGPT? Inside Microsoft’s AI supercomputer | Featuring Mark Russinovich – Zachary Cavanell
Information* Visual Studio 2022 – 17.6 Performance Enhancements – Nayana Srikanth * Transform your business with smart .NET apps powered by Azure and ChatGPT – Luis Quintanilla * Turbocharge your Visual Studio experience with Microsoft Dev Box – Ruben Rios * Microsoft Build 2023: all the news and announcements from the developer conference – Jon Porter * An AI Guide to Microsoft Build 2023 & A Data Professional’s Guide to Build 2023 – Natalie Mickey * Cloud-native at Build 2023 – Devanshi Joshi * What’s New for Azure App Service at Build 2023 – Stefan Schackow * Introducing Azure App Spaces: Getting your code into the cloud as fast as possible – Skyler Hartle * Making authenticated cross-origin requests with ASP.NET Core Identity – Andrew Lock * Good (Blazor) Components are… ? – Jon Hilton * Dependency Composition – Daniel Somerfield * Podman Desktop 1.0: Local container development made easy – Stevan Le Meur * Comparing HTTPS Sessions with Fiddler Everywhere – Nikolay Iliev * Announcing: Contoso Real Estate JavaScript Composable Application Reference Sample – Nitya Narasimhan * How to Create a Custom Debounce Hook with React – John Au-Yeung * How DynamoDB queries behave compared to relational databases – James Gregory
Information* Announcing Azure Monitor OpenTelemetry Distro – Matt McCleary & Sam Spencer * Blazor and CSP – Damien Bowden * Visual Studio 2022 17.6 – Http Endpoint explorer – Bart Wullems * The Art of HTTP Connection Pooling: How to Optimize Your Connections for Peak Performance – Ramakrishna Thanniru & Pete Tian * Detect Globalization-Invariant mode in .NET – Gérald Barré * Exploring the C# Source Link Feature: Enhancing Debugging Experiences – Neel Bhatt * 2 Good Tools To Test gRPC Server Applications – Karthik Chintala * How To: Creating a Private Journal and Mood Tracking App Using .NET 6, Chat GPT, C# and Visual Studio 2022 – Jamie Maguire
Information* Announcing TypeScript 5.1 RC – Daniel Rosenwasser * Building Functional .NET Applications: a Guide for Choosing between F# vs C# – Nahla Davies * When and How to Use Blazor Components – Steve ‘Ardalis’ Smith * Promise and Async in the (Elmish) wild – Pawe? Stadnicki * How I Re-implemented PyTorch for WebGPU – Frank A. Krueger * List of Useful JavaScript Shorthands – John Au-Yeung * Webinar – Cecil Phillip – Building payment flows with Stripe and Azure – Khalid Abuhakmeh
Information* Visual Studio Code – April 2023 (version 1.78) – Visual Studio Code Team and Contributors * Introducing Bob’s Used Books—a New, Real-World, .NET Sample Application – Steve Roberts * Untangling the many aspects of EDA – Derek Comartin * Automated UI Testing—Definition, Tools and Benefits – Dennis Martinez * Bug chasing, the process is more important than the result – Oren Eini * Creating Accessible Apps with Semantic Properties in .NET MAUI – Leomaris Reyes * Visual Studio–Generate C# client for OpenAPI – Barat Wullems * JetBrains .NET Day Online 2023 – Call for Speakers – Maarten Balliauw
Information* Announcing .NET mobile Debugging in VS Code. Mobile development in VS Code with Uno Platform or .NET MAUI – Uno Platform Team * Rider 2023.2 Roadmap & ReSharper 2023.2 Roadmap – Sasha Ivanova * Sending MediatR Notifications Immediately After Saving an Entity with Entity Framework Core – Bryan Hogan * Minimal API growing with .NET 7 – Christian Nagel * What happens when you navigate to the “same page” in Blazor? – Jon Hilton * MassTransit – Minimal Message Handlers – Bart Wullems * Uploading Large Files in ASP.NET Core – Code Maze * Native AOT libraries with TypeScript – Eric Sink
Information* Announcing a new version of the .NET Upgrade Assistant with support for .NET MAUI and Azure Functions! – Olia Gavrysh * Make your ASP.NET Core application always running on IIS – Bart Wullems * C# Tip: Format Interpolated Strings – Davide Bellone * Calling internal ctors in your unit tests” – Phil Haack * Running Vite with ASP.NET Core Web Applications – Khalid Abuhakmeh * What’s the “unit” in unit testing and why is it not a class – Dennis Doomen
Information* Web API development in Visual Studio 2022 – Sayed Ibrahim Hashimi * Exploring JavaScript and TypeScript Development in Visual Studio – Jiayan Chen * Part 2 – Babylon.js 6.0: Key Rendering Advancements – Jason Carter & Thomas Lucchini * Application security context models – Damien Bowden * Reading Windows Application Manifest of an exe in .NET – Gérald Barré * F# Orleans reminder grain – Wesley Skeen * Refactoring pure function composition without breaking existing tests – Mark Seemann * Fight for every byte it takes: Optimizing the encoding process – & * Fight for every byte it takes: Decoding the entries – Oren Eini * Using modern decorators in TypeScript – Alec Brunelle * Interface Segregation Principle in TypeScript – Dhananjay Kumar * How AI coding companions will change the way developers work – Werner Vogels
Monday is a public holiday here in the UK, so usual The Morning Brew won’t be published on Monday, but will return on Tuesday
Information* Announcing .NET Community Toolkit 8.2! Faster generators, code fixers, performance improvements and more! – Sergio Pedri * Intellenum: intelligence, for your enums! – Steve Dunn * Building a CRUD API with Dapper – Assis Zang * Create your own Validationattribute in ASP.NET Core – Steven Giesel * Fight for every byte it takes: Fitting 64 values in 4 bits – Oren Eini * Troubleshooting Kafka with 2000 Microservices – Derek Comartin * Introducing Open Source Thursdays – Japhlet Nwamu
Information* Get Started with OpenAI Completions with .NET – Luis Quintanilla * A quick tour of dictionaries in C# – Jack Lewis * How to End-to-End Test SMS Applications with C# .NET and Twilio – Niels Swimberghe * Part 5: Tips & Tricks for Migrating from Xamarin to .NET MAUI – Rossitza Fakalieva * Migrating Animations from Xamarin Forms to Uno Platform – Uno Platform Team * Fight for every byte it takes: Nibbling at the costs – Oren Eini * Using ChatGPT as a technical writing assistant – Mike Mason * Can ChatGPT modernize my VB6 app? – John Browne
Information* .NET Framework April 2023 Cumulative Update Preview Updates – Salini Agarwal * Let’s Learn .NET Virtual Events – All Around the World – Matt Soucoup * Drawing Elements on Maps with .NET MAUI – James Montemagno * ScriptDOM .NET library for T-SQL parsing is now open source – Drew Skwiers-Koballa * Introduction to ASP.NET Core Minimal APIs – Khalid Abuhakmeh * Memory leaks in C# – Arun Kumar Palani * Codeless API Testing: Definition, Importance and Tools – John Iwuozor * ASP.NET Core Guidance – Bart Wullems * Fight for every byte it takes: Variable size data – Oren Eini * Super-charging ‘git rebase’ with ‘git absorb’ – Andrew Lock * GitHub Copilot for CLI for PowerShell – Scott Hanselman * How GPT models work – Bea Stollnitz
Information* Improving the Syntax Highlighting of JavaScript in Visual Studio – Armando Aguirre * Part 1 – Announcing Babylon.js 6.0 – Jason Carter & Thomas Lucchini * Domain events and the “Unit of Work” pattern – Steven Giesel * Isolating Side Effects from Wolverine Handlers – Jeremy D Miller * Top Free Tools for .NET Web API Load Testing and Benchmarking – Steve ‘Ardalis’ Smith * Type-safe ASP.NET Configuration in F# – Victor Freire * C# 11 features I like the most – Neel Bhatt * 10 Awesome C# Refactoring Tips – Assis Zang * Applying the decorator pattern in .NET Core using Castle.DynamicProxy – Bart Wullems * Setting an Absolute Output Path for .NET SDK Projects – Rick Strahl * Are pull requests bad because they originate from open-source development? – Mark Seemann * Allocation, sizing and freeing with double-wide bitmaps: Oh my! & Fight for every byte it takes: Storing raw numbers – Oren Eini * Sands of MAUI: Issue #100 ???? – Sam Basu * Join the .NET Team at Microsoft Build 2023! – Mehul Harry
Information* Simplest dependency injection setup for WPF and Prism 6 – Henrique Dalcin Dalmas * C# Design Patterns: The Strategy Pattern – Kenji Elzerman * Writing a .NET profiler in C# — Part 3 – Kevin Gosse * Introduction to gRPC with Fiddler Everywhere – Nikolay Iliev * The Importance of TLS with SQL Server – Michael Howard * One use case for NOT using schema prefixes – Aaron Bertrand
Information* Orleans v7.1.2 – Reuben Bond * Short Circuit Evaluation of IF Statements with Await in C# – Code Maze * Scaling a Monolith with 5 Different Patterns – Derek Comartin * Encapsulate libraries not frameworks – Bart Wullems
Information* Announcing TypeScript 5.1 Beta – Daniel Rosenwasser * Git Tooling Preview Features to Enhance Productivity – Jessie Houghton * A Guide to OpenTelemetry for .NET Engineers – Juan Reyes * Upgrading to .NET 6 -ASP0014 warning – Bart Wullems * Web API Updates with .NET 8 – Christian Nagel
Information* Reduce Lookups in HashSet, Dictionary and Other Collections With ReSharper – Maarten Balliauw * My 2023 C# Software Developer Tool List – Michael Shpilt * Need your Blazor sibling components to talk to each other? & How to Migrate Your Web Forms App to Blazor in 6 Steps – Jon Hilton * WireMock.NET – Troubleshooting – Cezary Pi?tek * Deep dive – Uno Platform Template Wizard – Framework, Platforms and Presentation – Nick Randolph * The Three Browser Storage Mechanisms – Hassan Djirdeh * Smoother rebases with auto-squashing Git commits – Andrew Lock * 2023 State of Web Components – Rob Eisenberg * Writing a Cross-Platform Clock App With Avalonia UI and NXUI – Khalid Abuhakmeh
Information* Information * Running non-root .NET containers with Kubernetes – Richard Lander * A restaurant example of refactoring from example-based to property-based testing – Mark Seemann * Exploring gRPC project in ASP.NET Core – Karthik Chintala * Covariance and Contravariance in C# – Steven Giesel * My advice for building maintainable, clean architecture & My advice for transitioning to a clean architecture platform – Maarten Vandeperre & Kevin Dubois * Aggregate Design in .NET – Code Maze * Monsters Weekly 267 – Updating Legacy ASP.NET Applications & Monsters Weekly 266 – Time Series Data with Postges – ASP.NET Monsters * Detecting Dark and Light themes in a WPF application – Gérald Barré * Creating Cross-Platform/Multi-Platform .NET Applications with Windows App SDK (WinUI) and the Uno Platform – Nick Randolph * ChatGPT Problems in Coding React Apps – Peter G Kellner * Redux Toolkit is the official way to write Redux apps – Stephen Hanson & Will Larry * Webinar – Stefan Pölz – How to test C# unit tests with mutation testing – Khalid Abuhakmeh
Information* Converting Strings to .NET Objects – IParsable and ISpanParsable – Christian Nagel * Amazon CodeWhisperer, Free for Individual Use, is Now Generally Available – Steve Roberts * New Azure Extensions in VSCode.dev! – Meera Haridasa * (The Futility of) Keeping Secrets from Yourself – Eric Lawrence * Testing a periodic worker – Cellfish * Mastering Azure AI: #30DaysOfAzureAI Week Two Recap – Dave Glover
Information* .NET 8 Performance Edition – Steven Giesel * Improving Visual Studio performance with the new Instrumentation Tool – Nik Karpinsky * Journey to Containers – Saverio Proto * How to secure legacy ASP.NET MVC against Cross-Site (CSRF) Attacks – Aneesh Lal Gopalakrishnan * Upcasting and Downcasting in C# – Code Maze * TLS 1.3—What is It and Why Use It? – Nikolay Iliev * An introduction to generative AI with Swami Sivasubramanian – Werner Vogels * An example of LLM prompting for programming – Martin Fowler & Xu Hao
Information* Get started with OpenAI in .NET – Luis Quintanilla * Announcing Azure Data Studio 1.43 – Erin Stellato * Announcing General Availability of Azure Data Studio extension SQL Database Projects – Drew Skwiers-Koballa * Auth Flows in a Partitioned World – Eric Lawrence * C# Tip: Access items from the end of the array using the ^ operator – Davide Bellone * State Hasn’t Changed? Why and when Blazor components re-render – Jon Hilton * Thinking About Code Review – Kent Beck * That weird slow benchmark and its root cause – Oren Eini * Dapr extension for AKS is available in 7 new regions – Hannah Hunter
Information* Announcing .NET 8 Preview 3 – Jiachen Jiang
* ASP.NET Core updates in .NET 8 Preview 3 – Daniel Roth
* Announcing .NET MAUI in .NET 8 Preview 3 – David Ortinau
* Check out new C# 12 preview features! – Kathleen Dollard
* .NET April 2023 Updates – .NET 7.0.5, .NET 6.0.16 – Rahul Bhandari
* 5 useful extensions for Task
Information* Visual Studio Toolbox: Debug Threads & Tasks with Parallel Stacks – Leslie Richardson * Triggering a .NET Lambda Function from an Amazon SQS Queue & Using Step Functions to Orchestrate a Series of Lambda Functions – Bryan Hogan * Anagrams kata as a one-liner – Mark Seemann * Investigating a crash in Enumerable.LastOrDefault with a custom collection – Gérald Barré * Running .NET Console Apps in Azure Container Instances – Mark Heath * Binding Generator Preview Release – Eric Sink * Learn how to modernize your .NET apps from the pros! – Jon Galloway * Debugging native memory issues in a C# application – Oren Eini * Announcing ImageSharp.Web 3.0.0 – Six Labors * Using Application Insights in .NET Desktop Applications – Rick Strahl * 11 API Security Best Practices to Secure Your Business – John Iwuozor * Tips for handling localized ranges in regular expressions – Carlos O’Donell * Trying out What ChatGPT Knows About XML Doc Comments – Roland Weigelt * We need to tell people ChatGPT will lie to them, not debate linguistics – Simon Willison * Object-Oriented vs. Functional Programming With C# and F# – Recording Available – Khalid Abuhakmeh
Friday and Monday are public holidays here in the England, so in keeping with Morning Brew tradition I will be taking a break and not publishing on those days. The Brew will return on Tuesday 11th April.
Information* What’s new in MSIX: April 2023 – Naveen Kumar Nooka
* Build Minimal APIs in .NET 7 – Beau Carnes
* C# 11.0 new features: Span
Information* Improvements to auth and identity in ASP.NET Core 8 – Jeremy Likness * An abstract example of refactoring from interaction-based to property-based testing – Mark Seemann * Turning off Tracking for Find and FindAsync in Entity Framework – Bryan Hogan * Adding client-side validation to ASP.NET Core, without jQuery or unobtrusive validation – Andrew Lock * LINQ on steroids with SIMD – Steven Giesel * Facade Pattern: A Beginner’s How-To for Simplified Code – Nick Cosentino * Slack – Martin Fowler * Let’s Build a React Admin Dashboard Sample App—Part 2 – Thomas Findlay * Generating SVG Images with ChatGPT – Frank A. Krueger
Information* ASP.NET Core Route Tooling Enhancements in .NET 8 – James Newton-King * Looking at C# 12 Proposals and Beyond – Michael Shpilt * Should you adopt .NET 7 or wait for .NET 8? – DeeDee Walsh * Programmatically evaluating policies in ASP.NET Core – Karthik Chintala * How to Unit Test ILogger in ASP.NET Core – Code Maze * The Journey with multi-tenancy accesses continues with some issues – Daniel Wertheim * Versioning in graph databases – Bart Wullems * Listing all available ETW events in a .NET application – Gérald Barré * Error Messages Are Our Friends – Crystal Williams-Brown
Information* Accessing Objects Just After they are Saved by Entity Framework – Bryan Hogan * Creating a ToolTip Component in Blazor – Steven Giesel * WireMock.NET – Introduction – Cezary Pi?tek * TypeScript–Template literal types – Bart Wullems * Docs As Part Of The Developer Experience For MSAL – Den Delimarsky * Happy April Tools Day! – Erin Stellato * How to use AI to do practical stuff: A new guide – Ethan Mollick * AI is morphing from tool to platform (and the next technology epoch begins) – Colin Eberhardt * The Future of Senior Developers in an AI-Driven World – Christian Heilmann * Supercharge your AI skills with #30DaysOfAzureAI launching today with daily posts throughout April – Dave Glover
Information* Vendor-Agnostic Telemetry Using OpenTelemetry Collector in .NET – Phil Broderick * ReSharper IL Viewer and Low-Level C# – Khalid Abuhakmeh * Safari 16.4 Support for WebAssembly fixed-width SIMD. How to use it with C# – Gerard Gallant * Using soft limits to prevent abuse with good user experience – Cellfish * Azure – Data API Builder – Bart Wullems * A Beginners Guide to MySQL Replication Part 1 – Aisha Bukar * Schillace Laws of Semantic AI – Microsoft Learning
Information* Improving multi-platform container support – Richard Lander * Observability in Wolverine – Jeremy D Miller * “I NEED data from another service!”… Do you really? – Derek Comartin * Learning from failure in software – Bart Wullems * REST APIs: What They Are and All You Need to Know – John Iwuozor * How to Delete Elements from an Array in C# – Code Maze * Understanding TypeScript Function Types: A Beginner’s Guide – Dmitri Pavlutin * An Introduction to Microsoft Graph SDK and How to Create a To-Do List Using JavaScript – Kevin Gatimu * Storing information in its highest form · Enterprise Craftsmanship – Vladimir Khorikov * GitHub Copilot for the Command Line is amazing! – Christian Heilmann * How to Review and Refactor Code with GPT-4 (and ChatGPT) – Mark O’Neill
Information* Understanding the .NET ecosystem: The introduction of .NET Standard – Andrew Lock * C# – Clean up your exception handling logic with Exception Filters – Bart Wullems * Primary Constructors with C# – Christian Nagel * From Ancient Greeks to Modern Geeks: Basic Machine Learning Algorithms in C# – Part Two: The Bayes Classifier – Simon Painter * .NET MAUI App Stopped Working — HELP! – Khalid Abuhakmeh * Debunking Web Component Myths and Misconceptions – Rob Eisenberg * Part 1: Should We Migrate from Xamarin.Forms to .NET MAUI? When? – Rossitza Fakalieva * How to Create a Custom Authorize Attribute in ASP.NET Core – Code Maze
Information* More functional pits of success – Mark Seemann * Multiple authorization handlers for the same requirement in ASP.NET Core – Karthik Chintala * Smallest Minimal Web API in .NET? – Bryan Hogan * Authenticate externally, authorize locally & How to create a NuGet metapackage – Daniel Wertheim * Handling CancelKeyPress using a CancellationToken – Gérald Barré * Share reusable UI components through a Razor class library – Bart Wullems * Are you sure you need that ‘else’ – Extend your Blazor components – Jon Hilton * Azure Functions: Version 4 of the Node.js programming model is in preview – Lily Ma * AI-enhanced development makes me more ambitious with my projects – Simon Willison * How ChatGPT Plugins (could) work – Marco Aurelio Cardoso
Information* MongoDB, C# and DateTime’s – Daniel Wertheim * How to Create a Custom JsonConverter in Json.NET – Ahsan Ullah * The difference between libraries and frameworks – Goodness Woke * ChatGPT + .NET Slackbot – John Korsnes * The lost art of writing SQL queries – Bart Wullems * The SQL Injection Guide: Attacks, Types, Signs & Defense Against SQLi – Muhammad Raza * How Microsoft Edge Updates – Eric Lawrence * WYSIWYGPT – Christian Heilmann
Those paying attention today will be glad to see that my typing fingers are operating correctly today and that today’s post has the right title!
Information* Discover .NET 7 SDK Containers – Support for Authentication and Cross-architecture Builds – Chet Husk * Akka.NET v1.5: No Hocon, No Lighthouse, No Problem – Aaron Stannard * .NET 8 Preview 2 Unveiled: 5 New Features You Need to Know – ByteHide * A Demo On Clean Architecture | MediatR CQRS Pattern | .NET7 Web API – Naveen Bommidi * Techniques for Testing Mobile Apps vs. Web Apps – Amy Reichert * Create a portfolio website without installing any tools – Katie Savage * Building Static Web Apps with database connections: Best Practices – Thomas Gauvin * Azure Functions – Part 2 – Unit and Integration Testing – Orestis Meikopoulos * Buy vs Build… Over Time – Ted Neward
Information* Upgrading from IntelliCode custom team completions models to deep learning. – Aaron Yim * GitHub Copilot chat for Visual Studio 2022 – Mark Wilson-Thomas * Remote Development with JetBrains Rider – Khalid Abuhakmeh * Don’t Fail Publishing Events! – Derek Comartin * How to enable OpenTelemetry traces in React applications – Purva Naik * The 2023 guide to React debugging – Anna Monus
Information* Secure your .NET cloud apps with rootless Linux Containers – Richard Lander * A Quick Overview of Supply Chain Attacks – Devlin Duldulao * .NET Performance Delivers Again for Bing, From .NET 5 to .NET 7 – Ben Watson * Streamlining your Debugging process with Breakpoint Groups – Harshada Hole * Understanding the .NET ecosystem: The evolution of .NET into .NET 7 – Andrew Lock * Calling Web APIs using the dotnet CLI and HTTP Files with Visual Studio – Christian Nagel * .NET MAUI Development Environment Set Up Walkthrough – Khalid Abuhakmeh * Introducing GPT-4 in Azure OpenAI Service – Eric Boyd * The React useContext Hook – Hassan Djirdeh * How to investigate 7 common problems in production – Michael Dawson * On trust in software development – Mark Seemann * Bean Machine Retrospective, part 9 – Eric Lippert
Information* Announcing: Azure Developers – .NET Day – Mehul Harry * File and Folder dialogs in .NET MAUI with CommunityToolkit – Vladislav Antonyuk * A first look at Blazor and .NET 8 – Damien Bowden * ASP.NET Core 7: Beware of the Swagger bug when binding arrays in headers with Minimal APIs – Anthony Giretti * Configuring .NET Garbage Collection for Amazon ECS and AWS Lambda – Norm Johanson * Too many timers in .NET? – Gérald Barré * Policy-Based Authorization in ASP.NET Core – Karthik Chintala * .NET Core – Remove older SDKs and runtimes – Bart Wullems * Lighthouse meet GitHub Actions – John Reilly * Paging Data in T-SQL – Greg Larsen
Information* ASP.NET Core7: Use endpoint groups to manage minimal APIs versioning – Anthony Giretti * Iterator Benchmarks That Shocked With Unexpected Results – Nick Cosentino * Something Pretty Right – The history and egacy of Visual Basic – Ryan Lucas * Migrating from ts-node to Bun – John Reilly * What’s New in the Updated React Docs – Kathryn Grayson Nanz * Webinar – Object-Oriented vs. Functional Programming With C# and F# – Khalid Abuhakmeh
Information* Announcing TypeScript 5.0 – Daniel Rosenwasser * How Async/Await Really Works in C# – Stephen Toub * Help us investigate a new Welcome Experience in Visual Studio 17.6 Preview 2 – Grace Taylor * Testing WITHOUT Mocks or Interfaces! – Derek Comartin * Many Ways to make and Deserialize an HTTP GET with HttpClient – Bryan Hogan * How to Integrate Blazor WebAssembly into an Existing ASP.NET Core Web Application – Carey Payette * A Small Demo On OData(v8) In .NET 7 API Application – Naveen Bommidi * Implementing Text-to-Speech in C# using System.Speech.Synthesis – Ali Robot * Immutable Collections in C# – Code Maze
Information* Announcing Polyglot Notebooks! Multi-language notebooks in Visual Studio Code – Claudia Regio * Improving the Spell Checker – Dante Gagne * Server Timing API Meets Isolated Worker Process Azure Functions – Custom Middleware and Dependency Injection – Tomasz P?czek * Pi to 100 places with Amazon Polly and .NET & Polly with .NET 6, Part 8 – Policy Registry with Minimal APIs, and HttpClientFactory – Bryan Hogan * How to Validate React Props Using PropTypes – John Au-Yeung * How can I create a git feature branch that can merge into multiple other branches? – Raymond Chen
Information* Announcing .NET 8 Preview 2 – Alexandra Barry * ASP.NET Core updates in .NET 8 Preview 2 – Daniel Roth * EF Core 8 Preview 2: Lite and familiar – Arthur Vickers * Visual Studio 2022 v17.6 Preview 2 is now available – Marian Luparu * .NET March 2023 Updates – .NET 7.0.4, .NET 6.0.15 – Rahul Bhandari * System.Text.Json Serializing Hierarchical Data – Christian Nagel * Solving .NET JSON Deserialization Issues – Khalid Abuhakmeh * Making gRPC Compatible with the Rest of the World … and the Rest of Your Application – Peter Vogel * Monsters Weekly 264 – Debugging a .NET process at start-up with Visual Studio – ASP.NET Monsters * Static Interface Members, Generic Attributes, Auto-Default Structs – Using C# 11 in Rider and ReSharper – Matthias Koch * Using Github Copilot in Visual Studio – Bart Wullems * Accessibility Testing 101—Test Strategies & Tools – Amy Reichert * Terning On a Control – Remy Porter
Information* .NET 7 SDK built-in container improvements – Laurent Kempé * Confidence from Facade Tests – Mark Seemann * GraphQL HotChocolate – Method overloading for queries – Bart Wullems * ExternalFinalizer: Adding a finalizer to 3rd party objects – Oren Eini * Output Caching in ASP.NET Core – Ryan Miranda * Bring the ChatGPT model into our applications – Matteo Pagani * Visual ChatGPT – Microsoft
Information* To Infinity and Beyond, with Cloudflare Cache Reserve – Troy Hunt * How to Handle Enums in the Input to a .NET AWS Lambda Function – Bryan Hogan * Uploading Large Blobs in Parallel with the Azure SDK – Mark Heath * Building Functional .NET Applications: a Guide for Choosing between F# vs C# – Nahla Davies * Manipulating CSV Files in .NET – Assis Zang * Armchair Architects: Architectural Erosion and Technical Debt – Ben Brauer * Lean BDD with even more Code Generation – Sebastian Ssmoller * A simple guide to continuous deployment – Zachary Jansma * Stubbles – Stubbing and Doubles innit. ???? – Sami Birnbaum
Information* TypeScript’s Migration to Modules – Daniel Rosenwasser & Jake Bailey * Visual Studio 2022 – 17.5 Performance Enhancements – Nayana Srikanth * What’s new for the WinForms Visual Basic Application Framework – Klaus Loeffelmann & Melissa Trevino * Implementing the Producer Consumer Pattern with TPL Dataflow – Mark Heath * Announcing Log Monitor 2.0 Release Candidate – Lucille Xiong * DRY Gone Bad: Bespoke Company Frameworks – Aaron Stannard * Embed Blazor Components in Any Webpage with .NET 7’s Official Custom Elements Support – Jon Hilton * Uno Platform and Bluetooth LE: An Easy-to-Follow Guide to Building a Bluetooth Explorer – Uno Platform Team * Domain Events in Event Sourcing? Not Exactly! – Derek Comartin * ChatGPT is now available in Azure OpenAI Service – Eric Boyd * Generate images with AI using Stable Diffusion, C#, and ONNX Runtime – Luis Quintanilla & Cassie Breviu
Information* Developing Accessible Apps with Visual Studio – Dante Gagne * .NET Monthly Roundup – February 2023 – .NET 8 Preview 1, New Visual Studio features, and more! – Jon Galloway * Compound Handlers in Wolverine – Jeremy D Miller * When a Development Team Is Having Trouble Delivering, It Could Be a Sign of Bad Planning – Tyler Hakes * How to Find the Caller Method in C# – Code Maze * Do you know what good code looks like? – Matt Lacey * How Discord Stores Trillions of Messages – Bo Ingram
Late publishing today as the auto publish didn’t work today (probably user error last night when I was putting it together) – thanks to those who let me know
Information* Introducing the Reliable Web App Pattern for .NET – Matt Soucoup & Nish Anil * Azure Open-Source Day: Announcing new integrations with Azure Database for MySQL – Parikshit Savjani * Announcing new security and observability features in Azure Database for PostgreSQL – Sunil Agarwal * Wolverine 0.9.13: Contextual Logging and More – Jeremy D Miller * Validating Connection Strings on .NET Startup – Khalid Abuhakmeh * Performance benchmarks of PostgreSQL .NET with Npgsql, Dapper, and Entity Framework Core – Michael Shpilt * EF Core Mapping with Generic Types, Value Conversion, and JSON Columns – Christian Nagel * Visual Studio – ;Git line staging – Bart Wullems * Drawing graphs in GitHub comments with Mermaid diagrams – Andrew Lock * Five tips for successfully managing dependencies – Tyler Aldrich
Information* Warnings-as-errors friction – Mark Seemann * Testing Roslyn Incremental Source Generators – Gérald Barré * Disabling Controller methods in ASP.NET Core – Ryan Southgate * How to Setup Integration Tests in .NET Without a WebApplicationFactory – Paul DeVito * Role-based Authorization in ASP.NET Core – Karthik Chintala * Required Keyword, Checked Operators, nameof Operator Scope – Using C# 11 in Rider and ReSharper – Matthias Koch * Can WebAssembly Solve Serverless’s Problems? – B. Cameron Gain * How to build, test and deploy your application using Azure and GitHub – Liam Hampton * Auto sign-out using ASP.NET Core Razor Pages with Azure AD B2C – Damien Bowden
Information* Akka.NET v1.5 is Now Available – Aaron Stannard * Announcing ImageSharp 3.0.0 – Six Labours * Critter Stack Roadmap (Marten, Wolverine, Weasel) – Jeremy D Miller * Simple HTTPS with Caddy Ingress on AKS – Mark Heath * We want your feedback! Introducing Polly v8 – Joel Hulen * Myths about F#: Imperative code is simpler than functional code! No, not at all, but you are more used to it. – Urs Enzler
Information* Microsoft Teams’ Permission Service migration to .NET 6 – Diogo Barbosa * Build Better Extensions with VisualStudio.Extensibility Preview 3! – Maia Kelner * How to Handle Numbers Represented as Strings in the Input to a .NET AWS Lambda Function – Bryan Hogan * Delegates – Eric Sink * Package Validation – Bart Wullems * Write a high-quality README for NuGet packages – Lynn Dai * How To Deploy EF Database Migrations – Lee Richardson * Adding Audio Visualization to a React App Using the Web Audio API – Ifeoma Imoh
Information* Announcing TypeScript 5.0 RC – Daniel Rosenwasser * GitHub Copilot in Visual Studio 2022 – Mads Kristensen * Useful Tricks with Lamar for Integration Testing – Jeremy D Miler * Difference Between Returning and Awaiting a Task in C# – Ahsan Ullah * Introducing Azure Communication Services UI Library to Xamarin & .NET MAUI – Josh Lai * Blazor’s New LocationChanging Events in .NET 7 – Jon Hilton * What is Podman Desktop? A developer’s introduction – Ian Lawson * Functional Testing: Definition, Types and Importance – John Iwuozor * Announcing the end of Windows Installer support for AWS Tools for Windows – Norm Johanson
Information* Try Visual Studio 2022 v17.6 Preview 1 – Marian Luparu * Introducing F# Inline Type & Parameter Name Hints in Visual Studio – Petr Semkin * The fastest way to add files and folders – Grace Taylor * Announcing NuGet 6.5 – The Sweetest Way to Manage Your Packages – Jon Douglas & Nikolche Kolev * Customising the RequestDelegate with filters – Behind the scenes of minimal APIs – Part 8 – Andrew Lock * Speed Up ASP.NET Core JSON APIs with Source Generators – Khalid Abuhakmeh * Debugging Visual Studio issues – Bart Wullems * Lambda cold starts for .NET applications are not so bad – Bryan Hogan * Sentence Similarity in ML.NET Model Builder – Luis Quintanilla * How to Use GitHub Copilot Labs to improve your Code Quality and Productivity – Kevin Gatimu * Automatically generating tests for JS/TS functions in VS Code with GitHub Copilot – Christian Heilmann * Resiliency with Wolverine – Jeremy D Miller * Getting Out of Character – Joe Celko * Get started with Microsoft Graph .NET SDK! – March 2nd 4PM GMT – Someleze Diko * Join us for Hack Together: Microsoft Graph and .NET – Waldek Mastykarz
Information* Test Data Generator monad – Mark Seemann * Producer/Consumer Pattern with Wolverine – Jeremy D Miller * Raw Strings, UTF-8 Strings, and Multiline Interpolations – Using C# 11 in Rider and ReSharper – Matthias Koch * Serverless URL Shortener – Prakash Palanisamy * Backend API design principles: Don’t mirror your data – Oren Eini * WPF Begins its Long Goodbye – Matthew MacDonald * Extending the System Menu to add advanced commands in .NET – Gérald Barré * Debugging Dapr applications with Rider or Visual Studio: A better way – Laurent Kempé
Information* What To Be Wary of With Iterators and Collections in C# – Nick Cosentino * Scaling Akka.Persistence.Query to 100k+ Concurrent Queries for Large-Scale CQRS – Aaron Stannard * Conditional Middleware in Isolated Azure Functions – Adam Storr * Monsters Weekly 263 – Postgresql and Entity Framework – ASP.NET Monsters * Testing Without Mocks: A Pattern Language – James Shore * How Shadow DOM and accessibility are in conflict – Alice Boxhall * .NET Systems Programming Learned the Hard Way – Webinar Recording – Khalid Abuhakmeh * Azure Open Source Day 7th March 2023 – Lee Stott
Information* Updated Modern Code Generation for WinForm’s InitializeComponent – Klaus Loeffelmann * Reference GitHub Issues and Pull Requests in Visual Studio – Jessie Houghton * Applying Postel’s law in ASP.NET Core–Part II – Bart Wullems * How to use the .NET CLI clean-up tools on macOS – Marco Siccardi * Command Line Diagnostics in Wolverine – Jeremy D Miller * The Challenge of Microservices: UI Composition – Derek Comartin * Blazor United – Solving Blazor’s biggest challenges? – Jon Hilton * .NET MAUI Challenge 5: Telerik Barcode – Leomaris Reyes * Bean Machine Retrospective, part 8 – Eric Lipper * Find 40 Problems in this SQL Server Stored Procedure – Aaron Bertrand
Information* Visual Studio 2022 can now Always Update on Close! – Sayyeda Mussa * Maximizing the value of IntelliCode with API usage examples: Real-World Code Examples at Your Fingertips – Peter Groenewegen * C# “var” with a Reference Type is Always Nullable – Jeremy Clark * Create Clean Guard Clauses With GuardClauses in C# – Code Maze * Applying Postel’s law in ASP.NET Core–Part I – Bart Wullems * Automatic Instrumentation of Containerized .NET Applications With OpenTelemetry – Rahul Rai * Re-thinking the Visitor Pattern with the Double-Dispatch Approach – Huy Luong * Consistent hashing algorithm – NK
Information* Announcing .NET 8 Preview 1 – Jeremy Likness * ASP.NET Core updates in .NET 8 Preview 1 – Daniel Roth * EF Core 8 Preview 1: Raw, lazy, and on-time – Arthur Vickers * Visual Studio 2022 – 17.5 Released – Anthony Cangialosi * Visual Studio for Mac 17.5 is now available – Iain Holmes * Building the final RequestDelegate – Behind the scenes of minimal APIs – Part 7 – Andrew Lock * C# 11–The scoped keyword – Bart Wullems * How Hangfire Helps Your .NET API Perform Out-of-Process Tasks with Resilience and Speed – Paul DeVito * Combining 11ty Static Site Generator with ASP.NET Core – Khalid Abuhakmeh * Refactoring huge C# code base in minutes – Laurent Kempé * Getting the JSON sent to a Lambda Function when Deserialization Fails – Bryan Hogan * PostgreSQL Basics: Object Ownership and Default Privileges – Ryan Booz * Join Brendan Burns, Donovan Brown and others for Azure Open Source Day on March 7th! – Katie Fritsch
Information* List and Span Pattern Matching – Using C# 11 in Rider and ReSharper – Matthias Koch * How Hangfire Helps Your .NET API Perform Out-of-Process Tasks with Resilience and Speed – Paul DeVito * Using Hangfire with ASP.NET Core – Damien Bowden * Creating a custom Main method in a WPF application – Gérald Barré * So, you want to safely authenticate with 2FA? App stores are still not the solution – “why the web is dead” revisiTED – Christian Heilmann * Down the Cloudflare / Stripe / OWASP Rabbit Hole: A Tale of 6 Rabbits Deep ???? ???? ???? ???? ???? ???? – Troy Hunt * Integrate Google Sign-in into an Asp.Net Core 7 Application – Paul Michaels * GitHub Codespaces and GitHub Copilot: 2 stories, thousands of possibilities – Carlotta Castelluccio
Information* Pair Programming and test-driven development with Visual Studio Live Share and GitHub Copilot – Lee Stott * Building Functional .NET Applications: A Guide for Choosing Between F# vs C# – Nahla Davies * Async Event Methods and preventDefault() in JavaScript – Rick Strahl * Writing Javascript without a build system – Julia Evans * How to create a video and audio recorder in React – Iniubong Obonguko * .NET MAUI Challenge 4: Telerik DataGrid – Leomaris Reyes
Information* Upgrading your .NET projects with Visual Studio – Olia Gavrysh * GitHub Copilot Update: New AI Model That Also Filters Out Security Vulnerabilities – Anthony Bartolo * HSTS in IIS – Bart Wullems * Getting Started with Generics in .NET – Assis Zang * Azure Machine Learning Introduction: Part 1 Overview and prep work – Sanil Mhatre * Myths about F#: F# has too many operators – Urs Enzler * Optimizing Uno Platform WebAssembly Applications for Peak Performance – Uno Platform Team * Modularizing React Applications with Established UI Patterns – Juntao QIU (full artice) * How To Create Custom React Hooks – John Au-Yeung * 7 reasons to join us at Azure Open Source Day – David Dennis
Information* MediatR 12.0 Released – Jimmy Bogard * Generating Bogus HTTP Endpoints with ASP.NET Core Minimal APIs – Khalid Abuhakmeh * Github – Secret scanning & Generate a self-signed certificate for .NET Core – Bart Wullems * What’s enough Complexity for a Domain Model? – Derek Comartin * Modularizing React Applications with Established UI Patterns – New requirement: donate to a charity – Juntao QIU * Build smaller container images using S2I – Lumír Balhar * Retrospectives Antipatterns – Aino Corry
Information* .NET February 2023 Updates – .NET 7.0.3, .NET 6.0.14 – Rahul Bhandari * .NET Framework February 2023 Security and Quality Rollup Updates – Salini Agarwal * Improvements to .NET Framework updates for Windows 11, version 22H2 – Brett Lopez * What is .NET, and why should you choose it? – Jan Kotas, Rich Lander, Maoni Stephens & Stephen Toub * Thoughts on ‘What is .NET, and why should you choose it?’ – Andrew Lock * Wolverine’s New HTTP Endpoint Model – Jeremy D Miller * Async EventHandlers – A Simple Safety Net to the Rescue – Nick Cosentino * Introducing Search By Target Framework on NuGet.org – Jon Douglas & Advay Tandon * Use multiple identity providers from a Blazor WASM ASP.NET Core App secured using BFF – Damien Bowden * Getting Started: Entity Framework Core 7 JSON Support – Khalid Abuhakmeh
Information* Visual Studio AI-Assistance: A Developer’s Best Friend – Peter Groenewegen * Digging Into Nullable Reference Types in C# – Shawn Wildermuth * What’s On Tap for .NET 8 (Preview 1 Coming this Month) – David Ramel * Prevent accidental disclosure of configuration secrets – Gérald Barré * Epistemology of interaction testing – Mark Seemann * What is an Azure Load Balancer? – CaryRoys * Modern Mono – Tim Bray
Information* Iterators – An Elementary Perspective on How They Function – Nick Cosentino * AsyncAPI.NET – Lego Engineering * What’s New in .NET 7 for Minimal APIs? – Assis Zang * Container Service Options and Guidance in Azure – Faisal Mustafa * Lean BDD and Code Generation – Sebastian Ssmoller * .NET Dependency Injection With Constructor Parameters – Code Maze * In defence of pull requests | johnnyreilly – John Reilly * Where programs live Vague spaces and software systems – Tomas Petricek
Information* Must follow C rules, no exceptions – Eric Sink * Extracting Form Fields from a Multi-Page PDF AWS Textract and .NET – Bryan Hogan * Unit testing- Arrange Act Assert – Bart Wullems * Which Software Architecture Patterns do you use? – Derek Comartin * How to ask for programming help – Louis Davidson * From clone to running a code base in under 5 minutes – Dennis Doomen
Information* What’s new in the MSIX Packaging Tool: February 2023 – Naveen Kumar Nooka * How to customize Conventional Commits in a .NET application using GitHooks – Davide Bellone * C# – Value Object Pattern, Data Transfer Object Pattern & C#11 – Records Demystified – Mark Pelf * .NET MAUI Challenge 3: Telerik DateTimePicker – Leomaris Reyes * Porting Custom Controls from Xamarin Forms to Uno Platform – Uno Platform Team * Modularizing React Applications with Established UI Patterns – Introduction of the Payment feature – Juntao QIU * 10 Tips and Tricks to Handle JavaScript Objects – Charuka Herath * Bean Machine Retrospective, part 7 – Eric Lippert
Information* Generating the response writing expression for RequestDelegate – Behind the scenes of minimal APIs – Part 6 – Andrew Lock * C#11 – Immutable Object Pattern & C#11 – Immutable Object and Defensive Copy – Mark Pelf * How to use Entity Framework Core in ASP.NET Core – Khalid Abuhakmeh * Extracting Key-Value Pairs from Document Form Fields with AWS Textract and .NET – Bryan Hogan * The business value of frequent deployments: Recouped time – Stephen Fontanella * The cost of timing out – Oren Eini * Refactoring Bloated Code in C# – Code Maze * Modularizing React Applications with Established UI Patterns – Juntao QIU * A Historical Reference of React Criticism – Zach Leatherman * A Button Only Date Picker and JavaScript Date Control Binding – Rick Strahl
Community* Tech Conferences .NET – Bryan Hogan
Information* Update to the .NET language strategy – Kathleen Dollard * ASP.NET Core Dev Team Launches ‘Blazor United’ Push for .NET 8 – David Ramel * Contravariant functors as invariant functors – Mark Seemann * Property based testing in C#–Part 5 – Bart Wullems * IEnumerable in C# – A Simplified Beginner Guide – Nick Cosentino * PostgreSQL in C# .NET with Npgsql, Dapper, and Entity Framework: The Complete Guide – Michael Shpilt * Using source-generated regex in ASP.NET Core route constraints – Gérald Barré * Challenges 7-12: Implementing and breaking AES ECB – Scott Brady * React in 2023 and Beyond – Adhithi Ravichandran
Information* Visual Studio Code – January 2023 (version 1.75) – Visual Studio Code Team & contributors * Everything You Wanted to Know About Multiline Strings – Nick Cosentino * Extensibility in your applications – Bart Wullems * MonoBuild – John Efford * .NET Monthly Roundup – January 2023 – Jon Galloway * Why is Clean Architecture so Popular? – Derek Comartin * .NET Rocks – Clean Architecture in 2023 with Steven Smith – Carl Franklin, Richard Campbell & Steve Smith * Top F# Backend Web Frameworks in 2023 – Hamilton * Basic Windows Machine Hardware information from WMI for Exception Logging from .NET – Rick Strahl * The names of birds, part 4 – Eric Lippert * Webinar – Aaron Stannard – .NET Systems Programming Learned the Hard Way – Khalid Abuhakmeh
Today’s edition got a little stuck in the machine – looks like the instruction to post at 6am didn’t get saved and the post remained as a draft. Thanks to those who let me know
Information* Extracting Text from an Image with AWS Textract and .NET – Bryan Hogan * AOP with Interceptors and IL Code Weaving in .NET Applications – Engincan Veske * Writing a Custom SQLite Function (in C) – Part 1 – Karl Seguin * PostgreSQL Constraints: Learning PostgreSQL with Grant – Grant Fritchey * On AI, GPT and the future of developers – Oren Eini * Introducing ChatGPT Plus – OpenAI * Integrating ChatGPT into Software Development Workflow: Tips and Best Practices – Lakindu Hewawasam * Why You Should Use AI to Improve Your Productivity As a Software Developer – Tyler Hakes
Information* Microsoft Azure Load Testing is now generally available – Mandy Whaley * New Wolverine Release & Future Plans – Jeremy D Miller * Application Insights–OpenTelemetry integration for ASP.NET Core – Bart Wullems * Getting started with ML.NET – Khalid Abuhakmeh * The Ultimate Guide to JavaScript Error Handling – Craig Buckler * The State of WebAssembly – 2022 and 2023 – Gerard Gallant * What Surprised Me About ECMAScript Modules – Shawn Wildermuth * The DevOps Automation Guide – Shanika Wickramasinghe * The names of birds, part 3 – Eric Lippert
Information* A “gotcha” with object handles – Eric Sink * Generating argument expressions for minimal APIs (continued) Behind the scenes of minimal APIs – Part 5 – Andrew Lock * Optimizing Queries in MySQL: Optimizing Reads – Lukas Vileikis * Play Audio and Video in .NET MAUI apps with the new MediaElement – Gerald Versluis * .NET MAUI Challenge 2: Light and Dark Mode in .NET MAUI – Leomaris Reyes * A Breakdown of the React useEffect Hook – Hassan Djirdeh * Custom React Hooks and When to Use Them – Stephen Hanson
Information* Generating Sample Data with Bogus – Shawn Wildermuth * My experience with migrating my app from Xamarin.Forms to .NET MAUI – Andreas Nesheim * Built-in alternatives to applicative assertions – Mark Seemann * Windows I/O completion – One little trick – James Sturtevant * Mocking an HttpClient using ASP.NET Core TestServer – Gérald Barré * Central Package Management – warning NU1507: There are 2 package sources defined in your configuration. – Bart Wullems * async void – Taming the Asynchronous Nightmare – Nick Cosentino * Using multi-tenant AAD delegated APIs from different tenants – Damien Bowden * CI/CD: Automating Tests and Deployments the Fun Way – Victoria Guido & Christopher Kuttruff * The names of birds, part 2 – Eric Lippert
Information* Announcing TypeScript 5.0 Beta – Daniel Rosenwasser * .NET Framework January 2023 Cumulative Update Preview – Salini Agarwal * Steve Sanderson Wows Web-Devs with Peek at ‘Blazor United’ for .NET 8 – David Ramel * What’s New in EF Core 7.0 – Assis Zang * How to design APIs for Accessibility – Matthew Adams * Getting started with ML.NET – Carlotta Castelluccio * Minimize Delivery Risk with Progressive Release – comiscience * Structured data, SEO and React – John Reilly * Technical writing resources – Rachel Andrew
Information* The Developer Ecosystem in 2022: Key Trends for C# – Rachel Appel * That’s NOT an Aggregate in Domain Driven Design – Derek Comartin * 9 Tips to Reduce WPF App Startup Time – Andrey Slabov * #Monsters Weekly 262 – Getting Started with PostgreSQL in C# – ASP.NET Monsters * .NET MAUI Challenge 1: Simple Grid in .NET MAUI – Leomaris Reyes * Ask thoughtbot CTO – All About CI / CD – Joe Ferris, Akshith Yellapragada, Victoria Guido & Christopher Kuttruff
Information* Azure Data Studio 1.41 release – Erin Stellato * Introducing the Git Status Bar and Testing Improvements in Visual Studio for Mac 17.5 – Iain Holmes * AWS Lambdas with C# – Camilo Reyes * Using Command Binding in Windows Forms apps to go Cross-Platform – Klaus Loeffelmann * Translation and Text to Speech with Amazon Polly and .NET – Bryan Hogan * Performance: The Fastest Way to Loop Over an Array in Microsoft .NET – David McCarter * 2022 Akka.NET Year-in-Review and Future Roadmap – Aaron Stannard * Tracing .NET Applications Easily With OpenTelemetry – Phil Broderick * Pythonnet – A Simple Union of .NET Core and Python You’ll Love – Nick Cosentino * Objects – Eric Sink * We invested 10% to pay back tech debt; Here’s what happened – Alex Ewerlöf
Information* Documents and tool windows unleashed – Mads Kristensen * Generating argument expressions for minimal APIs – Behind the scenes of minimal APIs – Part 4 – Andrew Lock * Property based testing in C#–Part 4 – Bart Wullems * The business value of frequent deployments – Stephen Fontanella * Programming SVGs with C# – Khalid Abuhakmeh * Which collection interface to use? – Vladimir Khorikov * Sum function using “generic math” and head and tail functions – Ji?í ?in?ura * Understand How Rendering Works in React – Ifeoma Imoh * Handling external API errors: A resumable approach – Thiago Araújo Silva * Keyboard Shortcuts to Master Your Git Flow in Visual Studio – Jessie Houghton
Information* Nullable reference types – Using the required keyword in C# 11 – Bart Wullems * Reactive programming in F# – Tom Sloboda * 5 .NET MAUI Features for Building Great Desktop Apps – James Montemagno * Static libraries – Eric Sink * Basic Authentication in ASP.NET Core – Damien Bowden * Using .NET code from JavaScript using WebAssembly – Gérald Barré * Realistic Data Generation in .NET With Bogus – Marko Hrn?i? * Keyboard Shortcuts to Master Your Git Flow in Visual Studio – Jessie Houghton * Agilean – Mark Seemann
Community* TheJam.dev 2023 – 25 Jan – 26 Jan, 2023 – free virtual conference
Information* .NET Framework January 2023 Cumulative Update Preview – Salini Agarwal * PowerShell Extension for Visual Studio Code January 2023 Update – Sydney Smith * Released: General Availability of Microsoft.Data.SqlClient 5.1 – David Engel * Saving Christmas with Functional C# – Part Two – Indefinite Loops – Simon Painter * Implementing Zero Trust: A Guide to Securing Your Data – Anthony Bartolo * PostgreSQL Basics: Roles and Privileges – Ryan Booz * How to Implement Google Authentication in a Next.js App Using NextAuth – Chinedu Imoh * The Full-Stack Developer Fallacy – Ted Neward
Information* Visual Studio Spell Checker Preview Now Available – Dante Gagne * Property based testing in C#–Part 3 – Bart Wullems * Securely store secrets in Git using SOPS and Azure Key Vault – Patrick van Kleef * 2022 Akka.NET Year-in-Review and Future Roadmap – Aaron Stannard * It’s 2023, You Should Be Using Typescript! – Adhithi Ravichandran * Azure OpenAI is now generally available – Carlotta Castelluccio * Roll with us at SQLBits 2023! – Marisa Mathews
Information* Visual Studio 2022 17.5 Preview 3 is here! – Anthony Cangialosi * Announcing .NET Community Toolkit 8.1! Better, faster MVVM source generators, .NET 7 support, and more! – Sergio Pedri * Checking for Overflow in C# – Jeremy Clark * Native AOT Overview – Eric Sink * How to set the package version when using dotnet pack – Bart Wullems * Head and Tail using list patterns in C# – Ji?í ?in?ura. * McDonald’s Journey to Event-Driven Architecture – Derek Comartin
Information* New: Better search in Visual Studio – Leah Tran * General availability of Azure OpenAI Service expands access to large, advanced AI models with added enterprise benefits – Eric Boyd * Securing Sensitive Information with .NET User Secrets – Khalid Abuhakmeh * How to deploy .NET apps as systemd services using containers – Tom Deseyn * Exploring the model-binding logic of minimal APIs – Behind the scenes of minimal APIs – Part 3 – Andrew Lock * Simplify Your Blazor Applications Using .NET 7’s New Bind Modifiers – Jon Hilton * Multiple File Drag and Drop Upload with ASP.NET Core – Khalid Abuhakmeh * NHibernate – Using record types – Bart Wullems * Manage Data Over Time with SQL Server MERGE Statement – Greg Larsen * The names of birds, part 1 – Eric Lippert
Information* Property based testing in C#–Part 2 – Bart Wullems * Reducing Blazor WASM size by providing custom ICU data – Gérald Barré * BlazorForms Low-Code Open-Source Framework. Part 1: Introduction and Seed Projects – Ev Uklad * Implementing secure Microsoft Graph application clients in ASP.NET Core – Damien Bowden * Encrypting and Decrypting a String in C# – Code Maze * In the long run – Mark Seemann * Why we focus on AI (and to what end) – James Manyika * Production postmortem: The heisenbug server – Oren Eini
Information* Getting rid of warnings with nullable reference types and JSON object models in C# – Maarten Balliauw * Accessing Service Bus message metadata in Azure Functions isolated model – Mark Heath * Unit Tests for Main and Other Methods in Top-Level Statements Console Applications – Bryan Hogan * Property based testing in C# – Part 1 – Bart Wullems * Dots – the friendly .NET SDK manager – Joachim Leonfellner * Examples of floating point problems – Julia Evans * Convert GUIDs to a Shorter Textual Representation and Back – Roland Weigelt * Working with time series data in SQL Server 2022 and Azure SQL – Kendal Van Dyke * Fixing a Memory Leak in a Production Node.js App – Kent C. Dodds * Running PowerShell Inside ChatGPT – Doug Finke * DigiMixer: Introduction to digital mixers – Jon Skeet
Information* Visual Studio 2022 version 17.4.4 – Visual Studio Team * What is Zero Trust and is it the Future of Cybersecurity? – Anthony Bartolo * Cryptography Implementations in .NET – Alvaro Montoya * Azure DevOps Server – Switch from HTTP to HTTPS–Part 4 – Bart Wullems * Why tuples in C# are not always a code smell – Dennis Frühauff * You should be reading academic computer science papers – Ryan Donovan * SQL Server Function Examples with JSON Files – Rick Dobson * Modular Test Design for Automated Test Strategy Success – Amy Reichert
Information* Debugging Encoded Text – Mark Downie * Unit Tests for Main and Other Methods in Top-Level Statements Console Applications – Bryan Hogan * 5 new advanced features improving C# 11 – Tom Deseyn * Migrating to Isolated Durable Functions – Mark Heath * More on .NET 7 user-jwts Tool – Shawn Wildermuth * Easy Pagination for Entity Framework in 3 steps – Steven Giesel * 9 Best Practices to Safely Deploy and Keep Your Application Healthy at Scale – Michael Shpilt * Writing Custom Hooks with React – Andrew Evans
Information* .NET January 2023 Updates – .NET 7.0.2, .NET 6.0.13 – Dominique Whittaker * Lazy and once-only C# async initialization – Ian Griffiths * The IO monad – Mark Seemann * Making an Asynchronous Breakfast in .NET – Assis Zang * Deserialize Mastodon User XML RSS feeds with .NET – Khalid Abuhakmeh * Software Engineering at Google ebook available for free – Bart Wullems * Wolverine meets EF Core and Sql Server – Jeremy D Miller * Executing async operations onchange in Blazor – Mike Brind * Extracting metadata from a minimal API handler – Behind the scenes of minimal APIs – Part 2 – Andrew Lock * Index Types in PostgreSQL: Learning PostgreSQL with Grant – Grant Fritchey * Reducing the size of Windows Server Container Images – Part 1 – Akarsh Mishra
Information* Five shortcuts to boost your productivity – Mads Kristensen * Detecting breaking changes between two versions of a NuGet package at packaging time – Gérald Barré * When Your DbContext Has The Wrong Scope – Phil Haack * Entity Framework – Select Multiple Tables – Paul Michaels * Squashing EF Core Migrations Safely – Mitchel Sellers * Armchair Architects: Architects vs. The Ivory Tower – Eric Charran * No, No, No – Tasks are not threads and they are not for performance! – Steven Giesel * MassTransit – Using RabbitMQ Virtual Hosts – Bart Wullems * Advanced Unit Testing in React with Jest: Hooks and Promises – Emmanuel Byrd * C# Advent 2022 Awards – Matthew D. Groves * Upcoming Developer & Technical Events in the UK – Updated for 2023 – Adam Jackson
Information* Azure Functions 2022 recap and 2023 sneak peek – Anirudh Garg * Bye bye Azure Functions, Hello Azure Container Apps: Conclusions – Jonathan George * Protect and call an ASP.NET Core minimal Web API with Azure AD – Mark Heath * Mocking dependencies in ASP.NET Core tests – Cezary Pi?tek * SQLitePCLRaw and open source sustainability – Eric Sink * You should write React in F# – Bjørn-Ivar Strøm * The Road to Out-of-Process ReSharper: Asynchronous Typing – Sasha Ivanova * A developer’s guide to Zero Trust Networking – Mandy Hubbard * Azure DevOps Server – Switch from HTTP to HTTPS–Part 3 – Bart Wullems * Debugging Architects – Gregor Hohpe * Weekly Update 329 – Troy Hunt
Information* Build Containers Without a Dockerfile – Rockford Lhotka * Avoiding Primitive Obsession in .NET – Assis Zang * Automating Integration Tests using the “Critter Stack” – Jeremy D Miller * Machine Learning in .NET with F# and ML.NET 2.0 – Matt Eland * OpenTelemetry in .NET – Basic Usage With Examples – Phil Broderick * Answer: what does this code print? – Oren Eini * Introducing the MySQL common table expression – Robert Sheldon * Fix that damn Git Unsafe Repository – Rick Strahl * Azure Pipelines – Node.js 16 and custom pipelines task extensions – John Reilly * Bean Machine Retrospective, part 6 – Eric Lippert
Information* Challenge: what does this code print? – Oren Eini * ConcurrentBag in C# – Code Maze * Method-Core Injection: a C# Pattern for Reducing Boilerplate Code – Ann Lewkowicz * Architectural Decision Records for Intuitive Decision Makers – Alexander Bird * How to Determine a JavaScript Promise’s Status – David Walsh * Understanding useState in React – Andrew Evans * AI and Machine Learning for Coders – Jaime González García * Continuous Testing Options for Agile and Non-Agile Teams – Amy Reichert * NDC Oslo 2022 – YouTube – NDC Oslo Session Recodings
Information* C# 11 List Patterns – Create compatible types – Gérald Barré * Adding NuGet packages when offline – Mark Seemann * A first look behind the scenes of minimal API endpoints – Behind the scenes of minimal APIs – Part 1 – Andrew Lock * Testing ASP.NET Core FastEndpoints – Khalid Abuhakmeh * Wolverine delivers the instrumentation you want and need – Jeremy D Miller * Understanding Task and ValueTask in C# – Code Maze * You Want Modules, Not Microservices – Dissecting why everybody keeps talking about microservices. – Ted Neward
Information* How the heap verification mode helps with debugging heap corruption – Maoni Stephens
* ReadOnlySpan
This will be the last edition of The Morning Brew this year – As is traditional I will be taking a break from publication over the Christmas holidays. The Morning Brew will return on Tuesday 3rd January. Enjoy the end of the year however you celebrate it, and best wishes for 2023.
- 20 Years of NAudio – Mark Heath
- Saving Christmas with Functional C# – Part One – Definite Loops – Simon Painter
- Use the power of Source Generators with Lombok.NET – Bart Wullems
- How to build a real-time leaderboard for the Soccer World Cup with Azure SQL & Redis | Data Exposed – Marisa Mathews
- Accelerate ML.NET training with Intel oneDAL – Luis Quintanilla
- Azure Static Web Apps: dynamic redirects with Azure Functions – John Reilly
- Next.js API Routes—What You Need To Know – Ifeoma Imoh
- .NET Rocks – Episode #1825 – Energy Geek Out 2022 – Another of my must listen Podcasts – Carl and Richard have a great back catalog of .NET podcast content, with occasional trips off into other topics. This episode is a very interesting look at modern ways of generating power – well worth a listen
Information* Write markdown without leaving Visual Studio – Dante Gagne * Wolverine and “Clone n’ Go!” Developement – Jeremy D Miller * Experimenting With .NET & WebAssembly – Running .NET Based Spin Application On WASI Node Pool in AKS – Tomasz P?czek * Do you need a Distributed Transaction? Maybe not! – Derek Comartin * The problem with XAML & I want to be wrong about XAML! – Matt Lacey * 7 Tips for Building a Good Web API – Assis Zang * Introduction to the Node.js reference architecture, part 11: Typical development workflows – Michael Dawson
Information* Adding new files just got a lot faster – Josh Stevens * Extreme LINQ Performance Boost in .NET 7 – Ivan Matec * Introduction to MVVM Source Generators for C# .NET – Julian Ewers-Peters * Ephemeral Messages with Wolverine – Jeremy D Miller * ASP.NET Core Display Description Tag Helper – Khalid Abuhakmeh * Implementing Maps in .NET MAUI – Leomaris Reyes * Delete dotnet bin and obj folders recursively – Steve Smith * The Traveling Salesman Problem Using an Evolutionary Algorithm with C# – Dr. James McCaffrey * Beanstalk Retrospective, part 5 – Eric Lippert * Gatekeeper’s Achilles heel: Unearthing a macOS vulnerability – Jonathan Bar Or * Blazor Best Practices Borrowed From ReactJS – Webinar Recording – Khalid Abuhakmeh
Information* Error-accumulating composable assertions in C# – Mark Seemann * Ref-structs are technically obsolete – James Turner * Strengthening Security Posture of Containerized .NET Applications With Chiseled Ubuntu Containers – Kristina Devochko * Build Your Own Podcast App with .NET 7, Blazor, and .NET MAUI – James Montemagno * Deploying EOL .NET Core to Azure App Services – Dominique St-Amand * Generating a dump file when tests hang on a CI machine – Gérald Barré * How to Secure Passwords with BCrypt.NET – Code Maze * Generating C# bindings for native libraries by using ChatGPT – Muhammad Azeez
Community* Coding Blocks – 200th Episode Extravaganza! – Allen Underwood, Joe Zack & Michael Outlaw – Coding Blocks is one of my ‘must listen’ podcasts, enjoyable and in depth – congratulations on the milestone episode.
Information* Microsoft .NET History – Lazie Wouters * F# event sourcing with Marten – Jannik Buschke * Blazor Implementations Across Web & Native – Sam Basu * Why You Should Add Mutation Testing to Your Workflow – Michael McNeil * Getting Started With JavaScript Promises – Nwose Lotanna Victor * Roundup Advent Of Code 2022 – Daniel B. Markham * New: AWS CLI v2 Docker images available on Amazon ECR Public – Steve Yoo * Why doesn’t Windows use the 64-bit virtual address space below 0x00000000`7ffe0000? – Raymond Chen
Information* Sticky Scroll now in preview – Leah Tran
* Transactional Outbox/Inbox with Wolverine and why you care – Jeremy D Miller
* Task
Information* Dev tunnels in Visual Studio for ASP.NET Core projects – Sayed Ibrahim Hashimi * Building Minesweeper – Showing Why Logic Should Not Be in the UI – Brendan Enrick * Handling HTTP Requests with .NET 7 Native AOT on AWS Lambda – Bryan Hogan * Applying the CQRS Pattern in an ASP.NET Core Application – Assis Zang * Challenge: What does this code print? – Oren Eini * I want toast – Eric Lippert * ECMAScript proposal: Set methods – Dr. Axel Rauschmayer
Information* Try out Visual Studio 2022 version 17.5 Preview 2 – Anthony Cangialosi * .NET Framework December 2022 Security and Quality Rollup Updates – Salini Agarwal * .NET December 2022 Updates – .NET 7.0.1, .NET 6.0.12, .NET Core 3.1.32 – Dominique Whittaker * Why Did That Database Throw That Exception? – Phil Haack * Entity Framework Core Conversions for Logical Domain Types – Khalid Abuhakmeh * MAUI Sounds Amazing. Is It? – Lee Richardson * How Wolverine allows for easier testing – Jeremy D Miller * C# 11: pattern matching and static abstract interfaces – Tom Deseyn * C# 11 – File Scoped Types – Bart Wullems * Nullable Types in C# – Code Maze * How Many Threads Does My .NET App Have? & Consuming .NET WebAssembly From JavaScript in the Browser – Khalid Abuhakmeh * Baby Steps With TypeScript – Ifeoma Imoh
Information* Polyglot Notebooks – December 2022 Release – Claudia Regio * Introducing Wolverine for Effective Server Side .NET Development – Jeremy D Miller * When do tests fail? – Mark Seemann * Text Classification in C# with ML.NET 2.0 – Matt Eland * The Equinox Programming Model – Einar Norðfjörð * Simulating the Wrapinator 5000 – Mathias Brandewinder * Sands of MAUI: Issue #84 – Sam Basu * Introduction to MongoDB: Zero To Document Hero – Webinar Recording – Khalid Abuhakmeh
Information* YARP – Direct forwarding in .NET 6 and beyond – Bart Wullems * Wolverine on DotNetRocks – Jeremy D Miller * Blazor Code Generation – A Step by Step Guide – Zdravko Kolev * ECMAScript proposal: iterator helpers – Dr. Axel Rauschmayer * War Story: How Antivirus solutions can bring a server down – Alois Kraus * Bean Machine Retrospective, part 4 – Eric Lippert
Information* .NET 7 Networking Improvements – Natalia Kondratyeva & Má?a * Migrating from ASP.NET to ASP.NET Core with Project Migrations Part 5 – Sayed Ibrahim Hashimi & Mike Rousos * Changes in JWT Bearer Token Setup in .NET 7 – Shawn Wildermuth * Testing a token protected API using user-jwts – Bart Wullems * Visual Studio Code – November 2022 (version 1.74) – Visual Studio Team and Contributors * Remote Development Even Better – Brigit Murtaugh * Design Patterns: Who gives a ????? – Derek Comartin * Go for C# developers: LINQ – Cellfish * A Journey into Site Reliability Engineering – Clarissa Lima Borges
Information* Is the regression in GC or something else? – Maoni Stephens * C# 11 – Generic Attributes – Bat Wullems * Setting Windows Display Resolution from the Terminal – Rick Strahl * My Christmas Wish List from Visual Studio and the C# Build System – Michael Shpilt * Bean Machine Retrospective, part 3 – Eric Lippert * Rider 2022.3: Support for .NET 7 SDK, the Latest From C#11, Major Performance Improvements, and More! & ReSharper 2022.3 Released With More C# 11 Features, NuGet Vulnerabilities Detection, and Support for Visual Studio ARM64. – Sasha Ivanova * New npm features for secure publishing and safe consumption – Monish Mohan
Information* What’s new in Visual Studio productivity – Dante Gagne * Get your developer news – Mads Kristensen * Building Windows Services in .NET 7 – Kevin W. Griffin * 5 new MVC features in .NET 7 – Andrew Lock * Implement Feature Management in Blazor ASP.NET Core – Damien Bowden * Announcing PowerShell Crescendo 1.1.0-preview01 – Jason Helmick * Recap: .NET MAUI Performance—.NET Conf 2022 – Leomaris Reyes * Logging and global error handling in .NET 7 WPF applications – Thomas Ardal * Time Zones and Rocket Ships – Joël Quenneville * Solving support issues in other people’s products – Oren Eini * TLS Certificate Verification Changes in Edge – Eric Lawrence
Information* Custom Controls for WinForm’s Out-Of-Process Designer – Klaus Loeffelmann * GitHub Copilot preliminary experience report – Mark Seemann * Convert a project to use centralised package management – Bart Wullems * Prevent http requests to external services in unit tests – Gérald Barré * Introducing C#11: Newlines in string interpolation expressions, Introducing C#11: Pattern match Span and ReadonlySpan on a constant string, Introducing C#11: Extended nameof parameter scope, Introducing C#11: File local types, Introducing C#11: UTF-8 String Literals & Introducing C# 11: Numeric IntPtr and UIntPtr – Anthony Giretti * How to Recover from a DbUpdateException With EF Core – Phil Haak * Your flaky tests might be time dependent – Steve Polito * Building emergency pathways in your software (never to be used) – Oren Eini * Bean Machine Retrospective, part 2 – Eric Lippert
Information* How to make the fastest .NET Serializer with .NET 7 / C# 11, case of MemoryPack – Yoshifumi Kawai * Introducing C#11: Required properties – Anthony Giretti * Polly with .NET 6, Part 7 – Policy Wraps with Minimal APIs, and HttpClientFactory – Bryan Hogan * Our journey to F#: C#-F# Interop – Urs Enzler * Domain-Driven Microservices with F# – Ben Copeland * Refactoring Bloated Controllers with [FromService] – David Starr * Subqueries in MySQL – Robert Sheldon * Bean Machine Retrospective, part 1 – Eric Lippert * Deep linking with Azure Static Web Apps and Easy Auth – John Reilly * Managing CSS Scope With Razor Components – Ed Charbeneau * How the Web Storage API Works – Leonardo Maldonado
Update: The eagle eyed of you may have noticed that today’s edition suffered an out by 1 error in the post number! Thanks to Ruud for letting me know in the comments, and the title is now corrected I’m expecting a few quiet days here with our US colleagues taking some time off for Thanksgiving […]
Information What’s new with Codespaces from GitHub Universe 2022 – Nik Molnar Lucene + Blazor, Part 3: Auto Complete – Thomas Beck Background Tasks in .NET – Isaac Abraham Making VS Code and OmniSharp Open the Browser to a Specific URL for a .NET Application – Bryan Hogan Godot: Script with F# – Hamilton Immutability: […]
Information Announcing ML.NET 2.0 – Luis Quintanilla Introducing Visual Studio Rollback! – Sayyeda Mussa .NET Conf 2022 – YouTube – .NET Team What’s New in .NET 7 for Authentication and Authorization – Andrea Chiarelli Twelve C# 11 Features – Oleg Kyrylchuk Automatically rotate the password of a service principal – Patrick van Kleef
Information .NET 7 Performance Improvements in .NET MAUI – Jonathan Peppers Visual Studio Code – October 2022 (version 1.73) – Visual Studio Code Team an contributors .NET Interactive Notebooks is now Polyglot Notebooks! – Claudia Regio Marking API’s as obsolete or as experimental – Steven Giesel Making changes safely at scale – Thom Carter JavaScript […]
Information Announcing TypeScript 4.9 RC – Daniel Rosenwasser From Figma to Visual Studio – Adding Back-End Logic to Goodreads App – Paula Aliu Just store UTC? Not so fast! Handling Time zones is complicated. – Derek Comartin The Modern Observability Problem – Ben Hall Create your .NET portfolio in the .NET Conf student zone – […]
Information Performance improvements in ASP.NET Core 7 – Brennan Conroy The type system is a programmer’s best friend – Dustin Moris Gorski More Efficient Deletes With Entity Framework Core – Khalid Abuhakmeh Learn how to improve your ASP.NET Core controllers with these principles – Dennis Frühauff Winter is Coming – Keep your Azure services up […]
Information Slaying Zombie ‘No Repro’ Crashes with Infer# – Matthew Jin A regular grid emerges – Mark Seemann New Videos: Coding Short and a Rant – Shawn Wildermuth Using a Distributed Memory Cache with .NET Lambda Functions – Bryan Hogan Use a recursive Blazor component to render a TreeView – Jon Hilton Cool features in […]
Information Using WASM and WASI to run .NET 7 on a Raspberry PI Zero 2 W – Laurent Kempé Creating Good Monoliths in ASP.NET Core – Assis Zang Lucene + Blazor, Part 1: Basic Search – Thomas Beck Reminder: JSON.stringify can create Multi-line, formatted and filtered strings from JSON – Christian Heilmann A developer’s guide […]
Information Learning Series: Get started with GitHub in Visual Studio – Jessie Houghton C# 11 File Scoped Types – Patrick Smacchia STOP Over-Engineering Software! – Derek Comartin Thoughtworks Technology Radar – Volume 27 – Thoughtworks We Should All Be API Consumers – Kin Lane Uno Platform Roadmap 2023 Survey – Jerome Laban Big Changes are […]
Information Generic types are for arguments, specific types are for return values – Vladimir Khorikov PolySharp – Sergio Pedri C# as a System Language recording – Oren Eini Continuous Integration via GitHub Actions – Chad Voelker Web Component Experiment – Manipulating Inner Text, Building a Placeholder Web Component with No External Dependencies, Working with Custom […]
Information Authentication for .NET MAUI Apps with MSAL.NET – Sameer Khandekar What is Software Architecture? – Derek Comartin Using MediatR with .NET Lambda Functions and Function URLs – Bryan Hogan OpenSilver gains more features and improved performance – Ian Barker How to make your APIs more discoverable – Vamsi Ravula & Hugo Guerrero JavaScript unit […]
Information Real Life TDD Example – Jeremy D Miller The 10 Immutable Laws of Testing – Peter Vogel Visual Studio’s Azure Marketplace images now support Microsoft Dev Box – Ruben Rios Simple Dependency Injection for .NET Lambda Functions – Bryan Hogan Using .NET 7’s Blazor Custom Elements to render dynamic content – Jon Hilton The […]
Information Announcing the .NET MAUI Community Toolkit v1.3 – Kym Phillpotts Rate limiting in web applications – Concepts and approaches – Maarten Balliauw Adding validation to strongly typed configuration objects in .NET 6 – Andrew Lock .NET Build Improvement: Stop Wasting Resources – Patrick Smacchia Bending .NET – Compiling 65,536 Programs with Roslyn to Find […]
Information Architecture: Software as a Service Databases – Single DB or DB per Client – Greg Low x86 vs x64 in .NET – Steven Giesel Write barrier optimizations in regions – Maoni Stephens Implement the On Behalf Of flow between an Azure AD protected API and an API protected using OpenIddict – Damien Bowden Ensuring […]
Information Ten Years of TypeScript – Daniel Rosenwasser Functional Programming in TypeScript – Leonardo Maldonado NuGet Season of Giving – Jon Douglas, Nikolche Kolev & Camila Thompson Generate Strongly-Typed Resources with .NET Core – Travis Illig Modern C# Techniques, Part 1: Curiously Recurring Generic Pattern – Stephen Cleary Pitfalls with eager loading of collections in […]
Information Experimental WebTransport over HTTP/3 support in Kestrel – Chris Ross Migrating from ASP.NET to ASP.NET Core (Part 4) – Sayed Ibrahim Hashimi & Taylor Southwick By Reference in C# – Peter Ritchie Securing Web APIs with Azure AD: Connecting Azure Clients – Jimmy Bogard .NET: Learn LINQ as you never have before – Anthony […]
Information Microsoft Teams’ Infrastructure and Azure Communication Services’ Journey to .NET 6 – Siavash Fathi, Arman Raina & Bhaskar Bhattacharya Fall 2022 Updates for Xamarin, Hello iOS 16 and Android 13 – David Ortinau LINQ Usage Survey – Aaron Robinson Continuous Integration with GitHub Actions – Liam Mooney Introducing C#11: Auto Default structs – Anthony […]
Information Visual Studio for Mac 17.4 Preview 2.1 is now available – Iain Holmes Securing Web APIs with Azure AD: Connecting External Clients – Jimmy Bogard Built-in rate limiting in ASP.NET Core vs AspNetCoreRateLimit – Thomas Ardal A Swiss Army Knife for Developers: DevToys – Roland Weigelt Does “foreach” in C# call “Dispose” on an […]
Information Use .NET from any JavaScript app in .NET 7 – Pavel Šavara Announcing general availability for Azure Functions v4 .NET framework support in an isolated process – Melony Qin Microsoft Commerce’s .NET 6 Migration Journey – Kurtis Story ASP.NET Core rate limiting middleware in .NET 7 – Maarten Balliauw The Comprehensive Guide To Feature […]
Information Announcing TypeScript 4.9 Beta – Daniel Rosenwasser The ThreadPool in .NET 7 NativeAOT uses the Windows thread pool – Austin Wise Mitigating the Noisy Neighbour Multitenancy Problem – Mark Heath Dockerize your SQL Server and use it in ASP.NET Core with Entity Framework Core – Bryan Hogan How to take an ASP.NET Core web […]
Short edition today as my feed reader was rather empty following the public holiday in the US Information A walkthrough of Durable Entities – David Justo Azure Container Apps with Dapr Bindings Building Block – Part 7 – Taiseer Joudeh Adding color to bracket pairs – Mads Kristensen Implement a GRPC API with OpenIddict and […]
Software Visual Studio Code – August 2022 (version 1.71) – Visual Studio Code Team and contributors Information Beware of records, with expressions and calculated properties – João Antunes 10 Tiny Things in C#/.NET I Wish Were Different – nietras How to Change an Azure Function Written in .NET from In-Process to Isolated Process – Nick […]
Information Data Access Layer makes it easier to change your Database? – Derek Comartin Looping iOS Remote Simulator Connection Issue with .NET MAUI – Gerald Versluis Incrementally Migrating an ASP.NET Framework application to Razor Pages – Mike Brind Azure Container Apps Async Communication with Dapr Pub/Sub API – Part 6 – Taiseer Joudeh My advice […]
Information Performance Improvements in .NET 7 – Stephen Toub Broken Access Control in ASP.NET Core – OWASP Top 10 – Sanjay Use Refresh Tokens in ASP.NET Core Apps – Andrea Chiarelli Learning To Use Menu Bar in .NET MAUI – Leomaris Reyes Rainbow Colorized Brackets in Visual Studio – Steve Smith How to Test a […]
Information No more Dockerfiles with the help of .NET CLI – Christian Nagel Refactor code to use new C# language features – Rachel Appel Getting Started With Mapster in ASP.NET Core – Marko Hrn?i? Turning Methods Into Benchmarks – Assis Zang Troubleshooting .NET Blazor WASM Debugging – Khalid Abuhakmeh Lambda function A/B Testing with .NET […]