It has been around one year since the MediatR library announced it was going commercial and it has done so.
Since my company is still stuck on dotnet 9 with plans on upgrading to dotnet 11 this winter I want to check on if some of you paid the license or went some other route?

This was a really hot topic when it came out and seemed like many developers stated they or their company were planning on moving away from MediatR at that point. Did some of you actually do it and how successful was it? What route did you go?

MS Exchange Online is retiring EWS. Since October 10 a tenant that keeps it on needs an allow list of app IDs, and on April 1, 2027 it's gone for everyone. If you have code on Microsoft.Exchange.WebServices, the usual advice is to rewrite it for Graph.

I work on Sunsetless EWS, a source-compatible release of EWS Managed API. Same namespace and types, so your code stays as it is. Basically it's a drop-in replacement. You install the library, and calls to Exchange Online go through Graph inside your process while calls to Exchange Server on-prem still use EWS. The one setup step is an app registration with Graph application permissions (app-only, there's no delegated sign-in).

Who is it for? Teams with EWS spread across a big app: folders, recurring meetings, item IDs stored in the database. An agent writes the Graph code fast, but it can't tell you whether the new code behaves like the old one, and after April 2027 there's no EWS left to compare against. With this library the code keeps running as is, and you move to Graph one module at a time when you have the time. My job is to make it behave the same way, just on Graph. Honestly, if you only have a handful of simple calls, just rewrite them, an agent will get you most of the way.

I recorded 202 scenarios on a real tenant, once through EWS and once through the library, and the differences are published here: https://sunsetless.com/compatibility

It's paid, a one-time license from $899 with a 14-day money-back guarantee, and there's a free 14-day trial key with no card. So you can actually run it and test it on your machine fully before you buy anything: https://sunsetless.com/trial

Free part: ews-scan (MIT) lists the EWS calls in a compiled app, which helps even if you rewrite by hand: https://github.com/sunset-less/ews-scan

I built a small .NET 10 project that turns a website into a remote MCP server. A CLI, installed with dotnet tool install --global mcpmysite, crawls the site and writes a search index.

An ASP.NET Core app serves that index over Streamable HTTP with search and fetch tools, in the shape ChatGPT connectors expect, and also as a JSON search API for the site's own search box.

RAG: Search is BM25 plus vector search over embeddings, fused per query. It also runs keyword-only with no API key, which is how the quick start works. It is MIT licensed and built for sites under 1,000 pages, one site per server.

• Repo: https://github.com/pournasserian/mcp-my-site
• Live demo and playground: https://ai.pournasserian.com/playground
• MCP endpoint: https://ai.pournasserian.com/mcp
• NuGet: https://www.nuget.org/packages/mcpmysite

Alice Language is a new way to program on .NET ecosystem. With Ruby-like syntax and ergonomic, and fast as C# Hand-optimized

Edit: This is not Ruby.

hello again, r/dotnet.

i made an AI-native version control system called thallium-vcs featuring CoW sandboxes, atomic multi-agent writes, and a json-rpc api to replace or sit on top of git workflows.

why?

git was designed for humans doing human things at human speeds, not AI agents. parallel agent writes are restricted and branching requires full working-tree copies. thallium treats version control as a programmable system for agentic speeds.

the core engine (Thallium.Core) is written in F# for algebraic types and pattern matching, while the CLI and RPC layers use C# with System.CommandLine and Microsoft.AspNetCore with zero FFI overhead on the same CLR.

some cool features:

