Forem: Arash zandi

C# win Tiobe Programming Language of the Year 2025🚀

Arash zandi — Wed, 07 Jan 2026 06:23:59 +0000

C# saw the largest increase in ranking in the index year over year, while Java held steady, C and C++ swapped positions, R and Perl rose, and Go and Ruby faded, Python slipped slightly year over year.

For the second time in three years, C# has been named Programming Language of the Year by the TIOBE Index. C# earned this distinction by achieving the largest year-over-year increase in ranking. Over the years, the language has undergone fundamental changes. From a language-design perspective, C# has often been an early adopter of new trends among mainstream languages. At the same time, it successfully made two major paradigm shifts: from Windows-only to cross-platform, and from Microsoft-owned to open source. C# has consistently evolved at the right moment.

More information : TIOBE Index - TIOBE

📱 Is Windows 11 ARM Coming to Phones ?

Arash zandi — Tue, 30 Sep 2025 06:38:15 +0000

Microsoft is indeed investing heavily in Windows 11 on ARM, but not for smartphones or small mobile devices—at least not yet. Here's the current landscape and what the UI evolution might suggest:

📱 Is Windows 11 ARM Coming to Phones?

- No official plans for smartphones: Microsoft has not announced any intention to bring Windows 11 ARM to mobile phones. The focus remains on laptops, tablets, and hybrid devices powered by ARM chips like Qualcomm's Snapdragon X Elite.
- Cellular-ready ARM PCs: Many ARM-based Windows devices support cellular connectivity, instant-on behavior, and long battery life—traits borrowed from mobile phones. But these are still full PCs, not pocket-sized devices.

🧩 Why the UI Is Becoming Touch-Friendly

You're absolutely right—Windows 11's UI is increasingly:
- Responsive: Adapts to screen sizes and orientations.
- Touch-optimized: Larger hit targets, gesture support, and fluid animations.
- Stylus-aware: Better inking and handwriting recognition.
This is not accidental. Microsoft is preparing Windows to run seamlessly across a spectrum of form factors, from foldables to tablets to dual-screen devices. Think Surface Pro, Surface Duo (Android), and future ARM laptops—not traditional smartphones.

🔮 What Could Happen Next?

While there's no direct plan for Windows 11 on phones, the groundwork is being laid for:
- More compact ARM devices: Possibly foldables or ultra-portables with full Windows.
- Copilot+ PCs: AI-powered ARM laptops with mobile-like responsiveness and battery life.
- Unified design language: Fluent UI and WinUI 3 make it easier to scale across device types—something you're already leveraging in your own WinUI3 work.

Conclusion

So yes, the UI evolution is a clue—but not toward phones. It's about bridging the gap between mobile and desktop experiences, especially in the ARM ecosystem. If Microsoft ever does re-enter the phone space with Windows, it’ll likely be through a dual-screen or foldable device, not a traditional smartphone.

.NET Run C# Single Files Without a Project — Almost Like Python

Arash zandi — Fri, 22 Aug 2025 13:20:14 +0000

Introduction

The .NET platform is Microsoft’s cross-platform, open-source runtime and SDK for building applications that run from tiny IoT devices to large cloud services. Its primary language, C#, compiles to efficient native code and offers modern features for productivity and safety. Historically, developers began with a project (.csproj) and solution structure; the .NET CLI (dotnet) then built and ran that project. Starting with C# 14 / .NET 10, you can also run a single C# source file directly—an approach called a file-based app—and in .NET 10 that experience received major upgrades.
This article introduces the file-based model, explains the .NET 10 enhancements (notably native AOT publishing), and walks through step-by-step examples you can try today.

I'll show you step by step :

1 . First download .Net SDK SDK 10.0.100-preview.4 or newer from this link :
Download .NET 10.0 and install it

2 . Create a folder in your machine and then create a Program.cs file inside the folder. (you can now create and run any .cs file and the name not matters)

3 . Write this code in Program.cs

Console.WriteLine("Hello, World!");

4 . then open the folder containing Program.cs file in the terminal , CMD or even VsCode Terminal and run this command

Dotnet run Program.cs

5 . Finish... This is your result :

Now let's have more details :

using nuget packages

