๐Ÿš€ Version 4.0.7 • 100% Quality Gates Compliant

.NET Base Class Library
Engineered for Modern C++

DotNetDupe brings the familiar elegance, developer productivity, and cohesive design of C# .NET APIs to high-performance C++17/20 applications with zero STL leakage, ABI stability, and strict quality constraints.

Explore Full API Reference → Read Comparison Guides Install from NuGet
190+
Public Headers
1,500+
Member Functions
≤ 15
Max LLOC / Method
100%
Test & Gate Pass

Namespaces & API Categories

Browse classes by category with direct links to the official C++ API reference.

DotNetDupe::System

Full-featured UTF-8/UTF-16 string manipulation with culture-invariant comparisons, formatting, splitting, search algorithms, and seamless conversions.

DotNetDupe::System

Exception-safe RAII reference-counted smart pointer with lock-free control blocks, strong/weak lifecycles, and NewShared() / NewUnique() factories.

DotNetDupe::System

Idiomatic C# .NET event delegate system with multicast subscription (+=, -=), member method binding, token-based unsubscription, and thread-safe dispatch.

DotNetDupe::System

High-precision date and time management with 100ns ticks, UTC conversion, Daylight Saving Time adjustment rules, and TimeProvider abstractions.

DotNetDupe::System::Collections::Generic

Pure library collections mirroring .NET BCL: List<T>, Dictionary<K,V>, HashSet<T>, PriorityQueue, Queue, Stack, SortedDictionary, and LinkedList.

DotNetDupe::System::Collections::Concurrent

High-throughput thread-safe and lock-free structures: ConcurrentDictionary, ConcurrentQueue, ConcurrentStack, ConcurrentBag, and BlockingCollection.

DotNetDupe::System::IO

Comprehensive stream and file system abstractions: File, Directory, Path, FileStream, MemoryStream, BinaryReader/Writer, and TextReader/Writer.

DotNetDupe::System::Net

Cross-platform networking primitives: Socket, TcpClient, TcpListener, UdpClient, HttpClient, HttpRequestMessage, HttpResponseMessage, and RestClient<T>.

DotNetDupe::System::Threading

Multi-threaded tasking and synchronization: Thread, ThreadPool, Task<T>, Monitor, Mutex, Semaphore, SemaphoreSlim, Auto/ManualResetEvent, and Lock.

DotNetDupe::System::Diagnostics

Sub-5ms process discovery, observable ProcessStreamer telemetry, ETW log reader, Windows/Linux system hardware metrics, and terminal session tracking.

DotNetDupe::WebAppCore

ASP.NET Core style micro-framework in C++: WebApplication, WebAppServer, HttpContext, ControllerBase, Dependency Injection, JSON serialization, and JWT auth.

DotNetDupe::System::Data::SqlClient

ADO.NET database access with parameterized queries, in-memory SQL parsing engine, and optional SQLite persistent database backend.

DotNetDupe::Extensions::DependencyInjection

Full Inversion of Control container supporting Singleton, Scoped, and Transient lifetimes, factory delegates, and hierarchical scoped resolution modeled after Microsoft.Extensions.

DotNetDupe::Extensions::Logging

Structured diagnostic logging framework with Console and rolling File providers, JSON/text formats, and automatic Console::Out redirection via LoggerTextWriter.

C# Simplicity with C++ Speed

Compare the elegance and conciseness of DotNetDupe APIs against standard C# .NET.

1. File I/O & Text Streaming

C# .NET Standard C#
// C# .NET
using System;
using System.IO;

var lines = File.ReadAllLines("app.log");
foreach (var line in lines) {
    if (line.Contains("ERROR")) {
        Console.WriteLine($"Found: {line}");
    }
}
DotNetDupe C++ C++17/20
// DotNetDupe C++
#include "System/IO/File.h"
#include "System/Console.h"

using namespace DotNetDupe::System;
using namespace DotNetDupe::System::IO;

auto lines = File::ReadAllLines("app.log");
for (const auto& line : lines) {
    if (line.Contains("ERROR")) {
        Console::WriteLine(String::Format("Found: {0}", line));
    }
}

2. Thread-Safe Event Delegates

C# .NET Event Model C#
// C# Event Handling
public class Worker {
    public event EventHandler Completed;

    public void DoWork() {
        Completed?.Invoke(this, EventArgs.Empty);
    }
}

worker.Completed += (sender, e) => {
    Console.WriteLine("Done!");
};
DotNetDupe Event Model C++17/20
// DotNetDupe Event Handling
#include "System/EventHandler.h"
#include "System/Console.h"

class Worker {
public:
    EventHandler Completed;
    void DoWork() {
        Completed.Invoke(this, EventArgs::Empty());
    }
};

worker.Completed += [](void* sender, const EventArgs& e) {
    Console::WriteLine("Done!");
};

3. Generic Collections & Dictionaries

C# .NET Collections C#
// C# Collections
var scores = new Dictionary();
scores.Add("Alice", 95);
scores.Add("Bob", 88);

if (scores.TryGetValue("Alice", out int val)) {
    Console.WriteLine($"Score: {val}");
}
DotNetDupe Collections C++17/20
// DotNetDupe Collections
#include "System/Collections/Generic/Dictionary.h"
#include "System/Console.h"

Dictionary scores;
scores.Add("Alice", 95);
scores.Add("Bob", 88);

int val = 0;
if (scores.TryGetValue("Alice", val)) {
    Console::WriteLine("Score: {0}", val);
}