DEV Community: Pramesh Kc.

The Ultimate Guide to .NET Performance Testing with BenchmarkDotNet

Pramesh Kc. — Sat, 30 Nov 2024 09:39:57 +0000

Introduction

Have you ever wondered if your code could run faster? Or maybe you're choosing between different ways to write something and aren't sure which is better? That's where benchmarking comes in! It's like a stopwatch for your code that helps you make smart decisions about how to write your programs.

Why BenchmarkDotNet?

BenchmarkDotNet stands out for several reasons:

Statistical analysis to ensure reliable results
Cross-platform support (.NET Core, .NET Framework, Mono)
Hardware intrinsics reporting
Easy-to-read reports in various formats (JSON, HTML, CSV)
Memory allocation and garbage collection statistics

Your First Steps into Benchmarking

Step 1: Setting Up Your Project

First, create a new console application:

dotnet new console -n MyFirstBenchmark
cd MyFirstBenchmark

Now, add the BenchmarkDotNet package:

dotnet add package BenchmarkDotNet

Step 2: Your First Benchmark

Let's create a simple benchmark that compares different ways to join strings - something every developer does! Here's a beginner-friendly example:

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

public class StringBenchmarks
{
    // This is our test data
    private string firstName = "John";
    private string lastName = "Smith";

    [Benchmark]
    public string UsingPlusOperator()
    {
        return "Hello, " + firstName + " " + lastName + "!";
    }

    [Benchmark]
    public string UsingStringInterpolation()
    {
        return $"Hello, {firstName} {lastName}!";
    }

    // This is where we run our benchmarks
    public static void Main(string[] args)
    {
        BenchmarkRunner.Run<StringBenchmarks>();
    }
}

Step 3: Running Your Benchmark

Open your terminal
Navigate to your project folder
Run this command:

dotnet run -c Release

The -c Release part is important! Always run benchmarks in Release mode for accurate results.

Understanding Your Results

When your benchmark finishes, you'll see a table like this:

|               Method |     Mean |    Error |
|-------------------- |---------:|---------:|
|UsingPlusOperator    | 45.23 ns | 0.85 ns  |
|UsingInterpolation   | 43.12 ns | 0.81 ns  |

Let's break down what these numbers mean:

