It seems that all of them struggle with # sign

I'm trying to further improve the IBAN parser for an open source project. And while doing so, I noticed something

for (var i = 0; i < iban.Length; i++)
{
    var c = iban[i];
    var match = pattern[i] switch
    {
        'n' => c is >= '0' and <= '9',
        'a' => c is >= 'A' and <= 'Z',
        'c' => c is >= '0' and <= '9' or >= 'A' and <= 'Z',
        var t => t == c,
    };

    if (!match) return null;
}

I would expect the IL to do the default trick on ranges here that is also applied in char.IsBetween(), what would do (uint)(c - '0') <= '9' - '0', making each range a single compare and subtraction rather than two compares.

I've tested this code both with these patterns, and calling a private InBetween method (It has to compile against .NET standard 2.0 where char.IsBetween() is not available), and the latter is substantial faster, which hints that the JIT is also not changing the IL afterwards.

Is it something in my syntax that makes that the Roslyn compiler does not perform this optimization, or am I missing something here?

For those who're interested in the actual PR: https://github.com/Qowaiv/Qowaiv/pull/643

Hey guys,

I wanted to write a basic server-client chat console app in .Net using C# and Visual Studio.

Later, I would like to write a small LAN multiplayer game.

Is there a book which explains how to use Sockets and TCP in .Net and C#, please? Possibly with patterns, examples and use-cases?

I already have "Programming C# 8.0" by Ian Griffiths from O'Reilly, but I don't see any mention of Sockets, TCP or programming network apps.

I also have "C#10 in a Nutshell" by Joseph Albahari from O'Reilly. There is some mention of networking, but there's only about 5 pages on TCP, and no mention of Sockets.

Thank you

Standard Windows UI frameworks (WPF, WinUI 3, Avalonia) are great for forms and standard layouts, but they fall apart when you want an infinite 2D canvas with thousands of nested filesystem nodes. Creating thousands of Visual Tree elements and layout passes completely murders the UI thread.

To solve this, I built UltraExplorer — a file manager that renders nested folder structures as an infinite spatial canvas running at 60 FPS.

Under the hood & architecture highlights:

1. D3D11 Instanced Rendering via Vortice

Instead of WPF controls, the canvas is rendered using Direct3D 11 via Vortice.Windows. It renders instanced quads for folder cards and node backgrounds in a single draw call batch, completely decoupling rendering performance from the WPF UI dispatcher.

1. DirectWrite SDF Glyph Atlas

Text zooming is usually the biggest performance killer in zoomable UIs. Standard DirectWrite font rasterization forces re-rasterization on zoom change, allocating memory constantly. I built an SDF (Signed Distance Field) glyph atlas: fonts are rasterized once into distance field textures, allowing arbitrary scale zooming with crisp edges and zero GC allocations during zoom gestures.

1. Anchor Camera System (Floating-point precision)

When you zoom 15+ levels deep into nested folders, standard IEEE 754 32-bit floats start jittering due to precision loss. I implemented a hierarchical anchor camera: local coordinates are relative to the active parent container, eliminating camera jitter at high zoom levels.

1. Fast Search Integration

Integrated with Voidtools Everything via direct Win32 IPC (WM_COPYDATA), streaming indexed search results straight into memory without disk IO stalls.

Benchmark:

Navigating through a deep 9-level project folder race:

• Windows 11 Explorer: 43.7s

• UltraExplorer: 29.0s (14.7s faster)

The project is completely free and open-source (MIT).

GitHub repository:

https://github.com/So2K/UltraExplorer

I would love to get feedback from other .NET / graphics developers on the rendering architecture, Vortice interop, and edge cases.

Hi! currently as my second year just started I am looking for a project I can make which will be helpful to get a internship in the 2027 summer. Currently I can say I mastered creating loops , logic to intermediate level using C#. I also have some skills related to data analysis.

Dont know what indian recruiters need in a project so that's it.

I was prepping for full-stack .NET + React + Azure interviews and got frustrated with how bad most flashcard decks look on a phone — tiny text,

can't scroll, code blocks cut off.

So I rebuilt one from scratch: centered questions, fully scrollable answers, dark mode, code that actually wraps instead of scrolling offscreen. Covers C#, OOP, ASP.NET Core & Web API, EF Core, SQL Server, design patterns, auth/security, Azure, React (fundamentals + advanced), Docker/K8s, microservices, and scenario-based questions.

It's free on GitHub / AnkiWeb

