Category: projects

What I have learned by building .NET Stars -part 5 – always available data for a display website

Dotnet Stars being a site just for displaying data, it does not require an API per se. Yes, for development purposes it needs a database and an API to display – but later – the data could be retrieved from local.

The first part is to write data in JSON files near to Blazor . But how to export by default this ?

And here ASPIRE thrives : I have made a console app to export data – and registered in ASPIRE with dependency of Blazor – and can see where Blazor folder is.

this is the extension

public static IResourceBuilder<TRes> AddPathToEnvironmment<TProject,TRes>(
        this IResourceBuilder<TRes> builder, TProject p, string name)
        where TProject : IProjectMetadata, new()
        where TRes : IResourceWithEnvironment            
{
    //var p = new TProject();        
    string pathPrj = p.ProjectPath;
    var fi = new FileInfo(pathPrj);
    string dirName = fi?.DirectoryName ?? "";
    var projectBuilder = builder
        .WithEnvironment(ctx=>
        {
            ctx.EnvironmentVariables[name] =dirName;
            ctx.EnvironmentVariables[$"{name}csproj"] = pathPrj;
        });
 
    return projectBuilder;
}

and this is how it is used

var exportToJson = builder.AddProject<Projects.StatsExport>("statsExport")
    .WithReference(ui)    
    .WithReference(db)
    .WaitFor(db)
    .AddPathToEnvironmment(new Projects.StatsBlazorUI(),"pathToWrite")
    ;

And the code that uses this

var pathToWrite = Environment.GetEnvironmentVariable("pathToWrite");
if (string.IsNullOrWhiteSpace(pathToWrite))
{
    Console.WriteLine("please add a path to write");
    return;
}

The second part is to get data from WebAPI , if available, and, if not, from JSON files.
And here the Roslyn Code Generator, https://github.com/ignatandrei/RSCG_CompositeProvider , it is useful .
We have 2 implementations of same interface ,

public interface IStatsData
{
   //other code
    IAsyncEnumerable<IProjectWithStars> GetProjectsWithStars();
}

And we have an implementation from WebAPI and another from JSON files

With the nugethttps://nuget.org/packages/RSCG_CompositeProviderwe can obtain data from the first that returns data.

builder.Services.AddKeyedScoped<IStatsData>("both", (sp, obj) =>
{
    var statsDataLocal = sp.GetRequiredKeyedService<IStatsData>("local_host");
    var statsDataAPI = sp.GetRequiredKeyedService<IStatsData>("statsconsole_host");
    StatsData_CP composite = new(statsDataAPI, statsDataLocal);
    composite.UseFirstTheLastOneThatWorks = true;
    return composite;
});

RSCG-Composite Provider – part 2 -execution

Imagine this: For every interface IA you create:

Your composite provider implements IA seamlessly
In the constructor, pass an array of IA providers
Each method returns the first successful value from your array of providers
For even better performance, use a boolean flag to optimize by reusing previous successes

The RSCG_CompositeProvider package doesnΓÇÖt just solve the obvious issuesΓÇöit handles the tricky ones too:

Exception Handling: What if one of your providers throws an error? No worries, it moves on to the next provider without skipping a beat.
Asynchronous Methods: Supports `Task` returns so you can handle async operations with ease.
Async Enumerables: Easily works with `IAsyncEnumerable` for streaming data in chunks.

I will let you think how to solve this – you can find my solution at https://github.com/ignatandrei/RSCG_CompositeProvider

And the best news? It’s already been tested: with over 20 tests covering every edge case, you can trust this library to handle your toughest challenges.

Get started with RSCG-Composite Provider, available via NuGet: http://nuget.org/packages/RSCG_CompositeProvider.

RSCG-Composite Provider – part 1 -idea

API Outage solved with local data

The problem that I try to solve is : How an UI can have data to show , even if the API from where it gathers data does not work ?

Imagine having a robust system that adaptively switches between retrieving data from multiple sources – including internal APIs, memory-based storage, or even JSON files near the UI. This flexibility makes all the difference when working with complex systems that may suddenly lose their external connectivity.