Suppose that you want to use a nuget package in your app like Newtonsoft.Json and use it in your codes

add this line in top of your .cs file :

#:package Newtonsoft.Json@13.0.3

Or for using latest version

#:package Newtonsoft.Json@*

Then write the using :

using Newtonsoft.Json;

Now You can use the Newtonsoft.Json in your project and this is my sample :

#:package Newtonsoft.Json@13.0.3

using Newtonsoft.Json;

Console.WriteLine("Hello, World!");

var date = new
{
    date = DateTime.Now,
    message = "This is a test message"
};

string jsonString = JsonConvert.SerializeObject(date, Formatting.Indented);

Console.WriteLine(jsonString);

And the result is something like this :

PS C:\Users\ArashZandi\Desktop\C# file> dotnet run program.cs
Hello, World!
{
  "date": "2025-08-22T15:16:44.4952004+03:30",
  "message": "This is a test message"
}

Making an API with just a single file

1 . Make a file with your desired name (mine is Api.cs)
2 . Write this codes :

#:sdk Microsoft.Net.Sdk.Web

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/test", () => "Hello World!");
await app.RunAsync();

3 . Now run the project with the command Dotnet run Api.cs
4 . The result is

PS C:\Users\ArashZandi\Desktop\C# file> dotnet run api.cs
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5000
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Production
info: Microsoft.Hosting.Lifetime[0]
      Content root path: C:\Users\ArashZandi\Desktop\C# file

5 . You see that there is a website listening this address http://localhost:5000 Now in your browser go to this link
http://localhost:5000/test

6 . You should see the Hello World! comming from the API (read about Minimal Apis more in the references) as the result.

Tip : the key point of this type of .cs file is this line #:sdk Microsoft.Net.Sdk.Web which allow you to use WebApplication

Converting the .cs file to a .csproj based project

You can convert your .cs file to the other type which uses .csproj file like this :

dotnet project convert program.cs
dotnet project convert api.cs

Now I've converted my projects one by one in their own folders.

Referencing to your other projects in the .cs file

My Program.cs and Api.cs were in a same folder, I've converted them and I have this file/folder tree

Now I want to use my Program.csproj in the Api.cs (single file)
Actually I want to have a reference of Program.csproj (the converted proj) into Api.cs (the single file project)

1 . I delete converted Program.cs project and modify my program.cs file like this :

#:package Newtonsoft.Json@13.0.3

using Newtonsoft.Json;

Console.WriteLine("Hello, World!");

var date = new
{
    date = DateTime.Now,
    message = "This is a test message"
};

string jsonString = JsonConvert.SerializeObject(date, Formatting.Indented);

Console.WriteLine(jsonString);

public class ProgramTestClass
{
    public static string test() => "This is a test method.";
}

I convert it again to a .csproj project

dotnet project convert program.cs

Now in my Api.cs file I can use this line
#:project ./program/program.csproj

And my codes in Api.cs are these :

#:sdk Microsoft.Net.Sdk.Web
#:project ./program/program.csproj

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

var stringFromReferencedProj = ProgramTestClass.test();
app.MapGet("/test", () => stringFromReferencedProj);
await app.RunAsync();

The result of this link
http://localhost:5000/test
is :
This is a test method.

When to choose file-based apps (and when not)

File-based apps shine for small CLI tools, teaching, experiments, or build scripts—situations where you want to get from idea to running code with minimal ceremony. As complexity grows (multiple files, tests, multi-targeting, analyzers), migrate to a traditional project structure. The official tutorial and ecosystem write-ups emphasize this pragmatic split

Conclusion

.NET 10 turns file-based apps from a neat trick into a capable development mode. You can run C# files directly, pull in NuGet packages and other projects with declarative #: directives, publish native executables by default, and even host a minimal web API in a single file. The result is a lower-ceremony on-ramp to C# that still scales into project-based development when your program outgrows one file

References to read more :

.Net Aspire - Add Swagger, OpenApi, Scalar to the AppHost

Arash zandi — Mon, 03 Mar 2025 12:50:52 +0000

Before you begin, If you are not familar with OpenApi, Swagger or Scalar please read this article :
net-9-revolutionizing-documentation-of-apis-from-swashbuckle-to-scalar