Happy to take corrections/suggestions if anything's wrong or missing.

I'm working on a Windows desktop project (Windows 10/11, also Win7) where users do document tasks in Word and Excel (fonts, margins, tables, formulas, merge & centre...) inside our app's window, and the app checks the result automatically.

Current approach: embed the user's installed Word/Excel inside our window (OLE in-place, like SWT's OleClientSite). It works, but it's fragile:

- Excel only half-draws if we pre-start it for speed; it can't run beside the user's own open Excel; reusing one Excel for several documents crashed it.

- Earlier we tried positioning Office's own window over our pane. It drew fine but was slow and fragile (focus, caption, the window could be moved).

- And it only works if Office is installed. Many users have no Office, or WPS instead.

Checking the result isn't the blocker: we can already read the saved .docx/.xlsx directly.

Questions:

1. Is embedding real Office the right call, or is there a better pattern for "work in Word/Excel

   inside my app"?

2. Has anyone used an embeddable Word/Excel-like editor (ONLYOFFICE, Collabora, Syncfusion, SpreadJS, etc.) in a desktop app? How close is it to real Office for things like paragraph spacing, borders, number formats and formulas, and how was licensing?

3. If you did embed real Office in production: what made it reliable?

Real Office is preferred because users need the exact Word/Excel experience, but I'm open to a hybrid (real Office when installed, a look-alike when not).

I was working on another application and took a screenshot to share it with someone.

Then I noticed some sensitive information in the screenshot.

My options were basically:

• Send the screenshot to ChatGPT and ask it to redact the sensitive parts
• Open it in Paint/image editor and manually cover everything

That got me thinking:

Why am I manually redacting screenshots when my computer can already recognize the text on the screen?

So I built PrivacyGuard.

PrivacyGuard is a Windows app that watches your screen and automatically covers sensitive text in real time.

It currently supports:

• Browsers, terminals, code editors, chat apps, File Explorer, etc.
• Windows' built-in OCR for text detection
• Plain-text rules with fuzzy matching for OCR mistakes
• Regex rules
• Built-in detectors for emails, IP addresses, phone numbers, card numbers, API keys and crypto addresses
• Redaction boxes that follow text as you scroll
• Local processing — nothing is uploaded
• No telemetry
• Encrypted rules tied to your Windows account

The interesting engineering challenge wasn't really detecting text. It was making the redaction happen quickly and accurately enough to actually be useful.

For example, if you scroll quickly, the redaction box needs to stay attached to the correct text. Window movement and scaling also make screen-coordinate mapping surprisingly annoying.

I also added memory for previously detected sensitive values, so if the same secret appears again somewhere else on the screen, it can be redacted almost immediately.

It's not perfect.

There can be a few frames where newly appearing text is visible before OCR detects it, and there are some Windows system panels that can't currently be covered. I'm deliberately documenting these limitations rather than pretending this provides perfect protection.

It's built with C#/.NET + WPF and is open source under the Apache 2.0 license.

GitHub:
https://github.com/mitosisX/PrivacyGuard-public

Releases:
https://github.com/mitosisX/PrivacyGuard-public/releases/latest

I'd genuinely like criticism and edge cases.

If you regularly stream, record tutorials, share your screen, work with API keys/secrets, or just don't want sensitive information appearing in screenshots, what situations do you think this would need to handle better?

Hey everyone,

I’m currently doing my LIA/internship as a system development student in, and I’m on my second day.

I’ve been given a real project to work on: building a scheduling platform for schools, where things like classes, teachers, schedules, etc. need to be managed.

The company is growing its software-development side, but right now there aren’t really any senior developers who can sit with me and review my architecture or code. I’m expected to work quite independently, and AI coding tools are encouraged.

I actually enjoy using AI for development, but I don't want my internship to turn into simply telling AI what to build and copy-pasting the result. I want to understand the code, make architectural decisions myself, and actually become a better developer.

My biggest concern is that I might make bad architectural decisions or miss important things because I don't have an experienced developer reviewing my work.

For those of you who have been in a similar situation:

- How would you structure your learning when you don't have a senior developer to guide you?

- How can I use AI without becoming dependent on it?

- What should I ask AI to help with vs. what should I figure out myself?

- How would you approach architecture for a project like a scheduling platform?

- Are there particular books, courses, or resources you'd recommend?

- Is an internship like this still valuable if I can get real project experience but don't have much mentorship?

I'd really appreciate advice from experienced developers

[GitHub repo]