Mean: The average time it took to run (in nanoseconds here)
Error: How much the results might vary
ns means nanoseconds (that's really, really fast!)

Memory Diagnostics

To measure memory allocations:

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
public class StringBenchmarks
{
    private const string name = "John";

    [Benchmark(Baseline = true)]
    public string UsingPlus()
    {
        return "Hello, " + name + "!";
    }

    [Benchmark]
    public string UsingInterpolation()
    {
        return $"Hello, {name}!";
    }

    public static void Main(string[] args)
    {
        BenchmarkRunner.Run<StringBenchmarks>();
    }
}

Understanding Results

Your output will look like this:

|            Method |     Mean |    Error |   StdDev |  Allocated |
|------------------|----------|----------|-----------|------------|
|        UsingPlus | 12.23 ns | 0.123 ns | 0.115 ns |      24 B |
| UsingInterpolation| 11.45 ns | 0.118 ns | 0.110 ns |      24 B |

Key metrics explained:

Mean: Average time per operation
Error: Statistical error margin
StdDev: How much results vary
Allocated: Memory used

Collection Performance

Compare different collection types:

[MemoryDiagnoser]
public class CollectionBenchmarks
{
    [Params(100, 10000)]
    public int Size { get; set; }

    [Benchmark]
    public void List()
    {
        var list = new List<int>(Size);
        for (int i = 0; i < Size; i++)
            list.Add(i);
    }

    [Benchmark]
    public void Array()
    {
        var array = new int[Size];
        for (int i = 0; i < Size; i++)
            array[i] = i;
    }
}

Async Operations

Benchmarking async code requires special attention:

public class AsyncBenchmarks
{
    private HttpClient client = new();

    [Benchmark]
    public async Task<string> AsyncDownload()
    {
        return await client.GetStringAsync("http://example.com");
    }

    [Benchmark]
    public async Task<string> AsyncDownloadWithTimeout()
    {
        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
        return await client.GetStringAsync("http://example.com", cts.Token);
    }
}

Common Mistakes to Avoid

❌ Don't run benchmarks in Debug mode
❌ Don't benchmark with tiny amounts of work
❌ Don't ignore the warm-up phase

Tips for Success

✅ Always use Release mode
✅ Test with realistic data
✅ Run benchmarks multiple times
✅ Keep your test cases simple at first

Next Steps

Once you're comfortable with these basics, you can try:

Testing different sizes of data
Comparing different .NET versions
Measuring memory usage
Benchmarking your own code

Remember:

Start with simple comparisons
Always run in Release mode
Use realistic data
Take your time understanding the results

You don't need to be an expert to start benchmarking! Begin with these simple examples, and as you get more comfortable, you can explore more advanced features.

Happy coding! 🎉

What’s New in .NET 9: A Simple Guide for Developers

Pramesh Kc. — Tue, 26 Nov 2024 10:14:05 +0000

Introduction

.NET 9 has arrived with a focus on cloud-native applications, performance improvements, and developer productivity. This release is packed with updates for runtime, libraries, tools, and frameworks like ASP.NET Core, .NET MAUI, and Entity Framework Core. Let’s dive into the features in simple language to help you get started.

Core Platform Updates

Runtime Improvements

New Feature Switch System

The .NET 9 runtime introduces a sophisticated attribute model for feature switches with enhanced trimming support. This system allows libraries to:

Define toggleable functionality areas
Maintain better control over feature availability
Optimize application size through improved trimming

Advanced Garbage Collection

The new garbage collection system brings significant improvements:

Dynamic adaptation to application size (enabled by default)
Replaces traditional Server GC
Optimizes memory management based on real-time usage patterns
Reduces memory footprint while maintaining performance

Performance Optimizations

Substantial performance improvements include:

Enhanced loop optimization algorithms
Smarter inlining capabilities
Improved Arm64 vectorization
Optimized code generation for modern hardware
Reduced memory overhead in common operations

Library Enhancements

System.Text.Json Updates

The JSON handling capabilities have been significantly expanded:

Full support for nullable reference type annotations
JSON schema export functionality from .NET types
Customizable JSON indentation options
Multi-root JSON value reading from single streams
Improved performance for large JSON documents
Better handling of complex object graphs

LINQ Enhancements

New LINQ methods provide more efficient data operations:

CountBy: Efficiently count elements by key without intermediate collections
AggregateBy: Perform aggregations by key without GroupBy overhead
Improved performance for existing LINQ operations
Better memory utilization in LINQ queries

Collection Improvements

Priority Queue enhancements:

New Remove method with comprehensive comparison options
Improved performance for common operations
Better memory efficiency for large queues

Cryptography Updates

New cryptographic capabilities:

One-shot hash method on CryptographicOperations
KMAC algorithm implementation
Enhanced security features
Improved performance for common cryptographic operations

Reflection Capabilities

The new PersistedAssemblyBuilder brings:

Ability to save emitted assemblies
Full PDB support for debugging
Symbol information generation
Enhanced debugging capabilities for generated code

Artificial Intelligence Integration

AI Building Blocks

Microsoft.Extensions.AI

New unified C# abstractions for AI services:

Seamless integration with language models
Embedding support
Vector store capabilities
Flexible middleware options

Tensor Operations

TensorPrimitives and Tensor improvements:

Nearly 200 optimized method overloads
SIMD-optimized operations
Generic support for numerical operations
Zero-copy interop with major AI libraries

ML.NET 4.0 Features

Core Improvements

Programmatic MLContext configuration
Stream-based ONNX model loading
Enhanced DataFrame capabilities
Advanced tokenization features

Experimental Features

TorchSharp ports of Llama models
Phi family model support
CausalLM pipeline APIs
Improved model training capabilities

Tokenizer Updates

The Microsoft.ML.Tokenizers library now supports:

Tiktoken for GPT models
Llama tokenization
CodeGen support
Phi2 tokenization
WordPiece and Bert implementations

Web Development

ASP.NET Core Updates

Security Enhancements

Secure-by-default configurations
Enhanced authentication APIs
Improved authorization capabilities
Better HTTPS development support on Linux

Performance Improvements

Optimized static file handling
Automatic asset versioning
Reduced memory usage
Faster startup times

Blazor Updates

New application templates
Improved component rendering
Enhanced reconnection handling
Better server-side performance

API Improvements

Built-in OpenAPI document generation
Enhanced native AOT support
Improved API versioning
Better performance for common API operations

Mobile and Desktop Development

.NET MAUI Enhancements

Performance Updates

Optimized CollectionView and CarouselView
Improved control lifecycle management
Better memory utilization
Enhanced startup performance

New Controls and Features

Windows TitleBar control
HybridWebView for web content
Enhanced keyboard support
Improved application lifecycle events

Platform-Specific Improvements

iOS and Mac Catalyst optimizations
Windows-specific enhancements
Better cross-platform consistency
Improved native feature access

Development Tools and SDK

SDK Improvements

Workload Management

Unified workload versioning
Better version control
Simplified updates
Enhanced compatibility

Testing and Security

Parallel test execution
Comprehensive security audits
Improved build logging
Version mismatch detection

Language Updates

C# 13 Features

params collections
New lock semantics
Escape sequence improvements= \e
Method group enhancements
ref locals and unsafe contexts in iterators and async methods
ref struct capabilities
field backed properties (preview)

F# 9 Enhancements

Nullable reference types
Discriminated union improvements
Enhanced active patterns
REPL improvements
Collection functions
C# collection expression support

Data Access and Entity Framework

Entity Framework Core Updates

Azure Cosmos DB Integration

Improved NoSQL support
Better performance
Enhanced query capabilities
Optimized data operations

Performance Improvements

Steps toward AOT compilation
Pre-compiled queries
Reduced memory usage
Faster query execution

.NET Aspire

Cloud-Native Application Development

Dashboard Improvements

Enhanced monitoring capabilities
Better resource management
Improved visualization
Real-time updates

Integration Features

New service integrations
Flexible APIs
Enhanced development experience
Better production readiness

Best Practices and Migration

Upgrading to .NET 9

Preparation Steps

Review existing codebase compatibility
Update dependencies
Test application functionality
Deploy updates systematically

Migration Considerations

Review breaking changes
Update deprecated features
Test performance impacts
Verify security implications

Conclusion

.NET 9 is packed with features that cater to developers building modern apps. Whether you’re working on cloud-native projects, AI solutions, or web apps, this release brings tools to make your job easier, faster, and more efficient.

Whether you're building web applications, mobile apps, or AI-powered solutions, .NET 9 offers compelling reasons to upgrade. The improved performance, enhanced security, and new features across all areas of the framework make it a worthy upgrade for existing projects and an excellent choice for new development efforts.

Getting Started

To begin working with .NET 9:

Download the latest SDK from Microsoft's website
Review the official documentation
Test your existing applications for compatibility
Start exploring the new features in a development environment

Straight Paths: Non-Tech Essentials

Pramesh Kc. — Thu, 01 Feb 2024 07:52:31 +0000

INTRODUCTION

Many individuals may be experiencing a sense of being stuck in a job that no longer excites them. Many people might have thought about working in the growing tech industry but thought it wasn't possible because they don't have a technical background.

We’re encircled by the wonders of modern technology. In a world driven by technology, the possibilities of transitioning from non-technical background to a career in the tech industry may seem like an overwhelming obstacle. However, many have successfully made this journey possible, breaking through barriers and embracing the opportunities that tech world offers.

OVERCOMING DOUBTS:

It's natural to be accompanied by doubts and uncertainties. Questions like "Can I really do this?" or "Is it too late to learn?" may cross your mind. Acknowledge these doubts, but also recognize that many successful tech professionals started from scratch, armed only with a determination to learn, and grow.

WHY TECH JOBS ARE AWESOME: WIN-WIN VIBES

Good Pay: Tech jobs usually pay well, which means more money for you.
Feel Good at Work: Solving tricky problems and working on cool projects can make your job super satisfying. Work Flexibility: Many tech jobs let you work from anywhere, helping you balance your life better.
Flexible Work Culture: Many tech jobs let you work from anywhere, helping you balance your life better.
Growth Opportunities: Tech companies give you lots of chances to learn and grow in your career. You can move up at your own speed.

YOU'RE NOT ALONE: BREAKING THE "NON-TECHNICAL" MYTH

If you consider yourself "non-technical," don't let that misconception limit your potential. The tech industry is inclusive, with abundant resources and opportunities awaiting diverse skill sets. The tech world is more than just code. There are various roles like project management, marketing, and sales that need different skills. The tech industry is open to everyone, offering plenty of chances for diverse talents. Don't limit your potential – there's a place for you in tech beyond coding.

UNDERSTANDING TECH WITHOUT CODING

Being "non-technical" doesn't mean you're clueless about tech – it just means you have different skills.

Knowing tech basics, keeping up with tech news, and being good at problem-solving are valuable skills.
In a world full of tech, having a basic understanding is like having a map. It's not about being a coding expert but knowing enough to work well with those who are. It's like speaking a common language to make sure everyone is on the same page. Whether you love coding or not, there's a place for you in the diverse tech world.

THERE’RE PLENTY OF OPPORTUNITIES FOR NON-TECHNICAL PERSON

Project Management:

Opportunity: As a project manager, you oversee the development and execution of tech projects.
Skills Needed: Strong organizational skills, communication, and the ability to understand technical requirements.

Customer Support and Success:

Opportunity: Providing excellent customer support and ensuring customer success.
Skills Needed: Communication, problem-solving, and empathy.

Quality Assurance (QA) Software Testing:

Opportunity: Ensuring the functionality and quality of software before release is critical.
Skills Needed: Attention to detail, problem-solving, and the ability to follow testing protocols.

Data Analysis:

Opportunity: Analysing data is essential for making informed business decisions.
Skills Needed: Analytical skills, attention to detail, and the ability to derive insights from data.

Technical Writing and Documentation:

Opportunity: Documenting processes, creating user guides, and writing technical documentation.
Skills Needed: Clear communication, writing skills, and the ability to explain complex concepts.

Social Media Marketing:

Opportunity: Social media is a powerful tool for tech companies to connect with their audience.
Skills Needed: Understanding of social media platforms, content creation, analytics, and strategic thinking.

SEO (Search Engine Optimization):

Opportunity: Tech companies rely on SEO to improve their online visibility and reach a wider audience.
Skills Needed: Knowledge of SEO strategies, keyword research, analytics, and staying updated on search engine algorithms.

The tech industry is a vast ecosystem that welcomes individuals with a variety of skills, not just technical expertise. Social media marketing, SEO, QA software testing, and other roles offer exciting opportunities for non-technical professionals to thrive. By leveraging their unique skills, individuals can contribute significantly to the success and innovation within the dynamic tech landscape. Don't let the "non-technical" label hold you back – there's a place for everyone in the tech industry.

FINAL WORD: YOUR ADVENTURE BEGINS NOW!

Jumping into the tech world might seem like a big deal, but it's so worth it. Face the challenges, celebrate your wins, and step into a world where amazing things can happen.

A Beginner's Guide to Starting a Career in Web Development

Pramesh Kc. — Thu, 25 Jan 2024 09:16:39 +0000

Welcome to the wonderful world of web development! Whether you're interested in a career change, want to improve your skills, or simply explore a new passion, this guide is designed with you in mind. I'll explain the fundamentals of web development in a simple and easy-to-understand manner, helping you embark on this fulfilling journey.

What is Web Development?

Web development is like building and maintaining houses, but in the online world. It involves a mix of creativity, problem-solving, and a pinch of magic to craft websites. There are two main areas:

Frontend Development

Think of frontend developers as the architects and interior designers. They make sure the website looks good and feels easy to use. They use languages like HTML (the structure), CSS (the style), and JavaScript (the interactivity) to create what you see on a webpage.

Backend Development

Backend developer is like a chef in a restaurant. Just as a chef prepares your food in the kitchen (which you can’t see), a backend developer works on the parts of a website or app that you can’t see. They write code that helps the website or app to function correctly.They use languages such as Python, C#, Ruby to handle data, user authentication, and overall functionality.

Getting Started

1.Explore Basic Concepts

a. HTML (Hypertext Markup Language)

Understand the structure of a webpage using HTML. It's like the skeleton of a website, defining headings, paragraphs, images, and links.

example:

<html>
<head>
    <title>My First Webpage</title>
</head>
<body>
    <h1>Welcome to My Webpage</h1>
    <p>This is a simple paragraph on my webpage.</p>
    <img src="image.jpg" alt="A beautiful image">
    <a href="https://www.example.com">Visit Example.com</a>
</body>
</html>

Explanation:

<html>: Think of it as the start of your document.
<head> Contains important info about your webpage.
<body>: Where your content goes - like text and images.
<h1>: The biggest heading.
<p>: A paragraph of text.
<img>: An image.
<a>: A link to another webpage.

b. CSS (Cascading Style Sheets)

Learn how to style your HTML elements with CSS. This includes choosing colors, setting fonts, and positioning elements to create an attractive layout.
example:

body {
    background-color: #f0f0f0;
    text-align: center;
    font-family: 'Arial', sans-serif;
}

h1 {
    color: #008080;
}

p {
    font-size: 18px;
}

Explanation:

body: Styles the whole webpage.
background-color: Changes the background color.
text-align: Centers the text.
font-family: Chooses the font style.
h1: Styles the main heading.
color: Picks the text color.
p: Styles the paragraph.
font-size: Sets the text size.

c. JavaScript

JavaScript is the wizard behind the curtain. It makes your website interactive – from simple animations to handling what happens when you click a button. It allows you to add functionality, create dynamic content, and respond to user actions.
example:

<html>
<head>
    <title>Interactive Webpage</title>
</head>
<body>
    <h1 id="demo">Click the Button!</h1>
    <button onclick="changeText()">Click Me</button>

    <script>
        function changeText() {
            document.getElementById('demo').innerHTML = 'Button Clicked!';
        }
    </script>
</body>
</html>

Explanation:

onclick="changeText()": A button that does something when clicked.
document.getElementById('demo').innerHTML: Finds the part of the webpage and changes its content.

2. Choose Your Development Environment, your playground

Set up a code editor like Visual Studio Code, notepad++, it's like a digital notebook for your code. Explore web browsers like Chrome or Firefox. Familiarize yourself with developer tools to inspect and debug your code.

3. Online Learning Platforms

Take advantage of online learning platforms like Codecademy, freeCodeCamp, Udacity. These platforms offer interactive courses that guide you through the basics of web development.

Building Your First Project

1.Start with Baby Steps, Start Small

Create a simple webpage with HTML and CSS. This could be your online resume, a personal blog, or a portfolio to showcase your work.

2. Add Interactivity

Enhance your webpage using JavaScript. Start with basic interactions like form validation or a responsive navigation menu.

Expanding Your Knowledge

1. Dive Deeper into Frontend or Backend

Based on your interests, explore more advanced topics in frontend or backend development. This could include frameworks like React or Angular for frontend, or C#,Python for backend.

Building Your Portfolio

Create a portfolio website to showcase the projects you've worked on. This will serve as a tangible representation of your skills for potential employers.

Overcoming Doubts and Embracing Learning

Embracing Mistakes:
Every expert was once a beginner. Don't worry about making mistakes—they help you learn. It's okay to start small and get better step by step.

Learning Made Fun:
Websites like Codecademy and freeCodeCamp turn learning into a game. Web development isn't boring; it's an exciting journey where you discover new things and have fun along the way.

Conclusion

Congratulations! You've taken the first steps into the exciting world of web development. Remember, it's okay to start small, make mistakes, and learn as you go. Your journey is uniquely yours, and every line of code is a step forward. So, embrace the adventure, build, create, and let your passion for web development propel you into a fulfilling and rewarding career. The digital world awaits your creativity!

By: @prameshkc

Handling Non-Standard JSON in .NET Using System.Text.Json

Pramesh Kc. — Thu, 04 Jan 2024 09:23:27 +0000

JSON (JavaScript Object Notation) is a widely used data format for exchanging information between applications and systems. While JSON has a well-defined specification, real-world JSON data sometimes includes non-standard additions such as comments, trailing commas, or encoded numbers.

The .NET library System.Text.Json offers efficient JSON serialization and deserialization. By default, it strictly adheres to the JSON specification. However, System.Text.Json also provides options to process non-standard JSON content.

In this article, we will explore how to configure System.Text.Json to handle JSON data that includes:

Comments
Trailing commas
Number Handling

Allowing Comments in JSON

Comments are not permitted in valid JSON. However, we may encounter JSON strings with comments for documentation purposes:

JSON:
{
  "name": "PrameshKc", // name of the user
  "age": 30
}

If we try to deserialize the above JSON, we will get the following exception:
System.Text.Json.JsonException: '/' is an invalid start of a property name. Expected a '"'. Path: $ | LineNumber: 0

To allow comments when deserializing, we need to set the JsonSerializerOptions.ReadCommentHandling property:

var options = new JsonSerializerOptions
{
  ReadCommentHandling = JsonCommentHandling.Skip
};


var data = JsonSerializer.Deserialize<User>(json, options);

This will skip over any comments in the JSON string during deserialization.

Ignoring Trailing Commas

Trailing commas are also invalid in JSON:

JSON:
{
  "name": "PrameshKc",
  "age": 30,
}

If we try to deserialize the above JSON, we will get the following exception:
System.Text.Json.JsonException: The JSON object contains a trailing comma at the end which is not supported in this mode.
To permit trailing commas, set JsonSerializerOptions.AllowTrailingCommas to true:

var options = new JsonSerializerOptions
{
  AllowTrailingCommas = true  
};

var data = JsonSerializer.Deserialize<Data>(json, options);

Now any trailing commas will be ignored when deserializing.

Customizing Number Handling

Sometimes JSON may encode numbers as strings:

json
{
  "temp": "37" 
}

If we try to deserialize the above JSON, we will get the following exception:

System.Text.Json.JsonException: 'The JSON value could not be converted to System.Int32. Path: $.DegreesCelsius | LineNumber: 2 | BytePositionInLine: 21.'

We can customize how numbers are handled using the JsonNumberHandling option:

var options = new JsonSerializerOptions
{
  NumberHandling = JsonNumberHandling.AllowReadingFromString
};

var data = JsonSerializer.Deserialize<Weather>(json, options);

This will permit deserializing string-encoded numbers to numeric properties.

Conclusion

The System.Text.Json API provides many options to handle non-standard JSON formatting like comments, trailing commas, and unquoted names. By configuring JsonSerializerOptions, we can customize how .NET handles invalid JSON data during serialization and deserialization.
Happy coding! 😊

@prameshkc

Handling Non-Standard JSON in .NET Using System.Text.Json

Pramesh Kc. — Thu, 04 Jan 2024 08:24:36 +0000

In this article, we will explore how to configure System.Text.Json to handle JSON data that includes:

Comments
Trailing commas
Number Handling

Allowing Comments in JSON

Comments are not permitted in valid JSON. However, we may encounter JSON strings with comments for documentation purposes:

JSON:
{
  "name": "PrameshKc", // name of the user
  "age": 30
}

If we try to deserialize the above JSON, we will get the following exception:
System.Text.Json.JsonException: '/' is an invalid start of a property name. Expected a '"'. Path: $ | LineNumber: 0

To allow comments when deserializing, we need to set the JsonSerializerOptions.ReadCommentHandling property:

var options = new JsonSerializerOptions
{
  ReadCommentHandling = JsonCommentHandling.Skip
};


var data = JsonSerializer.Deserialize<User>(json, options);

This will skip over any comments in the JSON string during deserialization.

Ignoring Trailing Commas

Trailing commas are also invalid in JSON:

JSON:
{
  "name": "PrameshKc",
  "age": 30,
}

var options = new JsonSerializerOptions
{
  AllowTrailingCommas = true  
};

var data = JsonSerializer.Deserialize<Data>(json, options);

Now any trailing commas will be ignored when deserializing.

Customizing Number Handling

Sometimes JSON may encode numbers as strings:

json
{
  "temp": "37" 
}

If we try to deserialize the above JSON, we will get the following exception:

System.Text.Json.JsonException: 'The JSON value could not be converted to System.Int32. Path: $.DegreesCelsius | LineNumber: 2 | BytePositionInLine: 21.'

We can customize how numbers are handled using the JsonNumberHandling option:

var options = new JsonSerializerOptions
{
  NumberHandling = JsonNumberHandling.AllowReadingFromString
};

var data = JsonSerializer.Deserialize<Weather>(json, options);

This will permit deserializing string-encoded numbers to numeric properties.

Conclusion

@prameshkc

Discovering the Gem in .NET 8: Introducing ".NET Aspire"

Pramesh Kc. — Mon, 18 Dec 2023 10:54:43 +0000

This year, Microsoft rolled out a game-changer in the .NET 8 lineup – ".NET Aspire." As a developer, this has quickly become my absolute favorite feature.

We'll delve into the essentials of ".NET Aspire" and walk through the installation steps to get it up and running on your development environment. From there, we'll fire up a new project, leveraging the power and flexibility that ".NET Aspire" brings to the table.

What is .net Aspire?
Imagine a toolkit designed specifically for crafting cloud-ready, distributed applications. That's exactly what .NET Aspire brings to the table. It's not just a set of tools; it's a cloud-native stack delivered through NuGet packages, addressing key concerns in modern application development.

The beauty of .NET Aspire lies in its compatibility with the microservices approach. If you're into building applications with smaller, interconnected components, this is your golden ticket. Cloud-native apps, leveraging .NET Aspire, seamlessly consume various services like databases, messaging, and caching.

**Before we dive into the world of ".NET Aspire," let's make sure you're all set. Here's your checklist:

.NET 8 Installed: It's like the superhero suit for your development adventures. Make sure you have .NET 8 ready to roll on your machine.

.NET Aspire Workload:
CLI to install .net aspire



dotnet workload update
// to make sure latest .net aspire installed



dotnet workload install aspire
//This brings all the magic to your development world.



dotnet workload list
//check current aspire version

IDE or Code Editor: Choose your weapon! While it's optional, having a good Integrated Developer Environment (IDE) or code editor enhances the experience. You can go with Visual Studio 2022 Preview version 17.9 or higher for the full superhero vibe. If you're more of a minimalist, Visual Studio Code works like a charm too.
Docker Desktop:
For that extra oomph in containerized magic, grab "Docker Desktop."

Launching Your First .NET Aspire Project: Easy-Peasy Steps!

Ready to dip your toes into the world of ".NET Aspire"? Let's create your very own project with these simple commands:

Basic .NET Aspire Project:
If you're starting fresh, use this magic line:



dotnet new aspire --name dotnet8Aspire

This sets up a basic ".NET Aspire" project for you – like a blank canvas waiting for your code masterpiece.

Fancy .NET Aspire Project (with UI and API):
Feeling a bit adventurous? Try this one:



dotnet new aspire-starter

This not only creates a ".NET Aspire" project but also throws in a sample UI and API.

I'm creating basic .net aspire project with out UI and API, I'll add project later.

With the simple command dotnet new aspire, you're getting a no-frills ".NET Aspire" app. What's inside? Just two main things:

AppHost: The Maestro of Your App
The AppHost is like the chief conductor of your app orchestra. It rounds up all your projects, builds them, and sets the stage for your application. Imagine it as the leader making sure everyone plays in harmony. As you add more projects, AppHost takes care of the coordination, handling dependencies, NuGet files, and resolving connections – making your life easier.

ServiceDefaults: The Powerhouse of Aspire
Meet ServiceDefaults the powerhouse of Aspire. It's like a pre-loaded magic box for your app. Telemetry, logging, metrics, analytics – it's all set up without you lifting a finger. Microsoft gives you a default set of tools, but hey, feel free to tweak, add, or remove as you please. It's your app, your rules! 🎉💻✨

Let's run the project

running on port http://localhost:18888

Dasboard for .net aspire simple project. Since we've added any project so it's saying no project found on project list.
Lets add simple API project on this aspire project.

I've created a simple asp.net core web api project with name dotnet8Aspire.API

Let's add API project to aspire. Since i've not install vs tools for visual studio through which we can enable aspire support for projects with Visual studio with just couple of click. So I'll manually add project to aspire.

API project reference is added on aspire project , now let's configure on appHost program.cs.

When we add reference of other projects on aspire , all the added projects will available inside namespace "projects"

On API project "dotnet8Aspire.API" add reference of ServiceDefaults project and register AddServiceDefault on program.cs.

Now Lets run the project again

as we can see there's our newly added project on dashbaord. We can run the projects from here, view logs, enviroment variables and so on.

API project is running on http://localhost:5244. By regsitering on AppHost (aspire) we don't have to manually run API project, all the things are taken care from appHost.

let's send request from API and see logs from dashboard http://localhost:5244

I've execute one endpoint of API , now let's see on dashboard if there's any logs available from this current request.

And there you have it – a simple sneak peek into the world of ".NET Aspire." This was just the tip of the iceberg, a basic intro to get your feet wet. I hope you found it helpful and maybe learned a thing or two.
There's so much more to explore in the realm of .NET Aspire. So buckle up, stay curious, and keep an eye out for the next tutorial where we'll dive even deeper into the wonders of .NET Aspire. Until then, happy coding, and may your apps aspire to greatness! 💻🚀🌟