You can have ApiDocs and also your custom links in your .Net Aspire Dashboard like this :

Simply install this nuget package Arshid.Aspire.ApiDocs.Extensions to your AppHost.csproj

dotnet add package Arshid.Aspire.ApiDocs.Extensions

Then add these lines for the project that has Swagger, Scalar or etc.

📦 Example

using Arshid.Aspire.ApiDocs.Extensions;

var apiService = builder.AddProject<Projects.AspireApp1_ApiService>("apiservice")
    .WithScalar()
    .WithSwagger()
    .WithOpenApi()
    .WithCustomUrl("https://127.0.0.1:5000/CustomRoute/CustomPage1")
    .WithRoute("/CustomRoute/CustomPage2"); //The URL become something like this {protocol}://{url}:{port}/CustomRoute/CustomPage2

Source Codes are available here in GitHub:
https://github.com/zandiarash/Arshid-Aspire-ApiDocs-Extensions

Nuget Package:
Arshid.Aspire.ApiDocs.Extensions

Blazor: A Comprehensive Introduction, Pros and Cons, and Comparison with Angular, React, and Vue

Arash zandi — Wed, 15 Jan 2025 09:29:56 +0000

Microsoft Blazor: Revolutionizing Web Development with .NET
Microsoft Blazor is a cutting-edge web framework that has been making waves in the web development community. As part of the .NET ecosystem, Blazor enables developers to build interactive and dynamic web applications using C# and .NET instead of relying on JavaScript. This innovative framework opens up new possibilities for .NET developers, allowing them to leverage their existing skills to create modern web applications.
In this article, we’ll dive into what Blazor is, how it works, its key features, and why it’s becoming a popular choice for web development.
Introduction to Blazor
Blazor is a modern web framework developed by Microsoft that allows developers to build interactive web applications using C# and .NET instead of JavaScript. Launched as part of the .NET ecosystem, Blazor enables developers to create rich, single-page applications (SPAs) that run directly in the browser via WebAssembly or on the server-side with SignalR for real-time communication.

Key Features of Blazor
1. C# and .NET Ecosystem
Blazor allows developers to use C# for both client-side and server-side code, eliminating the need to switch between JavaScript and C#. This is a game-changer for .NET developers who can now build full-stack web applications using a single language and framework.

2. Component-Based Architecture
Blazor uses a component-based architecture, similar to other modern frameworks like React and Angular. Developers can create reusable UI components, making it easier to build and maintain complex applications.

3. WebAssembly Support
Blazor WebAssembly enables high-performance client-side execution, bringing near-native speed to web applications. This makes it possible to run .NET code directly in the browser without plugins or additional software.

4. Real-Time Updates with SignalR
Blazor Server uses SignalR, a real-time communication library, to send UI updates to the client. This ensures that the application remains responsive and up-to-date without requiring a full page reload.

5. Integration with .NET Libraries
Blazor can leverage existing .NET libraries and tools, reducing the need for additional third-party dependencies. This allows developers to reuse code and libraries from their existing .NET projects.

6. Strong Tooling Support
Blazor benefits from Visual Studio’s robust tooling, including debugging, IntelliSense, and hot reload. This makes the development process smoother and more efficient.

Why Use Blazor?
1. Familiarity for .NET Developers
For developers already familiar with C# and the .NET ecosystem, Blazor provides a seamless transition to web development. There’s no need to learn JavaScript or TypeScript, which can save time and reduce the learning curve.