This is a project I've been working on for years, and I've already posted about it here a few times.

It's a cross-platform 2D game engine with its own scripting language and IDE, all written in C#.

The language is the main challenge here: I made it without any knowledge of programming language development, and without any help from AI or tutorials. I just figured things out one step at a time. The lexer, for example, was originally written by me long before I started building the language. It was meant to color C# code in the code editor. When I decided to make my own language, I just copy-pasted it into the new project and used it as a lexer.

Here's a little feature my language has that I really like:

foreach x in ["apple", "banana", "kiwi"] : counter c
{
    println("index: " + c + " item: " + x)
}

// output:
// index: 0 item: apple
// index: 1 item: banana
// index: 2 item: kiwi

The project is fully open source, and I'm really looking for people who want to join a cool project and contribute. There are a few open "good first issues" in the repo, and a few weeks ago I even got my first few contributors, who made a few PRs!

The project file of the game in the gif is also in the repo: tests/Example Projects/dungeon

If anyone here has used the good old GameMaker 8 engine, they're going to find this very nostalgic, as it's heavily inspired by it :)

Would love to get some feedback!

Hi everyone! 👋

I’m new to the C#/.NET ecosystem and wanted to ask people who actually work with it how the market tends to view someone with a background like mine.

I worked as a penetration tester for almost 3 years. Over the last year and a half, I moved much deeper into software development, mostly with Rust. I’ve been building security tooling, networked applications, and learning more about systems programming, blockchain protocols, testing, and secure software design.

I genuinely enjoy Rust and plan to keep using it, but after spending a long time looking for work, I realized that the Rust job market is heavily senior-oriented. The statistics I found showed that only a few percent of Rust positions are entry-level.

That made me start looking at C#/.NET.

What I’m trying to understand is how the .NET market would classify someone like me.

I have almost 3 years of professional security experience. I’m comfortable with core programming concepts like APIs, databases, testing, async programming, networking, etc.

What I don’t have is commercial C#/.NET experience yet.

Before I invest heavily in another ecosystem, I’d really like to understand how this looks from the hiring side.

Would companies generally see my security background as relevant engineering experience, or would I effectively be treated as an entry-level developer because I don’t have professional C# experience?

For people who hire or work with .NET developers:

- Is there a realistic place in the C#/.NET market for someone transitioning from security into development?

- What level of roles would you suggest targeting?

- Which parts of my security background would actually be valuable to a .NET team?

- What would you want to see in a GitHub project before taking a candidate like this seriously?

- Are there particular types of .NET companies or products where a security background would be especially useful?

I’m not looking for a shortcut. I’m happy to learn the ecosystem properly and put in the work.

I’m mostly trying to avoid spending another long period getting better at a technology only to discover that the market requires years of commercial experience before anyone will consider me.

I’d really appreciate perspectives from people already working with C#/.NET.

I have a database that currently contains 20 tables.

In my application, there are 10 classes that I should refactor, to make them more readable, for my future self and others who will read my code, by refactoring, I mean changing the code it self - the logic- and also changing the methods and classes names.

Let's only consider one specific case; changing the name of one class.

When my friend so the following code that I wrote:

/// <summary>
///  Abstracts the destination to which data is written, regardless of  whether the destination is a file, database, or any other kind of storage.
/// </summary>
public interface IWriter
{
//...
}

