Coding With David

  Note: this is an update from Yes, Blazor Can Scale , 4/1/2021 From the very beginning of Blazor Server's release, skeptics have claimed that it cannot scale effectively, often citing a limit of 5,000 concurrent users. This misconception stems from misunderstandings about Blazor Server's architecture and capabilities. With the advent of .NET 8, Blazor Server has introduced new render methods that significantly enhance its scalability and performance. In this post, we'll break down these myths and explore how the latest advancements in Blazor Server make it a robust solution for modern web applications. Understanding the "Limit" for Users When Microsoft discusses the need to scale an application, they imply that if a normal response for any concurrent user takes longer than 200 milliseconds, the system isn't performant and requires scaling. We'll adopt this definition: If any normal user response exceeds 200 ms, the system needs to scale for concurrent use

One of the powerful features of Blazor is the ability to create reusable components, making it easy to build dynamic, interactive web applications while minimizing redundant code. In this post, we’ll walk through how to create a flexible, generic accordion component that can be reused throughout your application, allowing you to pass custom labels and dynamic content for each accordion section. The Problem: Hardcoded Accordion Sections Imagine you have an accordion structure with multiple sections that expand and collapse, showing content for different components. If this structure is repeated in several parts of your application, you could end up with a lot of repeated, hard-coded accordion items like this: <article class="WideArticle Admin mb-2"> <div class="accordion mb-4" id="accordionExample"> <div class="accordion-item"> <h2 class="accordion-header"> <button class

  As developers, we strive to write clean, efficient, and maintainable code. However, even the best of us can fall into patterns that lead to "code smells"—symptoms of deeper problems in our codebase. Identifying and addressing these code smells is crucial for long-term project health. In this post, we'll explore the 10 most common code smells in C# and provide guidance on how to fix them. 1. Long Methods What It Is Methods that are excessively long and try to do too much. Why It's a Problem Maintenance Difficulty : Long methods are harder to read and understand. Testing Challenges : It's more difficult to write unit tests for methods that handle multiple responsibilities. Violates Single Responsibility Principle : Each method should have one responsibility. How to Fix It Refactoring : Break down the method into smaller, reusable methods. Use Descriptive Names : Ensure each new method has a name that clearly describes its purpose.      // Before      public void

Developing web applications has evolved significantly with the advent of Blazor, a framework that allows you to build interactive client-side web UIs with C# instead of JavaScript. Blazor brings the power of .NET to the browser, enabling developers to create rich and dynamic web applications using familiar tools and languages. Whether you're just starting out with Blazor or looking to refine your existing skills, the following tips and tricks will help you maximize the framework's capabilities. This comprehensive guide covers essential aspects of Blazor development—from optimizing performance and utilizing component libraries to mastering state management and debugging techniques. Dive in to discover how you can enhance your Blazor applications and streamline your development workflow. 1. Understand Blazor Hosting Models (WebAssembly vs. Server) Explanation : Blazor can run in two modes: Blazor WebAssembly (client-side) and Blazor Server (server-side). Each has its advantages a

  Teaching developers to transition from thinking "building applications is just about coding" to becoming well-rounded software engineers requires guiding them to see the bigger picture. Here's how you can approach this: 1. Highlight the Full Software Development Lifecycle (SDLC) Explain the SDLC : Walk them through the stages beyond just coding: requirements gathering, design, implementation, testing, deployment, maintenance, and continuous improvement. Assign non-coding tasks : Encourage them to participate in planning, architecture discussions, or even gathering requirements from stakeholders. This will give them a broader perspective on what makes a good application. 2. Emphasize Design and Architecture Teach design principles : Help them understand SOLID principles, design patterns, and system architecture concepts like microservices, event-driven systems, and scalability. Involve them in architecture discussi

Let’s face it: JavaScript and C# are like two exes that you just can’t quit. You need them both, but constantly bouncing between the two can leave you feeling a little...discombobulated. Enter Blazor , your ticket to full-stack development bliss—all in C# and .NET. No more switching personalities between the browser (JavaScript) and the server (C#). With Blazor, it’s all C#, all the time. So, why should you get excited? Let me count the ways. 1. C# for Full-Stack Development: The Dream Team Imagine being able to use your favorite language (yes, C#) to develop both the client and server side of your web app. No more learning JavaScript just to make a button do something fancy. Blazor lets you stay in your C# comfort zone , allowing you to share code between the client and server, reuse business logic, and bask in the glory of DRY (Don’t Repeat Yourself) principles. Who needs to switch languages mid-project when you can have a unified codebase? This means fewer mental context switches an