2. Full-Stack Development
Blazor enables full-stack development using a single language (C#) and framework (.NET). This simplifies the development process and allows for better code reuse between the client and server.

3. High Performance
With Blazor WebAssembly, applications can achieve near-native performance in the browser. This makes it suitable for building complex, data-intensive web applications.

4. Real-Time Capabilities
Blazor Server’s use of SignalR makes it ideal for applications that require real-time updates, such as dashboards, chat applications, and live data feeds.

5. Cross-Platform Compatibility
Blazor applications can run on any modern browser, including those on desktop and mobile devices. This ensures a consistent user experience across platforms.

Blazor comes in two hosting models:

Blazor WebAssembly: This model runs the application directly in the browser using WebAssembly, a binary instruction format that allows high-performance execution of code. With Blazor WebAssembly, the entire application, including the .NET runtime, is downloaded to the client's browser, enabling full client-side execution.
Blazor Server: In this model, the application runs on the server, and UI updates are sent to the client over a SignalR connection. This approach reduces the initial load time and is ideal for applications where client resources are limited.

Blazor leverages the power of Razor syntax, a combination of HTML and C#, to create dynamic and reusable UI components. This makes it an attractive option for .NET developers who want to build web applications without leaving the familiar .NET ecosystem.

Pros of Blazor

C# and .NET Ecosystem: Blazor allows developers to use C# for both client-side and server-side code, eliminating the need to switch between JavaScript and C#. This is a significant advantage for .NET developers who are already familiar with the language and tools.
Component-Based Architecture: Like other modern frameworks, Blazor uses a component-based architecture, making it easy to create reusable and modular UI components.
Full-Stack Development: With Blazor, developers can build full-stack applications using a single language (C#) and framework (.NET), streamlining the development process.
WebAssembly Support: Blazor WebAssembly enables high-performance client-side execution, bringing near-native speed to web applications.
Integration with .NET Libraries: Blazor can leverage existing .NET libraries and tools, reducing the need for additional third-party dependencies.
Real-Time Updates with SignalR: Blazor Server provides real-time UI updates using SignalR, making it ideal for applications that require live data.
Strong Tooling Support: Blazor benefits from Visual Studio's robust tooling, including debugging, IntelliSense, and hot reload.

Cons of Blazor

Learning Curve for Non-.NET Developers: Developers who are not familiar with C# or the .NET ecosystem may find it challenging to adopt Blazor.

Comparison with Angular, React, and Vue
Blazor competes with popular JavaScript frameworks like Angular, React, and Vue. Here's a detailed comparison:

1. Language and Ecosystem

Blazor: Uses C# and the .NET ecosystem, making it ideal for .NET developers.
Angular: Uses TypeScript and has a robust ecosystem backed by Google.
React: Uses JavaScript (or TypeScript) and has a massive ecosystem supported by Facebook.
Vue: Uses JavaScript (or TypeScript) and is known for its simplicity and flexibility.

2. Performance

Blazor WebAssembly: Offers near-native performance but has a larger initial load time.
Blazor Server: Provides fast initial load times.
Angular: Optimized for performance but can be heavy for small applications.
React: Known for its virtual DOM, which ensures efficient updates and rendering.
Vue: Lightweight and fast, with a smaller bundle size compared to Angular and React.

3. Learning Curve

Blazor: Easier for .NET developers but may be challenging for those unfamiliar with C#.
Angular: Steeper learning curve due to its comprehensive feature set and complexity.
React: Moderate learning curve, especially for developers new to JSX and functional programming.
Vue: Easiest to learn, with a simple and intuitive API.

4. Community and Ecosystem

Blazor: Growing community but smaller compared to Angular, React, and Vue.
Angular: Large community and extensive ecosystem backed by Google.
React: Largest community and ecosystem, with a vast number of third-party libraries.
Vue: Strong and rapidly growing community, with a focus on simplicity and flexibility.

5. Use Cases

Blazor: Ideal for .NET developers building SPAs or full-stack applications.
Angular: Suitable for large-scale enterprise applications with complex requirements.
React: Versatile and widely used for both small and large applications.
Vue: Perfect for small to medium-sized applications and rapid prototyping.

Conclusion
Blazor is a promising framework that brings the power of C# and .NET to web development. Its ability to run on both WebAssembly and the server-side makes it a versatile choice for developers. However, it still lags behind established frameworks like Angular, React, and Vue in terms of ecosystem size and community support.

For .NET developers, Blazor offers a seamless transition to web development without the need to learn JavaScript. For others, the choice between Blazor and other frameworks will depend on factors like project requirements, team expertise, and performance considerations.

As Blazor continues to evolve, it has the potential to become a strong contender in the world of web development, especially for organizations deeply invested in the .NET ecosystem.

.NET 9 Revolutionizing documentation of APIs : From Swashbuckle to Scalar 🚀

Arash zandi — Thu, 09 Jan 2025 09:49:22 +0000

Abstract

API documentation is the backbone of modern software development. With .NET 9's shift from Swashbuckle to Microsoft.AspNetCore.OpenApi, developers need new strategies to stay efficient. This article explores these changes and introduces Scalar, a game-changer for API documentation.
This article delves into the evolution and integration of Swagger in the ASP.NET ecosystem, with a focus on the new developments in .NET 9. It traces Swagger’s journey from its origins as an open-source project to its widespread adoption as the de facto tool for API documentation, testing, and client code generation in the .NET space. As .NET Core matured, Swagger tools like Swashbuckle streamlined the process of adding interactive documentation and OpenAPI support to ASP.NET applications. However, with the release of .NET 9, Swashbuckle.AspNetCore is being deprecated in favor of the Microsoft.AspNetCore.OpenApi library. The article provides practical guidance on how to incorporate Swagger into .NET 9 Web APIs and highlights the shift towards more modern, efficient tools. It also introduces Scalar .NET, an innovative platform that enhances Swagger with a sleek user interface and first-class OpenAPI support. Offering step-by-step instructions and code examples, this article serves as a comprehensive resource for developers looking to modernize their API documentation strategies in .NET 9.

The Story of Swagger
The story of Swagger in ASP.NET is intertwined with the rise of API-driven development and the need for better ways to document, test, and interact with APIs. Here’s a breakdown of how Swagger became a key tool for ASP.NET developers:

The Rise of APIs
As RESTful APIs became central to modern application development, developers faced the challenge of creating clear and consistent documentation. Traditional documentation methods were error-prone and difficult to maintain, especially for large APIs.
Swagger emerged in 2011 as an open-source project by Tony Tam. It aimed to standardize how APIs were described, enabling tools to generate interactive documentation, client SDKs, and server stubs automatically.

Early Adoption in .NET
ASP.NET developers quickly saw the potential of Swagger. However, the integration was manual at first, requiring developers to write Swagger specification files (in JSON or YAML) by hand. This process was tedious and discouraged adoption.

Swashbuckle Makes Swagger Seamless
Swashbuckle, created by Richard Morris, was a game-changer for ASP.NET developers. It provided an easy way to integrate Swagger into ASP.NET projects, automatically generating Swagger JSON from your Web API controllers and routes.
Swashbuckle added features like:

Automatic Documentation: Generating API documentation directly from code, using XML comments and data annotations.
Swagger UI Integration: Embedding an interactive API documentation interface directly into your app.
Customizability: Allowing developers to extend and tweak the Swagger output.

ASP.NET Core Era
When ASP.NET Core was introduced in 2016, it was built with modularity and flexibility in mind. This made integrating Swagger tools even more straightforward. Swashbuckle adapted to ASP.NET Core and became the de facto standard for Swagger integration.
Key features during the ASP.NET Core era:

OpenAPI Specification: Swagger transitioned to the OpenAPI standard in 2015, ensuring broader industry adoption.
Improved Middleware Support: ASP.NET Core’s middleware architecture made it simple to add Swagger generators and UI middleware.
API Versioning Support: Tools like Swashbuckle and NSwag supported multiple API versions, catering to evolving APIs.

Expanding Swagger Ecosystem
Today, ASP.NET developers have multiple options for working with Swagger:

Swashbuckle: The most popular and feature-rich solution for ASP.NET Core.
NSwag: Another powerful tool that supports OpenAPI and adds features like client code generation for TypeScript and C#.
Azure Integration: Swagger/OpenAPI specifications are often used to integrate APIs with Azure API Management. Swagger’s Role in Modern Development Swagger (or OpenAPI) in ASP.NET projects plays a pivotal role in:
Collaboration: Bridging the gap between developers, testers, and stakeholders.
Automation: Generating client SDKs and testing tools automatically.
Developer Experience: Allowing developers to explore and test APIs interactively through tools like Swagger UI.

Swashbuckle.AspNetCore is being removed in .NET9 (Is Swashbuckle is deprecated ?)
“The ASP.NET Core team began shipping web API templates with a dependency on Swashbuckle in the .NET 5 timeframe. The decision allowed the team to provide built-in support for OpenAPI, a language-agnostic, platform-neutral representation of web-based APIs that contains everything needed to discover and interact with HTTP-based service endpoints. You may be more familiar with the name “Swagger” that refers to a set of tools for working with OpenAPI documents. The information in the OpenAPI document enables scenarios like client code generation, stubbing server code, creating documentation and dynamically producing a web-based UI to interactively test the API. It also is heavily used in artificial intelligence applications to provide prompts that describe the API for use by generative AI.
Swashbuckle is a great project, and we appreciate the time and effort its owner and community contributors have put into it. The project is no longer actively maintained by its community owner. Issues have not been addressed or resolved, and there is not an official release for .NET 8. The ASP.NET Core team will provide a solution for this in the .NET 9 release. The plan is to remove the dependency on Swashbuckle.AspnetCore from the web API template and extend the capabilities introduced with Microsoft.AspNetCore.OpenApi to provide OpenAPI document generation.”
For more details on the deprecation of Swashbuckle.AspNetCore, refer to this GitHub issue:

The Future of Swagger
With Microsoft continuously improving ASP.NET Core and OpenAPI becoming the industry standard, Swagger was expected to remain an integral part of the ecosystem. Features like minimal APIs in ASP.NET Core 6+ have made it even easier to integrate Swagger for lightweight and performant APIs. In spite of removing Swagger from Webapi samples it’s still updating and available to use.

How to add Swashbuckle (in practice) to the .Net9 webapi
I’l tell you how to add Swagger into your .Net Web API project using SwashBuckle
Before commencement ensure that .Net version 9 SDK is installed on your system properly

First make a new webapi project with this comamnd
Dotnet new webapi -n OpenApi-Swagger-Scalar

Then Open your project in VsCode
Next right click on an empty area in your project explorer and click on Open In integrated terminal
Next run this command
dotnet add package Swashbuckle.AspNetCore

Now it’s time to configure Swagger in Program.cs

(You see something about OpenApi in your program.cs

builder.Services.AddOpenApi();
app.MapOpenApi();

We will We will discuss that topic later in this topic)

Add these line below : builder.Services.AddOpenApi();

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

Add these lines below app.MapOpenApi()

 app.UseSwagger(); // Enable the Swagger JSON endpoint
 app.UseSwaggerUI(); // Enable the Swagger UI

Run Your Project and open the uri :
http://localhost:{your_port}/swagger/index.html
Or just navigate to /swagger
For example
http://localhost:5000/swagger

Congrats! You have SwashBuckle Swagger in .Net9 again!

The Story of OpenApi
OpenAPI, formerly known as Swagger, is a specification for describing REST APIs. It allows developers to define the structure of their APIs, including endpoints, operations, parameters, and authentication methods, in a format that is both human-readable and machine-readable.
The OpenAPI Specification (OAS) was originally developed by Tony Tam in 2010 as part of the Swagger project. The goal was to create a standard way to describe APIs, making it easier for developers to design, build, document, and consume APIs. In 2015, the Swagger project was donated to the OpenAPI Initiative, a consortium of industry leaders, and the specification was renamed to OpenAPI.
Swagger tools, such as Swagger Editor, Swagger UI, and Swagger Codegen, were built around the OpenAPI Specification to help developers work with APIs more efficiently. These tools allow developers to write OpenAPI definitions, generate interactive API documentation, and create server stubs and client libraries in various programming languages.
The ability of APIs to describe their own structure through OpenAPI has revolutionized API development, enabling better collaboration, automation, and integration across different tools and platforms.
Let’s tell you the first secret 😊
In the test project from previous section you had these two lines in your Program.cs

builder.Services.AddOpenApi();
app.MapOpenApi();

When debugging your test project let’s navigate to this link
http://localhost:{your_port}/openapi/v1.json
for example
http://localhost:5000/openapi/v1.json
You can see all documents about all your apis.

OpenAPI vs. Swagger
The Swagger project was donated to the OpenAPI Initiative in 2015 and has since been referred to as OpenAPI. Both names are used interchangeably. However, "OpenAPI" refers to the specification. "Swagger" refers to the family of open-source and commercial products from SmartBear that work with the OpenAPI Specification. Subsequent open-source products, such as OpenAPIGenerator, also fall under the Swagger family name, despite not being released by SmartBear.
In short:

OpenAPI is a specification.
Swagger is tooling that uses the OpenAPI specification. For example, OpenAPIGenerator and SwaggerUI. You can read more here : microsoft.com

Use SwaggerUI with the power of OpenApi json
So when we already have OpenApi as below
app.MapOpenApi();
There is another choice, swagger can benefits from OpenApi documents to generate it’s UI instead of swagger json endpoint
Thus we can remove this line
app.UseSwagger();
And Instead of this line
app.UseSwaggerUI();
You can use like this

 app.UseSwaggerUI(options =>
    {
        options.SwaggerEndpoint("/openapi/v1.json", "Your Custom Title");
    });

Scalar, A game changer!
Scalar .NET is an open-source API platform that provides a modern REST API client and beautiful API references with first-class OpenAPI/Swagger support. The Scalar.AspNetCore package makes it easy to integrate the Scalar API reference into your .NET applications.
You can read more here.

How to add Swashbuckle (in practice) to the .Net9 webapi
Install the package: Use the following command to add the Scalar.AspNetCore package to your .NET sample project:
dotnet add package Scalar.AspNetCore

Add this line above your Program.cs to as the namespace

using Scalar.AspNetCore;

Ensure that you have these lines in your program.cs

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
app.MapOpenApi();

Now add this line to the Program.cs

app.MapScalarApiReference();

When debugging your test project let’s navigate to this link
http://localhost:{your_port}/scalar/v1
for example
http://localhost:5000/scalar/v1
You can see a new modern and pretty cool UI to test your apis :

Time to tell you the second secret 😊
Instead of this line
app.MapScalarApiReference();

let’s use something like this

app.MapScalarApiReference(options =>
{
    options
    .WithTitle("Your Custom Title")
    .WithTheme(ScalarTheme.Mars)
    .WithDefaultHttpClient(ScalarTarget.CSharp, ScalarClient.HttpClient);
});

Boom !!!

Now You have your custom title
You have an amazing theme
You have C# codes as the default

All solutions
Now you have all this links for test with these lines of code existing in the Program.cs

builder.Services.AddOpenApi();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
app.MapOpenApi();
app.UseSwagger(); // Enable the Swagger JSON endpoint
app.UseSwaggerUI(); // Enable the Swagger UI
app.MapScalarApiReference();

Json Based Document for apis
http://localhost:5000/openapi/v1.json
http://localhost:5247/swagger/v1/swagger.json
UI based
http://localhost:5000/swagger/index.html
http://localhost:5000/scalar/v1

Summary
This article explores the evolution of Swagger in the ASP.NET ecosystem and its integration with .NET 9, focusing on OpenAPI and the Scalar platform.
It begins by detailing the history of Swagger, its emergence as an open-source tool to standardize API documentation, and its early adoption by ASP.NET developers. The article highlights how tools like Swashbuckle made Swagger easier to integrate with ASP.NET Core, automating API documentation and enhancing the developer experience. As .NET Core evolved, Swagger became a key tool for API documentation, testing, and client code generation.
With the release of .NET 9, Swashbuckle.AspNetCore is being deprecated, and the ASP.NET Core team plans to extend the Microsoft.AspNetCore.OpenApi library. The article provides practical steps for adding Swagger (via Swashbuckle) to a .NET 9 Web API project and discusses the removal of Swagger in Web API templates, suggesting alternatives for API documentation.
The article also introduces Scalar .NET, a modern platform that enhances Swagger with a beautiful UI and OpenAPI support. It shows how to integrate Scalar into a .NET project, offering a more polished and customizable API reference solution.
In summary, the article covers the history, evolution, and future of Swagger in the .NET ecosystem, along with practical guidance on using both Swagger and Scalar for efficient API documentation in .NET 9. And With the tools and insights provided, you're now ready to modernize your API documentation in .NET 9. Whether leveraging Scalar or sticking with OpenAPI, the key is to adapt and stay ahead of evolving standards.

Source codes are available for download here :
Github : https://github.com/zandiarash

Eager to know how to Integrate Swagger, Scalar, OpenAPI with .Net Aspir?
Read this article
https://dev.to/arashzandi/net-aspire-add-swagger-openapi-scalar-to-the-apphost-3ll6