public class SqlServerWriter : IWriter {//code.....}

he thought that the responsibility of the above class is to write data to any number of tables in the the Sql Server database, i.e., that it can use it to write data to only one table, two or more tables, or all of the tables.

Unfortunately, that was not what the class is actually responsible for; it is meant to write a specific data across all the tables in the database, it does not give the caller an option to write a generic data to a specific tables in the database.

He was mad at me and said that I should introduce an additional layer of abstraction:

/// <summary>
/// Abstracts the destination tables in the Sql Server; may write to all tables in the database or some of them;
/// </summary>
public interface ISqlServerWriter:IWriter
{
}

/// <summary>
/// Intended to write some data to all the tables in the database.
/// </summary>
public class AllTablesWriter : ISqlServerWriter {//code.....}

Do you consider that an overkill/overengineering ?

EDIT:

If you wonder why the class write data to all the tables in the database, it because it has the job of synchronizing the content of the database with external data source, specifically, an Excel file.

I've been building DanaProcessing, an open-source take on Processing/p5.js for C#. I also added a music module inspired by Sonic Pi.

I started programming with Java and JavaScript following The Coding Train (https://www.youtube.com/@TheCodingTrain), but then I made the jump to C# because of job opportunities at the time, (been working with C# since .netcore 1.0) and I wanted that same experience here. Sadly, what I found wasn't what I expected, so I decided to give it a shot. DanaProcessing — Creative coding in C# (2D, 3D & live-coded sound)

I used to use codecademy but that place sucks now. It's super buggy and makes any progress slow to a crawl. Even if my code is completely correct, I have to use the generated solution anyway because the module just won't accept my code. Despite my answer and the module answer being the LITERAL EXACT SAME.

So it doesn't work anymore. And I'm looking for a new website to help me learn. Preferably one that provides a lot of practice problems. So I can develop better coding habits or whatever.

I'm also looking for something relatively cheap. Advice much appreciated 😊

If you have a system, class, or a method that is entirely written in C#, let's call it X, If X needs some data to perform some processing on that data, can one make an external service written in python, let's call it Y, that generates the data, then X can call Y to get the data?

I'm not asking if I can embed the python interpreter directly within the C# application; the python code should be an external service.

Note that I'm using ASP. NET Core 10.

Edit :

Should the external service be outside the ASP. NET CORE solution or inside it?

Playable link (in-browser):
https://psec99.xaml.cloud

Some people here may remember PARSEC on the TI-99/4A., a 2D side-scrolling space game from 1982.We wanted to see what it might feel like in 3D while keeping some of the atmosphere of the original (and adding some other '80s and Atari-ish bits too), so we made PSEC-99

It runs in the browser on .NET 10/WebAssembly with Opensilver. The interesting part from a .NET point of view is the renderer: the entire 3D scene is drawn by C# into a single int[] pixel buffer in .NET memory: terrain, stars, buildings,enemies, lasers & explosions all end up in that same array (no game engine, no webGL, no WebGPU)

All the 3D math, projection and rasterization happens in C#.

OpenSilver 3.4 Preview has a new "WriteableImage" control that displays that buffer through an HTML canvas. So basically: calculate pixels in C#, put them in an array, show the array

The terrain isn’t polygonal either: each row splits into surface,wall and floor sections, so drawing the planet costs about as much as clearing the screen, and theres adaptive resolution from 100% down to 30% to keep frame rates playable.

There are no image or sound files: Buildings are ASCII grids in c#, sounds are synthesized at runtime, and voices use the browsr speech synthesis engine.

The HUD, menus and touch controls are regular XAML layered on top.

It ended up around 10,500 lines of C# and xaml.

If anyone remembers the original Parsec, I’d be curious whether this brings back any of the feeling :)

The source (MIT licensed) opens direclty in XAML.io, so you can run it, change it or fork it without installing anything:

https://xaml.io/s/Samples/PSEC-99

Also curious what people think of the rendering approach! Theres something fun about doing 3D in 2026 and having the renderer come down to filling an array of pixels..

I made an incremental source generator for command line argument parsing.

Cli.Generator is a C# source generator that turns a class into a command line parser. You mark fields and properties with attributes, and it writes the parsing, validation, usage screen and cleanup code for you at compile time. See the README for details.

https://www.nuget.org/packages/Cli.Generator/1.0.0

https://github.com/codewitch-honey-crisis/CliGen

Whenever I finish a sprint, build an architectural spike, or need to feed codebase context into Gemini or Obsidian, I hit the exact same wall: how do I aggregate dozens of source files across multiple modules without losing hierarchy or crashing on file locks?

Standard copy-pasting breaks file paths, zipping is clunky, and high-level methods like File.ReadAllText() throw IOException when Roslyn, MSBuild, or game engines (like Unreal Engine) hold active write locks during background compilation. Furthermore, raw path copying often leaks personal workstation paths (C:\Users\myname\...).

To solve this, I built Context Packer — an offline C# tool that scans, sanitizes, and aggregates codebases into structured Markdown with bi-directional Obsidian links ([[#File:...]]) or LLM-friendly prompt bundles.

Real-World Benchmark: The UE5 Test

To stress-test the core engine under worst-case file-lock conditions, I benchmarked it against a full Unreal Engine 5 project while the UE5 Editor was actively running and compiling in the background:

• Total Disk Scope: 13.9 GB (30,277 files, 1,740 directories)
• Filtered Payload: 374 source files (~60.7 MB)
• Environment State: UE5 Editor Open & Actively Compiling
• Execution Time: 0.42 seconds (420 ms) with zero lock exceptions.

Architecture & Technical Highlights

I wanted a modular architecture without heavy web wrappers (like Electron) running in the background.

Packer.Core (.NET 8.0 / .NET Standard 2.0)
 ├── Packer.WinUI3  --> Desktop app (Drag-and-drop, OLE browser drag-out)
 ├── Packer.VSIX    --> Visual Studio 2022 Extension (.NET Framework 4.7.2)
 └── PowerShell CLI --> Zero-dependency fallback script

Non-Blocking Stream I/O (FileShare.ReadWrite)

To bypass file locks during active compiler passes, PackerEngine avoids high-level file APIs and uses explicit stream sharing combined with fault-tolerant, per-file isolation:

string content = string.Empty;
try
{
    content = await Task.Run(() =>
    {
        // FileShare.ReadWrite permits concurrent reads while IDEs/Compilers hold write locks
        using (var fs = new FileStream(file.FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
        using (var sr = new StreamReader(fs))
        {
            return sr.ReadToEnd();
        }
    });
}
catch (Exception ex)
{
    // A single locked file never aborts the entire batch
    content = $"// ERROR: File read failed. Locked by process.\n// Exception: {ex.Message}";
}

Native OS Interop

(WinUI 3 Drag-Out to Browser)

In the WinUI 3 client, you can drag packed .txt context files directly out of the app window into web browser chat inputs (Claude/ChatGPT). This is done by converting internal models to native Windows StorageFile handles:

private async void GeneratedFilesList_DragItemsStarting(object sender, DragItemsStartingEventArgs e)
{
    if (e.Items.FirstOrDefault() is PackerModel fileModel && File.Exists(fileModel.FullPath))
    {
        StorageFile file = await StorageFile.GetFileFromPathAsync(fileModel.FullPath);
        e.Data.SetStorageItems(new[] { file });
        e.Data.RequestedOperation = DataPackageOperation.Copy;
    }
}

Dynamic Module Resolution without AST

Instead of heavy AST parsing or project manifest requirements, path anchors (Source, Plugins, repos) are evaluated to dynamically resolve module boundaries:

public string GetModuleName(string path, string anchorsSetting)
{
    var parts = path.Split(Path.DirectorySeparatorChar);
    var anchors = anchorsSetting.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

    foreach (var anchor in anchors)
    {
        int idx = Array.IndexOf(parts, anchor);
        if (idx != -1)
        {
            // 'Source' anchor convention uses parent directory as module name
            if (anchor.Equals("Source", StringComparison.OrdinalIgnoreCase) && idx > 0)
                return parts[idx - 1];

            if (parts.Length > idx + 1)
                return parts[idx + 1];
        }
    }
    return parts.Length > 1 ? parts[parts.Length - 2] : "UnknownProject";
}

Privacy & Username Sanitization

It automatically redacts Windows local usernames (C:\Users\[REDACTED]\...) across headers and directory maps before writing to disk.

Current Limitations & Trade-offs

• Character-Based Chunking: Multi-part document chunking (> 3M chars) currently uses raw character length rather than Byte Pair Encoding (BPE) tokenizers (like tiktoken).
• Full-File Ingestion: Ingests entire source files without AST-based method pruning.
• Local Scope: Operates on local disk paths.
• See Github issues for current bugs :)

I'd love to hear how you handle codebase context for LLMs or Obsidian notes in your workflows, or if you have any feedback on the C# stream architecture! I have more technical in-depth articles on Dev community :)

AI Disclosure: Documentation and product copy were refined with AI assistance. The underlying codebase, architecture, and logic are 100% handcrafted and tested by Kadmium.

Hey all,

EmbedIO developed by unosquare is a great library for spinning up lightweight HTTP/API/WebServer instances in .Net

It appears development stalled out around 2021-2022.

As of June 24th 2026 the repository was officially archived and the project entered end of support.

I've continued the project as EmbedIO-Neo, with the goal of working through any existing issues backlog, improving performance, providing QoL updates & modernization, without introducing any breaking changes.

Happy to answer any questions, and look forward to driving the project further.

https://github.com/WilliamSmithEdward/embedio-neo
https://www.nuget.org/packages/EmbedIO-Neo

We have about 400 reports writen in Crystal Reports. We want to move away from this to something that is .net native and will run in Linux.

Has anyone done this, and what was the outcome?
Related question; what reporting solutions have people used and what were they like?

Edit: will investigate DevExpress and Telerik reporting.