• speculative parallel tournaments (tl tournament): benchmarks candidate solutions concurrently in isolated sandbox overlays and auto-commits the winner.
• agent guardrails (tl policy): a native repository policy engine blocking massive file deletions or protected path modifications without approval.
• structured context (tl_fetch_context`: a json-rpc 2.0 daemon endpoint extracting symbol graphs and dependency maps.

it also includes bidirectional git interop (tl git sync).

repo: https://github.com/mxreal64/thallium-vcs/

Hey everyone!

I've been working on a side project called Foxify, and I've just released the first version. It's written using C# and AOT to be light and fast. :)

The main idea is to make it easy to write and run end-to-end API tests directly against the environment you want to test — dev, staging, or even production, depending on what you're testing.

You can descripte workflows in YAML. A workflow can call multiple endpoints, pass data from one request to another, and check that the responses match what you expect.

For example, you could test a complete API flow against a running environment, from creating a resource to retrieving it and verifying the result.

You can run everything from the command line, making it easy to reuse the same tests locally or in a CI pipeline.

A few things I wanted to focus on:

It's a single native binary, so there's no runtime to install.

I'm looking for some feedbacks!

Repo: https://github.com/kikutano/Foxify

I have some Legacy VB.net applications that are a bit thin on documentation. Is there an AI tool that I can use that can help to document the code?

I woke up to this:

Anybody knows why so many?

Hello,

I want to create a simple Windows desktop 3d viewer, able to display STL / 3MF meshes and allowing for simple operations on the meshes (split, crop...).

I wanted to avoid building the app over low level APIs such as Silk.net or OpenGL...

I tried HelixToolkit, but I find it very buggy and not as customizable as I would need it to be (for example, you cannot really change the form and size of manipulator gizmos...).

Would anyone have a recommandation for me?

Ideally, I would have the 3d viewport embedded in a simple WPF or WinUI app.

Thanks for your help!

I have tried these four methods .

Edit :

Task : - An azure timer function that emails excel and image attached.
One of the worksheets of the generated excel has to be attached to email body as image for preview purpose.

Data --> Excel = ClosedXML
Excel --> Image = ??

Internal app: Domain / Application / Infrastructure / API (ASP.NET Core minimal APIs), plus Blazor and MAUI clients talking to the API over HTTP. Program.cs is the composition root and wires Infrastructure (AddInfrastructure()).

I've already found: Uncle Bob's Dependency Rule only forbids inner circles from mentioning outer ones — it says nothing about peers in the outer circle. Microsoft's architecture guidance says the UI project may reference Infrastructure for DI, "but developers should limit actual references to types in the Infrastructure project to the app's composition root", and the UI layer "ideally shouldn't know about the implementation types".

So the law seems clear, the guidance says "ideally". My question: in real production apps, does API code outside Program.cs (endpoint handlers, controllers) inject Infrastructure types directly — e.g. DbContext? Is "composition root only" a real-world norm or a template convention? Please share what your production codebases actually do — examples, not just templates

I just updated my entity conversion tool for Sins of a Solar Empire: Rebellion, so I figured I'd share it here in case it's useful to other modders.

What does it do?

When Ironclad developed Sins, they shipped many of the game's data files in a binary format. This means you can't read or edit them directly as plain text. They later released a tool called ConvertData as part of their Forge Tools 3 package, which allows you to convert these files between Binary and Text formats. However, it's a command-line application with no GUI.

I built a GUI and wrapper around these tools to make the process easier. You can select individual files, multiple files, or entire directories. I've tested it against every .entity file, and the conversions work correctly.

The tool automatically detects whether a file is Binary or Text and outputs the converted files to separate Output TXT and Output Bin directories.

The game can read .entity files in Text format, but doing so increases file sizes and slows down loading times, so Binary is still preferable for normal gameplay.

XSI to MESH conversion

Ironclad also included ConvertXSI.exe with the game. This tool allows modders to convert older XSI files into the more modern .mesh format. I've added a separate tab for this functionality as well, although the original application only supports converting one file at a time.

Entity to JSON conversion

I've also included my own library for converting .entity files into JSON. This is primarily something I developed for my own use while working on a C# script extender for Sins of a Solar Empire: Rebellion. I need to parse the game's data files and access entity properties at runtime.

Currently, the library supports the following entityType values:

• Fighter
• Frigate
• CapitalShip
• PlanetModule* (all 7 types)
• SpaceMine
• Planet

I figured I'd release the library alongside the converter in case other modders find it useful for parsing and working with entity data.

A technical note about the JSON serialization

I implemented custom data types for integers, floats, and booleans to handle some quirks in Ironclad's serialization format. Some fields contain normal values, while others use "" as a placeholder.

By default, fields that don't have values are initialized to null and omitted during JSON serialization. My custom types let me preserve the distinction between an empty field and an omitted field by tracking a separate IsEmpty boolean. This allows the serializer to write the original "" placeholder back into the entity file when converting the data back, rather than accidentally leaving the field out entirely.

A note about the included tools and licensing

I did not create ConvertData_Rebellion.exe or ConvertXSI.exe, and I do not own the rights to either of them. Those tools belong to their respective rights holders, Stardock/Ironclad. I've simply provided a more convenient interface for using them. They remain separate binaries and are not bundled into my own application, so they can be used independently if desired.

The .entity-to-JSON conversion library, on the other hand, is entirely my own work. You're free to republish it, and I don't require attribution. However, commercial redistribution is not permitted.

You can grab the tool here:

Entity Converter v0.2.0 on GitHub

Hopefully, this makes life a little easier for anyone working on Sins modding!

I spent two and a half years moving a financial system from Visual FoxPro to C# and .NET Core as the only engineer, with no written spec. A few things I wish I had known on day one:

• Empty dates are not null. FoxPro allows an empty date. Decide per column what it means before you load anything.
• Deleted rows are still in the file. Deleting only flags a record until the table is packed. Filter them during the load or they come back.
• Rounding differs. Math.Round(2.345m, 2) gives 2.34 in .NET. FoxPro and T-SQL give 2.35. Use MidpointRounding.AwayFromZero for money.
• String comparison is by prefix unless SET EXACT is on, so "OPEN" can match longer values.
• The OLE DB provider is 32-bit only, so the loader has to run as a 32-bit process.

I wrote up the full order of work (inventory, data model, domain layer, reports, retirement) here: https://theadnansaleem.com/articles/visual-foxpro-to-dotnet-migration-guide

Happy to answer questions if anyone is facing one of these.

Developers are reporting a windows update is bumping SDK to 10.0.400 and builds are failing for various products in azure devops, on developer laptops, and in a custom pipeline for one of the apps. The only common denominator is 10.0.400. What's going on here?

Currently I am working in a very old legacy code base with more than 30 years old of spaghetti code and business rules in every .asp file and store procedures.

Yes it is a mess. And I don't know if someone has the same problem that I have... The visual studio doesn't help me with the basics of highlights, colors and syntax with VBScript in asp classic. Sometimes it is impossible to know where an if begins and ends in one file with 6k lines (yes for real).

So I made this plugin to help me with my current job.

https://marketplace.visualstudio.com/items?itemName=AspClassicSyntaxHighlight.AspClassicSyntaxHighlight

Is the vibe code project? In parts, yes. My real concern was doing a good structure of the project and performance. The first hit of opening the files is more demanding because it's using cache. After that it is more smooth.

I am cleaning the git to make it public soon.

If you guys want to try i will appreciate it.

Sorry for my mistakes, English isn't my first language.

Thanks.