ASP.NET Core VS LocalStorage

Multiple repos make creating a list of matching packages surprisingly hard. I learned this when working on ASP.NET Core. The framework initially consisted of a couple of dozen of repos. Our build servers were constantly grinding because of what we called "build waves." A build wave was initiated by a single commit that triggered a build. When this build finished, it triggered builds in repos depending on it. This process continued until all repos were built. Not only was this process slow and fragile, but with a steady stream of commits across all the repos, producing a list of matching packages was difficult.

Only in the .NET can you build web applications, APIs, microservices, and real-time applications in one stack. Its highly customizable nature is a good choice for startups with limited budgets. Additionally, being a Microsoft product, ASP.NET Core integrates well with other Microsoft products, such as Azure Active Directory, to deliver competitive products. You can begin building applications by reading the ASP.NET docs.

UseCors middleware should be placed before UseResponseCaching due to this bug.

1. ASP.NET Core

> Just .GetAwaiter().GetResult() it.

That won’t work with various synchronization contexts, where doing this would cause a deadlock. There’s not much fun in trying to debug such issues.

And now that various libraries only provide async api, or worse an non-async version wrapping the async one with . GetAwaiter().GetResult(), you’ll be in for a treat updating your dependencies.

Async all the way is the answer, although various frameworks still don’t offer async hooks. Recently I ran into this for example trying to write an async validator in blazor, but that’s not possible and you have to work around it [1].

C# 5 introduced async/await almost 12 years ago. And we’re still not “async all the way”.

[1]: https://github.com/dotnet/aspnetcore/issues/40244

This approach to organizing middleware enhances code readability, maintainability, and reusability. By following this encapsulation pattern, you're adhering to best practices in ASP.NET Core development, ensuring your application remains well-organized and scalable.

🌟.NET 9 Preview 2 ➡️.NET 9 Preview 2 Discussion ➡️ASP.NET Core updates in .NET 9 Preview 2 ➡️ASP.NET Core updates in .NET 9 Preview 2 Release Notes ➡️EF Core updates in .NET 9 Preview 2 ➡️.NET Aspire preview 4 - .NET Aspire

https://github.com/dotnet/aspnetcore/issues/50643

Even if you look at Microsoft’s by far most popular GitHub project, they’re still only half as big as SupaBase. If you believe “the SupaBase story”, SupaBase grew and became twice as large as Microsoft in 3 years. Below is their likes over time if you’re curious, together with a couple of additional “too good to be true” Silicon Valley projects.

https://github.com/dotnet/aspnetcore/issues/10117

if its like less than 30 items u can just use https://github.com/Blazored/LocalStorage

You store the token in local storage. This is a library that will give you access to that. Blazored

Blazored LocalStorage - for Tokens and Authentication Stuff

The library make use of Blazored LocalStorage for storing cache data.

I use a library called Blazored LocalStorage for the WASM project to store client side data like preferences and auth stuff. This, it seems, is not supported in MAUI. Although MAUI starts a web server, it does not store data in the 'browser'. Instead it uses an API called "Preferences" (Which is a pretty sweet interface, props MS) but now I find myself struggling how I can use one, or the other depending on the project.

I've built a few Blazor WASM apps and use Blazored LocalStorage to access it.

For Blazor, you need to either use a third-party library to set up INPC, or do this yourself. I do the latter. For example, I have a settings class. I use https://github.com/blazored/LocalStorage to store the settings in the browser, and set them up as a singleton.

If you only need key/value, I've been using this one. https://github.com/Blazored/LocalStorage