Rule change

Hi there r/dotnet!

After the poll we had a couple of weeks ago, we have decided to update the self promotion rule.

New rule:
Any self-promotion posts where you are highlighting a product or library must:

be posted on Saturdays (New Zealand time (GMT+12 hours)).
be flaired with the new "Promotion" flair.
not be written by AI. (Put some effort into it if you want other people to check it out)
be restricted to major or minor release versions to prevent spamming (e.g., "v1.3")

Any promotion posts outside of those restrictions will be removed.



The results of the poll were pretty obvious with the vast majority of people wanting self-promotion posts restricted to a single day with flair, with even more wanting AI generated posts removed as well

https://preview.redd.it/cu16ue2u27mg1.png?width=862&format=png&auto=webp&s=cf0ad034eb2cfdcf7cfb1449d7d854d355c816b7



So, we're adding this rule as of now. Any posts that are outside of this rule will be removed.

We're also adding the rule around restricting versions to prevent people posting every little, tiny update to their libraries as a way of getting around spam rules.



If you have any thoughts or feedback, let us know below! Hopefully this rule change will be a positive for the community, but we can change it if it needs more tweaking in the future.


https://redd.it/1rgx9j4
@r_dotnet

I source-built the .NET 8 SDK on IBM POWER8 (ppc64le) — found a Y2K-style date overflow bug in Arcade SDK


Microsoft doesn't ship .NET for POWER. Fedora dropped ppc64le support years ago. So I built it from source on an IBM S822 running Gentoo Linux — 20 cores, 160 threads of POWER8. It took 7 patches. The juiciest one: the Arcade SDK generates FileVersion revision numbers from the current date using YY×1000 + MM×50 + DD. In 2026, this overflows the 65534 max for assembly version fields. CS7035 gets promoted to error by /warnaserror. Microsoft's own build infra literally cannot handle dates after mid-2025. Other fun finds: a private Azure DevOps NuGet feed (BuildXL) hardcoded in MSBuild's open source, and test projects requiring app host binaries for RIDs that don't exist. After the SDK was working, I compiled Jellyfin 10.9.11 on the same machine — media server running natively on POWER8 with 160 threads, serving 122 movies over NFS from ZFS storage. The whole thing was done in a live session with my AI assistant via Discord.



Full writeup: https://debene.dev/posts/dotnet-power8-what-microsoft-wont-ship/

Scripts & patches: https://github.com/felipedbene/dotnet-power8

https://redd.it/1rgtse1
@r_dotnet

Azure Data Studio retired today – My Replacement VS Code Extension: Fast Connections, Inline Editing, DB Diagrams & More

So today is literally the day – February 28, 2026 – Azure Data Studio is officially retired. No more updates, no security patches, Microsoft just pulled the plug after giving us over a year to migrate.

They've been saying for a while: switch to VS Code + the official MSSQL extension. VS Code is great in general, super extensible… but let's be real – for heavy SQL work the MSSQL extension still feels sluggish compared to how snappy Azure Data Studio was. It lags on bigger databases, IntelliSense can be hit-or-miss, and overall it just doesn't hit the same "quick & pleasant" vibe we loved in ADS.

I got tired of waiting for Microsoft to fix it, so I built my own open-source VS Code extension to try and bring back that fast, reliable ADS-like experience specifically for MS SQL Server / Azure SQL.

It's called MS SQL Manager (vsc-ms-sql-manager), and the main features right now are:

Ultra-fast connection management & object explorer
Inline data editing
IntelliSense & autocompletion that actually performs well (even on large DBs)
Clean results grid with export to CSV, JSON, Excel
Schema navigation + quick noscripting of tables/procs/views/etc.
Database Diagrams
Schema Compare between databases
Keeps everything lightweight – no random bloat from the broader VS Code world

Repo & install instructions: https://github.com/jakubkozera/vsc-ms-sql-manager



https://redd.it/1rh1iq9
@r_dotnet

Am I the only one who finds mobile testing genuinely demoralizing?

Six years in QA and last week I spent three hours debugging a test failure that turned out to be a 200ms animation delay on a bottom sheet ......Three hours like are you fr???