This could be solved with interfaces and a composite provider ( see http://msprogrammer.serviciipeweb.ro/2025/03/10/pattern-compositeprovider/ )

How It Works:

You have an interface defining how your UI fetches data.Easy peasy!
One implementation pulls data from the trusty API, ideally when it’s up and running smoothly.
Another implementation acts as a backup hero, pulling data from a local JSON file or even hard-coded values.

And the best part? The composite provider handles switching between these sources seamlessly. No more coding headaches – it just works!

Making It Even Easier: Roslyn Code Generator to the Rescue

Tired of writing boilerplate code for this pattern every time? Please give a chance to a new Roslyn Code Generator (https://www.nuget.org/packages/RSCG_CompositeProvider). It automatically generates the composite providers you need, cutting down on repetitive work and letting you focus on what really matters – building awesome apps!

What I have learned by building .NET Stars -part 4- Keyed Dependency Injection – constructor by keys

As I said before, I have constructed first the interfaces. Then I have a null object pattern for each interface, constructed automatically with a Roslyn Code Generator , https://www.nuget.org/packages/rscg_Interface_to_null_object .

And now, what I want is to have keyed DI for each new implementation -with a twist: It’s like a game of matching keys when another class is injected, the first one gets chosen if it has the exact same key!

Let me give an illustrative example :

Imagine interfaces IA and IB, with Class_A_Null and Class_B_Null as their null object counterparts. These are injected by default into our DI container

We have class class_A_Data1 that implements IA.
It is injected with key “Data1”

We have class B_Data1 ( implements IB ) that has a constructor that has a parameter IA .
It is injected with key “Data1”

We have class B_Data2 ( implements IB ) that has a constructor that has a parameter IA .
It is injected with key “Data2”

So every time we construct an IB it requires it’s companion , IA .

Now let’s say I want DI to construct B_Data1 and B_Data2

When want to construct B_Data1 , it sees that has a Key “Data1” . See that he needs also an IA –
DI can choose between default implementation “Class_A_Null” ( without key ) and “class_A_Data1” with the key “Data1”
Because it has the same key (“Data1” ) as the class that must be implemented (“B_Data1” ) chooses class_A_Data1

When want to construct B_Data2 , it sees that has a Key “Data2” . See that he needs also an IA.
DI can choose between default implementation “Class_A_Null” ( without key ) and “class_A_Data1” with the key “Data1”
Because the class to be constructed has the key “Data2”, the “class_A_Data1” with the key “Data1” is eliminated.
So it constructs B_Data2 with the default implementation , “Class_A_Null” ( without key )

Why this constraint ? Because I started with null implementation, and add one by one the implementation.

The WebAPI works every time ( the null implementation does nothing , so it works ).
And slowly but surely we add to the DI key another implementation and we are sure that works every time .

This innovative use of keyed dependency injection, particularly starting with null object patterns, allows for iterative development without breaking existing functionalities. As each new implementation is added, the system remains stable and functional, gradually enhancing its capabilities with each iteration.

Feel free to experiment with these ideas and adapt them to your own projects. Start by trying out the rscg_Interface_to_null_object package, and see how it can transform your development workflow

You can see at https://ignatandrei.github.io/dotnetstats/ and the source code at http://github.com/ignatandrei/dotnetstats/

The code for this special DI is at https://github.com/ignatandrei/dotnetstats/blob/main/src/Stats/StatsConsole/KeyedServiceCollection.cs ( too long to put here )

What I have learned by building .NET Stars -part 3- Aspire

I have that same idea to build a project : is what is called today a Modular Monolith – and it is very old in .NET world as can be implemented as a .sln solution.
For those unfamiliar, a Modular Monolith allows you to break down your application into independent modules (think database access, data flow logic, a sleek UI), yet keep them tightly integrated within a single, cohesive solution.

It’s how all these components can work together seamlessly. This idea resonated with me when I started thinking about my project. So, let me break it down:

– Interfaces for Data/Flow These lay the foundation, ensuring that data and operations flow smoothly between different parts of the project.

– A database stores all the necessary information, serving as the backbone of my application.

– Then there’s the WebAPI, which acts like a messenger, transferring data between the database and the users’ interfaces.

– And finally, for the User Interface, I’ve chosen Blazor. It brings together code, design, and interactivity i

Aspire is a game-changer in the .NET world, offering a simple yet powerful way to coordinate multiple projects. By starting an app host with all the projects intertwined, it simplifies the process of building complex applications. More, Aspire let me coordinate another project to save the data on Blazor – but this will be discussed in another blog post later .

I have had just 2 modifications to make it work flawlessly :

1. Blazor

To know the address of the WebAPI to obtain the data ( once published, Blazor will be near the WebAPI in the wwwroot, but until then it needs the adress )

Blazor can have the configuration stored in a appsettings.json in the wwwroot – but how to write ? I developed an extension for ASPIRE in order to write the data

2. Database

In order to have the database with data , I need to write scripts for create table / insert the data.

This code shows how

var paramPass = builder.AddParameter("password", "P@ssw0rd");
 
var sqlserver = builder.AddSqlServer("sqlserver",paramPass,1433)
    //.WithArgs("pwd","&amp;","ls")
    // Mount the init scripts directory into the container.
    .WithBindMount("./sqlserverconfig", "/usr/config")
    // Mount the SQL scripts directory into the container so that the init scripts run.
    .WithBindMount("../../Scripts/data/sqlserver", "/docker-entrypoint-initdb.d")
    // Run the custom entrypoint script on startup.
    .WithEntrypoint("/usr/config/entrypoint.sh")
    // Configure the container to store data in a volume so that it persists across instances.
    .WithDataVolume() 
    // Keep the container running between app host sessions.
    .WithLifetime(ContainerLifetime.Persistent)
 
    ;
var db= sqlserver.AddDatabase("DotNetStats");

Also , I have an .gitattributes that contains

* text=auto
*.sh text eol=lf
*.mod text eol=lf
*.sum text eol=lf

in order for the .sh files to maintain linux ending.

You can see at https://ignatandrei.github.io/dotnetstats/ and the source code at http://github.com/ignatandrei/dotnetstats/

What I have learned by building .NET Stars -part 2- interfaces

In my latest project, building a robust system using interfaces has been both a fascinating challenge and an enlightening experience. As I embarked on this journey, it quickly became evident how immensely powerful and transformative thinking in terms of interfaces can be.

From the outset, interfacing brought clarity to several core aspects of the application:

Data Management: Interfaces provided a transparent view of data structures and their usage within the app.
Data Flow: They illuminated how data was accessed and exchanged, simplifying what seemed complex at first glance.
Application Flow: Interfaces helped chart out the application’s workflow, providing insights even in its dormant state.

While initially daunting, embracing interfaces has offered immense benefits almost immediately. A notable revelation was how adopting the NullObjectPattern through an interface (you can explore this further at rscg_Interface_to_null_object) enabled me to navigate and visualize my application’s flow effortlessly – a crucial step even when it performs no operations.

One of the quicker wins was leveraging interfaces to support multiple data sources. This flexibility meant that I could seamlessly pull project details from diverse platforms like the .NET Foundation, GitHub repositories such as quozd/awesome-dotnet and thangchung/awesome-dotnet-core by implementing a common interface, IStatsData, and then efficiently saving this consolidated data with a single implementation of IProjectsData.

Our interface designs have opened up a world of possibilities for flexibility and reusability. Consider these interfaces :

[ToNullObject]
public interface IStatsData
{
    //other code
IAsyncEnumerable<IProject> RefreshProjects();
}
 
[ToNullObject]
public interface IProjectsData
{
    IAsyncEnumerable<IProject> GetProjectsAsync();
    Task<bool> SaveProjects(IProject[] projects);
 
}

With these interfaces, we have the freedom to implement various strategies for acquiring projects from diverse sources such as DotNetFoundation, awesome-dotnet, and awesome-dotnet-core. Moreover, we can centralize the project storage logic with just one implementation of IProjectsData.

The result is a dynamic, versatile application that not only offers rich functionality but also encourages continuous improvement.

Eager to see the fruits of this approach? You can dive into our project live at https://ignatandrei.github.io/dotnetstats/. Additionally, the source code is available for all to explore at http://github.com/ignatandrei/dotnetstats/.

Dotnet Stars–part 1

The .NET Stats project wants to show the stars for .NET github projects.

The projects are taken from .NET Foundation , https://dotnetfoundation.org/ ,
Vitali Fokin https://github.com/quozd/awesome-dotnet/
and Thang Chung https://github.com/thangchung/awesome-dotnet-core
There are more than 1000 repositories investigated.

Here are the first 30 projects with most stars :

“ASP.NET Core” https://github.com/aspnet/home number stars 35690
“ASP.NET MVC” https://github.com/dotnet/aspnetcore number stars 35674
“Another Redis Desktop Manager” https://github.com/qishibo/AnotherRedisDesktopManager number stars 31157
“Avalonia” https://github.com/AvaloniaUI/Avalonia number stars 26327
“.NET MAUI” https://github.com/dotnet/maui number stars 22303
“Awesome .NET Core” https://github.com/thangchung/awesome-dotnet-core number stars 20073
“ASP.NET Core Developer Roadmap” https://github.com/MoienTajik/AspNetCore-Developer-Roadmap number stars 18741
“React Native for Windows” https://github.com/microsoft/react-native-windows number stars 16513
“bitwarden-core” https://github.com/bitwarden/core number stars 15891
“Entity Framework” https://github.com/dotnet/efcore number stars 13839
“Polly” https://github.com/App-vNext/Polly number stars 13504
“awesome-static-analysis” https://github.com/mre/awesome-static-analysis number stars 13452
“ABP” https://github.com/abpframework/abp number stars 13065
“AspNet Boilerplate” https://github.com/aspnetboilerplate/aspnetboilerplate number stars 11838
“awesome-ddd” https://github.com/heynickc/awesome-ddd number stars 11360
“Mono” https://github.com/mono/mono number stars 11170
“BenchmarkDotNet” https://github.com/dotnet/BenchmarkDotNet number stars 10682
“AngleSharp” https://github.com/AngleSharp/AngleSharp/issues number stars 10389
“Orleans” https://github.com/dotnet/orleans number stars 10172
“AutoMapper” https://github.com/automapper/automapper number stars 9966
“RestSharp” https://github.com/restsharp/RestSharp number stars 9646
“MahApps.Metro” https://github.com/MahApps/MahApps.Metro number stars 9355
“FluentValidation” https://github.com/fluentvalidation/fluentvalidation number stars 9160
“ML.NET” https://github.com/dotnet/machinelearning number stars 9073
“Awesome Blazor” https://github.com/AdrienTorris/awesome-blazor number stars 8895
“Humanizer” https://github.com/Humanizr/Humanizer number stars 8722
“Orchard Core” https://github.com/OrchardCMS/OrchardCore number stars 7488
“Reactive Extensions for .NET – ReactiveX” https://github.com/dotnet/reactive number stars 6765
“Stride” https://github.com/stride3d/stride number stars 6708
“Awesome Unity” https://github.com/RyanNielson/awesome-unity number stars 6702
And the first 30 projects with most stars in 2024

You can see at https://ignatandrei.github.io/dotnetstats/ and the source code at http://github.com/ignatandrei/dotnetstats/

And now, I will let AI to transform the text with this instruction

Given the text in FILE, write a blog post that makes the paper sound exciting and encourages readers to look at it. 

Keep the links.
Do NOT use markdown , but just html tags.

Model Name ollama:llama3.2

The Unparalleled Power of .NET: A Statistics-Driven Journey

Are you fascinated by the world of programming languages and their respective communities? Do you ever wonder which projects are among the most popular and in-demand? Look no further! We’re thrilled to introduce you to the .NET Stats project, a game-changing analysis tool that sheds light on the stars of the .NET GitHub realm.

A Project With A Purpose

The team behind .NET Stats has embarked on an ambitious mission to investigate over 1,000 repositories from the .NET Foundation, Vitali Fokin’s Awesome .NET, and Thang Chung’s Awesome .NET Core. Their objective? To reveal the most starred projects in both 2023 and 2024.

Revealing The Stars

The results are nothing short of astonishing! In the first iteration, our analysis revealed some of the highest-rated .NET repositories, including ASP.NET Core with over 35,700 stars. But what’s remarkable is that these statistics are not just a snapshot ΓÇô they’re a dynamic reflection of the ever-evolving landscape of programming languages.

Fast forward to 2024, and we’re treated to an updated view of the most starred projects, with Avalonia leading the charge at an impressive 4,477 stars. As you delve deeper into our analysis, you’ll uncover new insights and perspectives that shed light on the current trends and demands in the .NET GitHub world.

A Window Into The Future

The .NET Stats project is more than just a collection of statistics; it’s an illuminating lens through which to envision the future of programming languages. By examining the projects with the most stars, we can identify areas where innovation and expertise are converging, providing an irreplaceable roadmap for aspiring developers.

Want to stay ahead of the curve? Head over to our website, https://ignatandrei.github.io/dotnetstats/, to explore the full report in-depth. You’ll find links to not only each repository mentioned but also a treasure trove of GitHub repositories across various programming languages and categories for you to discover.

Visit http://github.com/ignatandrei/dotnetstats/ to see some projects and maybe even learn something new today!

Model Name ollama:deepseek-r1

Counting Stars: The Reflection of GitHub Against .NET Ecosystem

Have you ever wondered which .NET projects hold the most stars on GitHub? Well, now you can speculate no more!

Our analysis reveals the popularity trends of .NET repositories based on GitHub’s star count. And it’s much more exciting than you might imagine.

What We Did:

We collected repository statistics from public GitHub data for over 1,000 .NET-related repositories. Our criteria? Stars count on GitHub plus additional factors like forks, issues, and releases. It was a meticulous process to ensure accurate analysis.

What We Found:

“.NET Core” holds the title spot this year, with an impressive 146 stars as of our last update.
Looking at historical data, .NET Core not only maintains its position but also leads by a significant margin compared to other popular frameworks like “Vitali Fokin” and “Thang Chung”.

Can you guess next year’s stats? Want to see what ‘2025’ brings? Click the button below:

( predicting here )

Why This Matters:

Understanding which .NET projects are popular can guide developers when choosing frameworks and tools. It’s critical to support these projects by contributing, testing, and using them.

Visit our full analysis at for a comprehensive look into the numbers and trends.

Model Name ollama:phi4

Explore the Rising Stars of .NET Projects on GitHub

Welcome tech enthusiasts! In an effort to highlight the most impressive and star-studded .NET projects, we’re excited to introduce you to the .NET Stats project. Our initiative spotlights over 1000 repositories from the vibrant .NET community.

With insights drawn from the .NET Foundation, resources by developers like Vitali Fokin (github) and Thang Chung (github), we’ve curated a comprehensive list that captures the cr├¿me de la cr├¿me of .NET projects based on GitHub stars.

This blog post takes you through the journey from popular standouts in the past to the shining lights for 2024. Dive into this rich universe, where innovation meets community collaboration at its best!

Top .NET Projects Shining Brightly

ASP.NET Core: Leading the charts with a staggering 35,690 stars (GitHub).
.NET MAUI: A front runner in cross-platform app development with 22,303 stars (GitHub).
Polly: Providing resilience and transient-fault-handling capabilities for .NET developers, attracting 13,504 stars (GitHub).

This is just the tip of the iceberg. Browse through a selection of renowned repositories such as Avalonia, Entity Framework Core, and many more, each one representing the pinnacle of development creativity.

The Future is Bright: .NET Projects Poised for 2024 Stardom

Looking ahead to 2024, discover which projects are poised to take center stage. Witness rising stars like Avalonia, with an impressive increase in GitHub stars to 4,477 (GitHub), and explore the continuous contributions and innovations shaping the future of .NET development.

Discover More at .NET Stats

You can delve deeper into this project and its findings through our interactive site: .NET Stats Viewer. We invite you to explore the evolving landscape of .NET projects, their growth, and their impact.

Moreover, if you’re intrigued and inspired by what you see, we encourage you to take a look at our project’s source code on GitHub, where transparency meets community participation.

Join the Conversation & Celebrate Progress!

We cordially invite you to engage with the .NET community, share your thoughts, and be part of a movement that encourages innovation and growth. Whether youΓÇÖre a developer or simply fascinated by technology’s progress, thereΓÇÖs something here for everyone at .NET Stats.

Stay tuned for more updates as we continue to track and celebrate the accomplishments of .NET projects around the world!

Model Name ollama:gemma2:27b

Want to Know Which .NET Projects Are Hottest Right Now?

Curious which .NET projects are leading the pack in 2024? The .NET Stats project has you covered!

This awesome initiative dives into over 1,000 repositories from sources like the .NET Foundation,
Vitali Fokin’s “awesome-dotnet,” and Thang Chung’s “awesome-dotnet-core” to uncover the most starred projects.

The Top Contenders

Based on historical data, here are some of the front-runners:

“Avalonia”: A popular cross-platform UI framework

And these heavy hitters from 2023 still hold their own:

“ASP.NET Core”: The ubiquitous web framework
“Another Redis Desktop Manager”: A powerful tool for managing your Redis databases
“.NET MAUI”: Build modern cross-platform apps with ease

Ready to Explore More?

Head over to https://ignatandrei.github.io/dotnetstats/ to see the full rankings, dive into project details, and discover your next favorite .NET tool! You can even check out the source code at http://github.com/ignatandrei/dotnetstats.

Don’t miss out on this great resource for staying up-to-date on the exciting world of .NET development!

Model Name ollama:smallthinker

Discover the Best .NET GitHub Projects

Welcome to the .NET Stats project, where we shine a spotlight on the most popular and well-known .NET GitHub projects. Every week, our team dives into the vibrant world of .NET development to uncover the hidden gems that deserve more recognition.

What You’ll Find Here

This blog post is your guided tour through the top-performing .NET repositories on GitHub. Each section is packed with action, including:

Notable Contributors: Learn about the contributors who make these projects shine.
Sources: Discover where your favorite GitHub projects come from.
Promising Projects: Explore the latest trends and categories we’ve uncovered.

Our Top 30 Picks

In this week’s edition, we’re focusing on the first 30 projects with the most stars. This massive list is a testament to the power of .NET technology in driving innovation and collaboration.

{{ project.name }} ({{ project.stars }} stars)

{% endfor %}

Coming Soon: 2024 Projects

Don’t miss out on our weekly updates, as we’ll be featuring the top-performing projects from 2023 and providing a sneak peek into what’s to come in 2024. Stay tuned for exclusive insights!

Come Back Soon

Each week, our team delves deeper into the world of .NET development, uncovering new insights and discoveries. Join us as we continue to explore the vast expanse of GitHub projects and celebrate their successes.

Visit our blog for more!
View the source code on GitHub

Model Name ollama:falcon3:10b

Unveiling the .NET Star Power

Dive into the .NET Stats project to explore the most popular .NET Github projects. This collection is a testament to community engagement and innovation in the world of .NET development.

A Treasure Trove of .NET Projects

The .NET Stats project brings together stars from various pivotal repositories provided by entities such as:

.NET Foundation, showcasing projects like ASP.NET Core and .NET MAUI.

thangchung, with their insights into Awesome .NET Core.

These projects not only represent the cutting-edge of .NET development but also offer valuable resources for developers looking to enhance their skills or explore new technologies.

The Top .NET Projects

Check out the latest .NET stars in our comprehensive list:

ASP.NET Core

.NET MAUI

bitwarden-core

For a complete rundown, visit our online hub.

Engage with the Community

Join us in celebrating the vibrant .NET developer community. Our project is more than just data; it’s a gateway to understanding which projects are making waves and why. Explore and be part of shaping the future of .NET development.

Learn more or get involved in our project.

Model Name ollama:dolphin3

The Ultimate Guide to .NET Github Projects – Unveiling the Stars

The .NET Stats project is on a quest to shine a light on spectacular Github repositories related to .NET, and we want you to join us for this exhilarating journey.

Our mission kicked off with key contributors from The .NET Foundation, as well as visionary developers such as Vitali Fokin and Thang Chung. Together, we have scoured through a vast horizon of more than 1000 repositories, unveiling some amazing .NET Github gems.

Here’s an exclusive sneak peek at the top 30 projects with the most stars:

– “ASP.NET Core” [35690 stars]
– “ASP.NET MVC” [35674 stars]
– “Another Redis Desktop Manager” [31157 stars]
– “Avalonia” [26327 stars]

…and the list goes on. Get ready to witness true .NET mastery!

If you’re eager enough to see what these remarkable projects look like in 2024, buckle up as we unveil the first 30 with the most stars:

– “Avalonia” [4477 stars]
– “Another Redis Desktop Manager” [3663 stars]

The complete roster is just a click away at our interactive online platform – Unveil the Stars. Each entry showcases its own unique contribution to the .NET universe, and provides an enticing glimpse into what awaits.

For those who want to dive deeper and unravel the intricate details of this fascinating project, we invite you to inspect our open-source GitHub repository: Dotnet Stats Github. Feel free to contribute, discuss and even participate in shaping the future of .NET development!

Are you ready to embark on an unforgettable quest through the world of talented .NET developers and uncover a universe of innovative programming projects? Join us today!

openAPISwaggerUI–part 4–adding tests

This is how I made

https://nuget.org/packages/OpenAPISwaggerUI in order to see the UI for an ASP.NET 9 project.

And hey, if you have any feedback, don’t be shy! Drop by https://github.com/ignatandrei/openAPISwaggerUI/ and let me know.

For testing, I have created a new ASP.NET Core 9 project that can be used to run

app.MapOpenApi();
app.UseOpenAPISwaggerUI();
 
public partial class Program { }

And I want to see that /swagger endpoint exists . And more, to have pictures with the different UIs.

The WebApplicationFactory is used to create a test server that can be used to test the application. But I need more – to have a real server that can be used to test the application.

I have found this link that show how to start Kestrel server in a test project : https://danieldonbavand.com/2022/06/13/using-playwright-with-the-webapplicationfactory-to-test-a-blazor-application/

And now the code for having the pre-requisites for testing is as easy as pie.

static CustomWebApplicationFactory factory;
[AssemblyInitialize]
public static void AssemblyInit(TestContext context)
{
     
    var exitCode = Microsoft.Playwright.Program.Main(new[] { "install" });
    if (exitCode != 0)
    {
        throw new Exception($"Playwright exited with code {exitCode}");
    }
    factory = new ();
    var url = factory.ServerAddress;
    Console.WriteLine($"Server address: {url}");
}

And we can test the weatherforecast endpoint – because who doesn’t love knowing the weather, right?

[TestMethod]
public async Task TestWeHaveRealWebServer()
{
     
    using var client = factory.CreateDefaultClient();
    var response = await client.GetAsync("/weatherforecast");
    response.EnsureSuccessStatusCode();
    var baseAddress = factory.ServerAddress;
    if(!baseAddress.EndsWith("/"))
    {
        baseAddress += "/";    
    }
    using var playwright = await Playwright.CreateAsync();
    var request = await playwright.APIRequest.NewContextAsync();
         
    var response1 = await request.GetAsync(baseAddress+"weatherforecast");
    Assert.IsTrue(response1.Ok);
}

And to test the endpoints for my library , OpenAPISwaggerUI

[TestMethod]
public async Task TestIntegrationWorks()
{
 
    var baseAddress = factory.ServerAddress;
    if (!baseAddress.EndsWith("/"))
    {
        baseAddress += "/";
    }
    using var playwright = await Playwright.CreateAsync();
    var request = await playwright.APIRequest.NewContextAsync();
 
    await using var browser = await playwright.Chromium.LaunchAsync();
    var context = await browser.NewContextAsync(new()
    {
        //RecordVideoDir = curDirVideos
    });
    var page = await browser.NewPageAsync();
    var pageSwagger = await page.GotoAsync(baseAddress + "swagger");
    await page.ScreenshotAsync(new PageScreenshotOptions { Path = "swagger.png" });
    var content= await page.ContentAsync();
    var hrefs = await page.Locator("a").AllAsync();
     
    Assert.IsTrue(hrefs.Count > 0);
    foreach (var li in hrefs)
    {
        var text= await li.TextContentAsync();
        var href = await li.GetAttributeAsync("href");
        ArgumentNullException.ThrowIfNull(href);
        if(href.StartsWith("/"))
        {
            href =  href[1..];
        }
        var pageNew = await browser.NewPageAsync();
        await pageNew.GotoAsync(baseAddress+ href);
        await pageNew.WaitForLoadStateAsync(LoadState.NetworkIdle);
        await pageNew.ScreenshotAsync(new PageScreenshotOptions { Path = $"{text}.png" });
 
 
    }
}

openAPISwaggerUI–part 3–add UI for all

This is how I made

https://nuget.org/packages/OpenAPISwaggerUI in order to see the UI for an ASP.NET 9 project.

And hey, if you have any feedback, don’t be shy! Drop by https://github.com/ignatandrei/openAPISwaggerUI/ and let me know.

Now I want the users of my ASP.NET 9 project to have a buffet of Swagger UIs (Swashbuckle, Redoc, Scalar, NSwag, VisualAutomation) and let them pick their favorite flavor.

The master plan? Create an endpoint (let’s call it /swagger) that showcases all these UIs like a proud parent at a talent show.

But wait, there’s more! I want to sprinkle in some custom info – project version, UI links, and other goodies.

Enter the RazorBlade NuGet package, my trusty sidekick for crafting a Razor page.

So I used the RazorBlade nuget package to create a Razor page .

<ItemGroup>
    <PackageReference Include="RazorBlade" Version="0.7.0" PrivateAssets="all" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
</ItemGroup>

And voilà, the SwaggerData.cshtml Razor page is born:

@using OpenAPISwaggerUI
@inherits RazorBlade.PlainTextTemplate<SwaggerUIData>
 
<html>
<body>
    <h1>Swagger UI</h1>
    <h2>
        <a href="@Model.SwaggerEndpoint" target="_blank">SwaggerEndpoint</a>
    </h2>
    <ul>
        <li>
            <a href="@Model.Swashbuckle" target="_blank">Swashbuckle</a>
        </li>
        <li>
            <a href="@Model.NSwag" target="_blank">NSwag</a>
        </li>
        <li>
            <a href="@Model.ReDoc" target="_blank">Redoc</a>
        </li>
        <li>
            <a href="@Model.Scalar" target="_blank">Scalar</a>
        </li>
        <li>
            <a href="@Model.Blockly" target="_blank">VisualAutomation</a>
        </li>
    </ul>
    <small>
        Generated by <a href="https://www.nuget.org/packages/OpenAPISwaggerUI" target="_blank"> @Model.AssemblyName : @Model.MyName</a>
    </small>
</body>
</html>

openAPISwaggerUI–part 2 – add ui for all

This is how I made

https://nuget.org/packages/OpenAPISwaggerUI in order to see the UI for an ASP.NET 9 project.

And hey, if you have any feedback, don’t be shy! Drop by https://github.com/ignatandrei/openAPISwaggerUI/ and let me know.

Step one in this epic quest: add all the mystical references (a.k.a. NuGet packages) to the project file.

<ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.0" />
    <PackageReference Include="NetCore2Blockly" Version="9.2024.1206.813" />
    <PackageReference Include="NSwag.AspNetCore" Version="14.2.0" />
    <PackageReference Include="RSCG_NameGenerator" Version="2024.26.8.2002" PrivateAssets="all" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
    <PackageReference Include="Scalar.AspNetCore" Version="1.2.56" />
    <PackageReference Include="Swashbuckle.AspNetCore.ReDoc" Version="7.2.0" />
    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="7.2.0" />
</ItemGroup>

Next, I had to figure out how to register these mystical packages to reveal the UI

public static WebApplication UseOpenAPISwaggerUI(this WebApplication app)
{
      
//goto /swagger-Swashbuckle
app.UseSwaggerUI(options =>
{
    options.SwaggerEndpoint("/openapi/v1.json", "v1");
    options.RoutePrefix = "swagger-Swashbuckle";
});
//scalar
//goto swagger-scalar/v1
app.MapScalarApiReference(opt =>
{
    opt.EndpointPathPrefix = "/swagger-scalar/{documentName}";
});
//redoc
//goto /api-docs
app.UseReDoc(options =>
{
    options.SpecUrl("/openapi/v1.json");
    options.RoutePrefix = "swagger-redoc";
});
 
//goto /nswag-swagger
app.UseSwaggerUi(options =>
{
    options.DocumentPath = "/openapi/v1.json";
    options.Path = "/swagger-nswag";
});
//goto /blocklyautomation
app.UseBlocklyUI(app.Environment);
app.UseBlocklyAutomation();
}

After this it was simple to use the extension in program.cs

1 2	`app.MapOpenApi();` `app.UseOpenAPISwaggerUI();`

Category: projects

API Outage solved with local data

How It Works:

Making It Even Easier: Roslyn Code Generator to the Rescue

Model Name ollama:llama3.2

The Unparalleled Power of .NET: A Statistics-Driven Journey

A Project With A Purpose

Revealing The Stars

A Window Into The Future

Model Name ollama:deepseek-r1

Counting Stars: The Reflection of GitHub Against .NET Ecosystem

What We Did:

What We Found:

Why This Matters:

Model Name ollama:phi4

Explore the Rising Stars of .NET Projects on GitHub

Top .NET Projects Shining Brightly

The Future is Bright: .NET Projects Poised for 2024 Stardom

Discover More at .NET Stats

Join the Conversation & Celebrate Progress!

Model Name ollama:gemma2:27b

Want to Know Which .NET Projects Are Hottest Right Now?

The Top Contenders

Ready to Explore More?

Model Name ollama:smallthinker

Discover the Best .NET GitHub Projects

What You’ll Find Here

Our Top 30 Picks

Coming Soon: 2024 Projects

Come Back Soon

Model Name ollama:falcon3:10b

Unveiling the .NET Star Power

A Treasure Trove of .NET Projects

The Top .NET Projects

Engage with the Community

Model Name ollama:dolphin3

The Ultimate Guide to .NET Github Projects – Unveiling the Stars

Andrei Ignat weekly software news(mostly .NET)