On web that whole investigation takes minutes, you open DevTools, you see exactly what happened, you fix it and move on and that's the gap I'm talking about. On web I feel like a professional. Fast feedback, reliable CI, and when something breaks the debugging experience actually respects your time but on mobile I'm reverse engineering why a login flow test failed on Android but passed on iOS even though the user journey is literally identical on both platforms, and I'm maintaining two completely separate suites just to cover that same flow.

The flakiness is what really gets me though like let me tell you something so we had a payment checkout test that failed roughly 1 in 6 runs nobody touched it for months because everyone assumed it was just a flaky test it turned out that it was masking a real race condition in the order confirmation screen that eventually made it to production that's what normalizing 15% flakiness actually costs you in practice.

I've looked at alternatives and everything shares the same core problems just wrapped differently and nothing fundamentally changes underneath.

So genuinely asking, is this a platform constraint, an investment problem, or have I just not found the right tool yet? Because that three hour animation debugging session is not an edge case for me, it's just a regular Tuesday.

https://redd.it/1rh8kft
@r_dotnet

.NET Memory Dump Analysis with DumpLinq
https://medium.com/@anders_pedersen/net-memory-dump-analysis-with-dumplinq-8a7a73f1c136

https://redd.it/1rh08a9
@r_dotnet

Postgres for everything, how accurate is this picture in your opinion?
https://redd.it/1rghux6
@r_dotnet

Offlining a Live Game With .NET Native AOT
https://sephnewman.substack.com/p/offlining-a-live-game-with-net-native

https://redd.it/1rgg12y
@r_dotnet

nugx.org A fresh, new nuget.org package explorer for dotnet community.

New to reddit. I built an alternative NuGet explorer: nugx.org (http://nugx.org/)

The default nuget.org (http://nuget.org/) is functional but discovering packages and understanding dependencies is harder than it should be. nugx.org (http://nugx.org/) adds better search, popularity signals, dependency graphs, and a cleaner UI.

I would love feedback from the community.

nugx.org (https://nugx.org/)



https://redd.it/1rh8jej
@r_dotnet

zerg - iouring networking library in C#

Quick links:

[Docs Website](https://mda2av.github.io/zerg/)

[Github Repository](https://github.com/MDA2AV/zerg)


zerg (ring zero) is a low level TCP framework built on liburing, requires Linux Kernel 6.1+

Designed for low level control over sockets, predictable performance and latency.


Implements IBufferWriter, PipeReader, Stream APIs.


Performance: io\uring benefits are less CPU usage, in average 40% less CPU power when compared with Unhinged (low level epoll C# framework).


A submission for TechEmpower was done to test in terms of throughput (requests per second) and latency, I would personally say however that io_uring does not seem to be better than epoll for TCP networking in these two metrics.




https://redd.it/1rgdyhj
@r_dotnet

SQLite Explorer a simple SQLite/PostgreSQL graphical DB client using .NET 10 and AvaloniaUI

Hello,

I designed an application using OpenCode and GLM-5 as the model. The application is an app that can connect to an SQLite or Postgres DB and perform queries and see the query results using a DataGrid (AvaloniaVirtualDataGrid) UI component that I developed in a previous session. So in a sense this app is a form of dogfooding for the previous project, the Virtualized DataGrid. Both projects required intense prompting and GLM-5 is not a fast model so it took more time than using a faster model. Strangely, GLM-5 identifies as Claude so that's what I put on the About box. Here is the link to the github repo:

https://github.com/tkleisas/SQLiteExplorer

Enjoy or hate!

https://redd.it/1rhjtdu
@r_dotnet

How do I become a “real” software developer? Feeling stuck despite learning .NET

Hey everyone,
I’m currently a Computer Science student and I’ve been learning .NET for a while. I’ve built some projects, and I actually enjoy it a lot. But lately, I’ve been feeling stuck.
Whenever I browse Reddit or see posts from engineers working in the industry, I get this mix of inspiration and… honestly, frustration. They seem to know and use so many technologies, and sometimes I feel like I’ll never catch up.
I know I can’t learn everything at once, but it makes me question myself: Am I good enough? Or am I falling behind?
I want to really become a strong software developer, not just someone who can copy and paste code or follow tutorials. I want to understand how systems work, write maintainable code, and actually solve real problems.
How did you get past this stage? How do you stop comparing yourself to everyone else and start feeling confident in your skills?
Any advice, personal stories, or guidance would really help.

https://redd.it/1rhm6w5
@r_dotnet

I built a pure-Swift unified SQL driver (MSSQL + PostgreSQL + MySQL + SQLite) on SwiftNIO — with a feature no other SQL library has

# Reddit Post — r/swift

Title:
> I built a pure-Swift unified SQL driver (MSSQL + PostgreSQL + MySQL + SQLite) on SwiftNIO — with a feature no other SQL library has

---

Hey r/swift 👋

I've been working on CosmoSQLClient-Swift — a Swift 6 database driver that connects to all four major databases through a single, unified async/await API, built entirely on SwiftNIO with no C libraries or FreeTDS.

GitHub: https://github.com/vkuttyp/CosmoSQLClient-Swift
Swift Package Index: https://swiftpackageindex.com/vkuttyp/CosmoSQLClient-Swift

---

### The flagship feature: JSON Streaming 🚀

This is something no other Swift SQL library does.

When SQL Server returns FOR JSON PATH results, it fragments the output at ~2033-character boundaries that don't align with JSON object boundaries. Most libraries buffer the entire response before doing anything with it.

I built a pure-Swift JSONChunkAssembler state machine that detects exact {...} object boundaries across arbitrary packet splits — so each complete JSON object is yielded the instant its closing } arrives:

// Yields one fully-formed object at a time — never buffers the full array
for try await product in pool.queryJsonStream(
    "SELECT Id, Name, Price FROM Products FOR JSON PATH",
    as: Product.self) {
    print(product.name) // arrives before the query even finishes
}

It works on Postgres and MySQL too:

// Postgres
for try await row in pgPool.queryJsonStream(
    "SELECT row_to_json(t) FROM (SELECT id, name FROM users) t") { ... }

// MySQL
for try await row in myPool.queryJsonStream(
    "SELECT JSON_OBJECT('id', id, 'name', name) FROM users") { ... }

And in Vapor, you can pipe it straight to a chunked HTTP response — first byte reaches the client before the query finishes:

app.get("products") { req -> Response in
    let response = Response()
    response.headers.contentType = .json
    response.body = .init(stream: { writer in
        Task {
            _ = writer.write(.buffer(ByteBuffer(string: "[")))
            var first = true
            for try await chunk in req.application.mssqlPool.queryJsonStream(
                "SELECT Id, Name, Price FROM Products FOR JSON PATH") {
                if !first { _ = writer.write(.buffer(ByteBuffer(string: ","))) }
                _ = writer.write(.buffer(ByteBuffer(bytes: chunk)))
                first = false
            }
            _ = writer.write(.buffer(ByteBuffer(string: "]")))
            _ = writer.write(.end)
        }
    })
    return response
}

---

### One API for all four databases

// Write once — runs on MSSQL, Postgres, MySQL, or SQLite
func getActiveUsers(db: any SQLDatabase) async throws -> [SQLRow] {
    try await db.query(
        "SELECT id, name FROM users WHERE active = @p1", [.bool(true)])
}

All four drivers conform to the same SQLDatabase protocol. @p1-style parameters work universally across all backends.

---

### Benchmark highlights

vs SQLClient-Swift (FreeTDS) — the library this replaces:
- Warm full-table query: 1.7× faster
- Warm single-row: 1.7× faster

vs ADO.NET (C# port, all warm benchmarks):
- CosmoSQL wins every single one — up to +16% on JSON queries

vs MySqlConnector (C# port):
- Cold connect: +16% faster
- Pool acquire: +24% faster

---

### What's included

- ✅ Native wire protocols — TDS 7.4, PostgreSQL v3, MySQL v10, SQLite3
- ✅ Swift 6 strict concurrency throughout
- ✅ Connection pooling for all four databases
- ✅ Transactions, stored procedures + OUTPUT params, multiple result sets
- ✅ Codable row decoding
- ✅ Windows / NTLM auth (MSSQL)
- ✅ Named instances (SERVER\INSTANCE)
- ✅ Bulk insert (BCP) for MSSQL
- ✅ Logical SQL dump / restore across all databases
- ✅ No FreeTDS, no C bridging, no external dependencies

There's also a C# / .NET port built on DotNetty if that's your world:

https://github.com/vkuttyp/CosmoSQLClient-Dotnet (published on NuGet as CosmoSQLClient.MsSql / .Postgres / .MySql / .Sqlite)

---

Happy to answer questions — especially around the JSON streaming internals or the TDS protocol implementation. It was a wild ride implementing NTLM auth and TLS-inside-TDS from scratch 😄

---

# Reddit Post — r/dotnet

Title:
> I built a pure-C# unified SQL driver (MSSQL + PostgreSQL + MySQL + SQLite) on DotNetty — beats ADO.NET on every warm benchmark and has a JSON streaming feature no other .NET library has

---

Hey r/dotnet 👋

I've been working on CosmoSQLClient — a .NET 10 database driver for all four major databases, built on DotNetty (NIO-based async networking) with wire protocols implemented from scratch — no ADO.NET network layer.

GitHub: https://github.com/vkuttyp/CosmoSQLClient-Dotnet
NuGet: dotnet add package CosmoSQLClient.MsSql

---

### The flagship feature: JSON Streaming 🚀

This is something no other .NET SQL library does.

SQL Server's FOR JSON PATH fragments output at ~2033-character boundaries that don't align with JSON object boundaries. Even Microsoft's own IAsyncEnumerable buffers the full result before yielding.

I built a JsonChunkAssembler backed by Utf8JsonReader + JsonReaderState that detects exact {...} object boundaries across arbitrary chunk splits — yielding each complete object the instant its closing } arrives:

// Typed streaming — each object arrives before the query finishes
await foreach (var product in conn.QueryJsonStreamAsync<Product>(
    "SELECT Id, Name, Price FROM Products FOR JSON PATH"))
{
    Console.WriteLine($"{product.Id}: {product.Name}");
}

In ASP.NET Core, just return IAsyncEnumerable<T> — the framework streams it as chunked HTTP automatically:

[HttpGet]
public IAsyncEnumerable<Product> GetAll() =>
    _pool.QueryJsonStreamAsync<Product>(
        "SELECT Id, Name, Price FROM Products FOR JSON PATH");

First byte reaches the client before SQL Server finishes the query. No buffering at any layer.

---

### One API for all four databases

// Write once — runs on MSSQL, Postgres, MySQL, or SQLite
async Task CreateUser(ISqlDatabase db, string name) =>
    await db.ExecuteAsync(
        "INSERT INTO users (name) VALUES (@name)",
        new SqlParameter("name", name));

---

### Benchmark results (BenchmarkDotNet, .NET 10, Apple M-series ARM64)

MSSQL vs ADO.NET (Microsoft.Data.SqlClient):

| Benchmark | CosmoSQL | ADO.NET | Winner |
|---|---|---|---|
| Warm full-table query | 589 µs | 599 µs | 🏆 CosmoSQL +2% |
| Warm single-row | 575 µs | 580 µs | 🏆 CosmoSQL +1% |
| Warm ToJson() | 612 µs | 729 µs | 🏆 CosmoSQL +16% |
| FOR JSON streamed | 565 µs | ❌ N/A | 🏆 CosmoSQL exclusive |

CosmoSQL wins every warm benchmark against ADO.NET.

MySQL vs MySqlConnector:

| Benchmark | CosmoSQL | MySqlConnector | Winner |
|---|---|---|---|
| Cold connect | 4.99 ms | 5.93 ms | 🏆 +16% |
| Pool acquire | 333 µs | 435 µs | 🏆 +24% |
| JSON streamed | 310 µs | ❌ N/A | 🏆 exclusive |

PostgreSQL vs Npgsql:

| Benchmark | CosmoSQL | Npgsql | Winner |
|---|---|---|---|
| Cold connect | 4.53 ms | 4.60 ms | 🏆 +2% |
| JSON streamed | 296 µs | ❌ N/A | 🏆 exclusive |

---

### What's included

- ✅ TDS 7.4, PostgreSQL v3, MySQL v10, SQLite3 — all from scratch
- ✅ Connection pooling (channel-based, health-checked, WarmUpAsync())
- ✅ Transactions, stored procedures + OUTPUT params, multiple result sets
- ✅ SqlClient-compatible API (new MsSqlConnection(connectionString))
- ✅ Named instances (SERVER\INSTANCE)
- ✅ Windows / NTLM auth (MSSQL)
- ✅ SqlDataTable with JSON, CSV, Markdown output
- ✅ Shared static IEventLoopGroup — cold connect in ~5ms (not ~1s)

Install just what you need:

dotnet add package CosmoSQLClient.MsSql
dotnet add package CosmoSQLClient.Postgres
dotnet add package CosmoSQLClient.MySql
dotnet add package CosmoSQLClient.Sqlite

There's also a Swift port for iOS/macOS/Vapor:

https://github.com/vkuttyp/CosmoSQLClient-Swift

---

Happy to answer questions — especially around the DotNetty pipeline, JsonChunkAssembler internals, or why warm Npgsql/MySqlConnector are still faster (binary protocol — that's next on the roadmap 😅).


https://redd.it/1rhmxlp
@r_dotnet

Rx.Net is great, but…

I’ve started using System.Reactive in my applications and it solves a number of dependencies I would otherwise have had to handle. It’s awesome, I think.

But (here’s my question), what are the drawbacks to using it? Is there a hidden cost that’s coming back to bite me later?

Obviously Rx.Net is hiding a lot of complexities under the hood and can introduce bad design and unpredictable behavior when abused, but is there anything else to be wary of?

https://redd.it/1rhpg6g
@r_dotnet

Looking for serious .NET study partner (Switch prep)

I’m a .NET developer with \~2 years of experience and currently preparing to switch to a better product-based company.

I’m looking for serious and consistent study partners so we can stay accountable, discuss concepts, and do mock interviews together.

Preferred:

Similar experience range (2–4 yrs)

From India (for timezone ease)

Willing to be consistent (this matters most)

If you’re in the same phase, comment or DM. Let’s grow together 🚀

https://redd.it/1rhrlly
@r_dotnet

Best practices for multi targeted NuGet package

Let's say I want to make a NuGet package, that has a dependency on a System.* package. Such as System.Text.Json.

I can multitarget my package so it has specific versions for .net 8/9/10 for example.

What is the best practice for defining the dependency?

Would you set the System.Text.Json to change with each target?

Would you just define the lowest common version, like ">= 8.0.0"

https://redd.it/1rhvpp3
@r_dotnet

Best practices for EF Core migrations in team setup

I recently onboarded a developer in my startup. The project is small enough that we eventually ended up both working on the database schema on two different PRs.


Initially, I sped through my development and merged my database changes before they started their own. Now they have started working on their PR and I know they already have their own migration worked on and applied locally, but I have to add some modifications to the model but I'm afraid of creating annoyances to the other dev.

Does EF Core supports applying unrelated migrations out of order? ChatGPT says no claiming each migration has its parent but I think it's hallucinating as I couldn't find any of the attributes it mentions.

Alternatively, what's the best way to handle a team working at the same time on the same DbContext?

Do you have any trick up your sleeve worth sharing?

https://redd.it/1rhv52o
@r_dotnet

Fresh .NET student, any advice?

I'm currently studying ASP.NET web core API, still in the very begining, but I have few questions:

1. Standard projects structure (l Domain, DTOs layers, etc.) are confusing me a little bit, is it okay to continue anyway? or should I grasp the full concept first?

2. Is it a good idea to not follow a certain linear course? I'm just using LLMs and Docs.

Note: I have a SWE background (4th year student), meaning I understand fundementals and basic concepts.

https://redd.it/1ri1lm8
@r_dotnet

someone posted something about a new app he made. a network app or something

I wanted to check it out and it said the post was removed. If you see this, send me a message. I want to check it out.


thanks

https://redd.it/1rieqfk
@r_dotnet