DotNetDupe 3.0.0

DotNetDupe 🚀

Ever admired the elegance and developer-friendliness of .NET APIs? 🤔 While the C++ Standard Template Library (STL) is powerful, its learning curve can be steep. This project, DotNetDupe, bridges that gap! 🌉

Inspired by the clear and concise API design of C# .NET, DotNetDupe is a C++ library that brings a familiar, streamlined development experience to your C++ projects. ✨

We're starting with a foundational set of classes in the System and IO namespaces, offering a glimpse into the library's potential. Your contributions are highly welcome to expand its functionality! 🤝

A fun fact: While I personally crafted core components like Char, String, and Path (along with their tests), a significant portion of the remaining code was generated with the help of Gemini Code Assist. 🤖 This project serves as a unique playground for exploring how generative AI can accelerate development from scratch. 🚀

DotNetDupe aims to simplify C++ development by providing C#-like interfaces for common tasks, making your code more concise, intuitive, and a joy to write. 💖

Table of Contents 📚

• DotNetDupe 🚀
  • Table of Contents 📚
  • Project Overview 💡
  • Features ✨
  • Getting Started 🚀
    • Prerequisites 📋
    • Installation ⬇️
  • Cross-Platform Support 🌐
    • Building and Testing
    • Integration via NuGet
  • WSL Setup Guide (Windows) 🐧
    • 1. Install WSL
    • 2. Environment Provisioning
    • 3. Build & Test in WSL
  • Building and Running with NuGet in WSL 🐧📦
  • Usage 💻
  • STL vs DotNetDupe Comparison ⚖️
  • API Reference 📖
  • Project Status 🚧
  • Contributions 👋
  • CI/CD Pipeline 🚀
  • License 📄
  • Generated Content 🤖
  • Contact 📧

Project Overview 💡

The core objective of DotNetDupe is to bridge the gap between the power and performance of C++ and the ease of use and productivity offered by C# APIs. By providing C#-like interfaces for common programming tasks, DotNetDupe aims to:

• Simplify C++ Development: Reduce the boilerplate and complexity often associated with STL, making C++ more approachable for developers accustomed to higher-level languages.
• Enhance Readability: Promote cleaner and more readable code by adopting well-known C# API patterns.
• Boost Productivity: Accelerate development cycles by offering intuitive and efficient tools for common operations.

Features ✨

• C#-like API Design: Intuitive and familiar interfaces for common programming constructs.
• Exception Handling: Robust exception classes mimicking .NET's exception hierarchy.
• String Manipulation: Powerful String class with comprehensive methods for text processing.
• Path Utilities: Convenient functions for file system path operations.
• Time and Time Zone Support: Core classes like DateTimeOffset, TimeSpan, TimeZone, and TimeZoneInfo for accurate time management.
• Type System Enhancements: (Add more specific features as they are implemented, e.g., Object base class, IComparable, IClonable etc.)

Getting Started 🚀

Prerequisites 📋

• C++17 compatible compiler (e.g., MSVC, GCC, Clang)
• CMake (for building, if applicable)
• (Any other dependencies, e.g., Google Test for running tests)

Installation ⬇️

1. Clone the repository:

   git clone https://github.com/your-username/DotNetDupe.git
   cd DotNetDupe
   

2. Build the solution and generate NuGet package: Open a Developer Command Prompt for Visual Studio and navigate to the project root.

   msbuild DotNetDupe.sln /p:Configuration=Release /p:Platform=x64
   nuget pack DotNetDupe.nuspec -OutputDirectory nuget_packages
   

   This will build the DotNetDupe library and automatically create a NuGet package (DotNetDupe.3.0.0.nupkg) in the nuget_packages directory at the solution root.

3. Add local NuGet package source: To use the locally generated NuGet package, add the nuget_packages directory as a local NuGet source:

   nuget sources Add -Name "DotNetDupeLocal" -Source "D:\Personal\Projects\C++\DotNetDupe\nuget_packages"
   

   (Replace D:\Personal\Projects\C++\DotNetDupe with your actual solution root path.)

4. Install the NuGet package in your project: In your C++ project, you can now install the DotNetDupe package using the NuGet Package Manager or the command line:

   nuget install DotNetDupe -OutputDirectory <YourProjectDirectory> -Source DotNetDupeLocal
   

   (Replace <YourProjectDirectory> with the path to your project where you want to install the package.)

5. Integrate into your project: Once installed, ensure your project's .vcxproj file is configured to link against the DotNetDupe.lib and include its headers. The NuGet package's .targets file should handle most of this automatically.

Cross-Platform Support 🌐

DotNetDupe is designed for high portability and officially supports Windows (via MSVC/MSBuild) and Linux (via GCC/Clang/CMake).

Building and Testing

Integration via NuGet

DotNetDupe is distributed as a multi-platform NuGet package. It contains native binaries for:

• win-x64 (DotNetDupe.dll)
• linux-x64 (libDotNetDupe.so)

When you add the NuGet package to your project, the appropriate binary is automatically selected based on your target platform.

Note for Linux Users

On Linux, NuGet packages are typically managed via dotnet CLI or integrated into CMake projects using tools like vcpkg or by manually extracting the shared library (.so) and headers from the .nupkg (which is a ZIP file).

Example manual extraction:

unzip DotNetDupe.nupkg -d dotnetdupe_lib
# Use dotnetdupe_lib/include for headers
# Use dotnetdupe_lib/runtimes/linux-x64/native/libDotNetDupe.so for linking

WSL Setup Guide (Windows) 🐧

For Windows developers who want to build and test for Linux locally, we recommend using the Windows Subsystem for Linux (WSL).

1. Install WSL

If you haven't already, install Ubuntu via PowerShell:

wsl --install -d Ubuntu

2. Environment Provisioning

Inside your WSL terminal, install the C++ build chain:

sudo apt-get update
sudo apt-get install -y build-essential cmake

3. Build & Test in WSL

Navigate to your project root (e.g., /mnt/d/Projects/DotNetDupe) and run:

# Create build directory
mkdir -p build-wsl && cd build-wsl

# Configure and Build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build .

# Run Tests
ctest --output-on-failure

4. Running WSL Commands from PowerShell

You can also build and test for Linux directly from a Windows PowerShell terminal without manually entering the WSL shell:

# Create build directory
wsl -d Ubuntu -- bash -c "mkdir -p build-wsl"

# Configure
wsl -d Ubuntu -- bash -c "cd build-wsl && cmake .. -DCMAKE_BUILD_TYPE=Release"

# Build
wsl -d Ubuntu -- bash -c "cd build-wsl && cmake --build ."

# Run Tests (via CTest)
wsl -d Ubuntu -- bash -c "cd build-wsl && ctest"

# Run Tests (direct execution)
wsl -d Ubuntu -- bash -c "cd build-wsl && ./DotNetDupeTests"

# Run Demo Application
wsl -d Ubuntu -- bash -c "cd build-wsl && ./DotNetDupeDemo"

Building and Running with NuGet in WSL 🐧📦

This section describes how to use the pre-compiled NuGet package to build and run the DotNetDupeDemo application in a WSL environment.

1. Extract the NuGet Package

The .nupkg file is a ZIP archive. Extract it to a local directory (e.g., DotNetDupe_NuGet) using PowerShell:

Expand-Archive -Path "nuget_packages\DotNetDupe.3.0.0.nupkg" -DestinationPath "DotNetDupe_NuGet" -Force

2. Configure and Build in WSL

Use CMake with the USE_NUGET option enabled and point NUGET_PATH to the extracted directory. WSL automatically handles the path mapping for Windows drives.

# Configure
wsl cmake -S . -B build-wsl -DUSE_NUGET=ON -DNUGET_PATH="./DotNetDupe_NuGet"

# Build the Demo Application
wsl cmake --build build-wsl --target DotNetDupeDemo

3. Execute in WSL

Run the demo application directly from PowerShell via wsl:

wsl ./build-wsl/DotNetDupeDemo

Usage 💻

Here are some quick examples of how to use DotNetDupe:

#include <iostream>
#include "DotNetDupe/String.h"
#include "DotNetDupe/Path.h"
#include "DotNetDupe/BasicException.h"
#include "DotNetDupe/TimeZoneInfo.h"

int main() {
    // String Example
    DotNetDupe::System::String greeting = _T("Hello");
    DotNetDupe::System::String name = _T("World");
    DotNetDupe::System::String message = greeting + _T(", ") + name + _T("!");
    std::wcout << message << std::endl; // Output: Hello, World!

    // Path Example
    DotNetDupe::System::String fullPath = DotNetDupe::System::IO::Path::Combine({_T("C:\\"), _T("Users"), _T("document.txt")});
    std::wcout << L"Combined Path: " << fullPath << std::endl;

    // TimeZone Example
    DotNetDupe::System::TimeZoneInfo localTz = DotNetDupe::System::TimeZoneInfo::Local();
    std::wcout << L"Local TimeZone: " << localTz.GetDisplayName() << std::endl;

    // Exception Example
    try {
        throw DotNetDupe::System::BasicException<TCHAR>(_T("Something went wrong!"));
    } catch (const DotNetDupe::System::BasicException<TCHAR>& e) {
        std::wcout << L"Caught exception: " << e.What() << std::endl;
    }

    return 0;
}

STL vs DotNetDupe Comparison ⚖️

DotNetDupe is designed to be more intuitive and less verbose than the standard C++ STL.

• General Comparison Guide: Covers Strings, Collections, Timing, etc.
• Threading Comparison Guide: Detailed comparison of thread synchronization primitives.

Sample Client and Test Code 🧪

The repository includes DotNetDupeDemo (a sample console application) and DotNetDupeTests (unit tests) projects. These projects demonstrate how to integrate and use the DotNetDupe library. You can refer to their .vcxproj files for examples of how to configure your own projects to consume the DotNetDupe NuGet package.

API Reference 📖

For detailed information on the available classes, methods, and their usage, please refer to the comprehensive API documentation for each class.

Namespace: DotNetDupe::System

Classes

Exceptions

Interfaces

Namespace: DotNetDupe::System::Collections::Generic

Classes

Namespace: DotNetDupe::System::Diagnostics

Classes

Namespace: DotNetDupe::System::Text

Classes

Namespace: DotNetDupe::System::IO

Classes

Exceptions

Interfaces

Namespace: DotNetDupe::System::Threading

Classes

Exceptions

Project Status 🚧

DotNetDupe is currently under active development. We are continuously working on expanding the API coverage and improving stability.

Contributions 👋

Contributions to the DotNetDupe project are highly welcome! Whether it's bug reports, feature requests, code contributions, or documentation improvements, your help is invaluable. Please refer to GitHub's general contributing guidelines for more information on how to get started.

CI/CD Pipeline 🚀

This repository uses GitHub Actions to automate the build, test, and release process.

Workflow Details

• Build & Test: Every push to main and all pull requests trigger a full build (Debug & Release) and execution of all unit tests.
• NuGet Release: Pushing a tag (e.g., v1.0.0) triggers the creation and publishing of the NuGet package to nuget.org.

How to Release

1. Update the version in DotNetDupe.nuspec.
2. Commit and push the changes.
3. Create and push a new tag:

   git tag v1.0.0
   git push origin v1.0.0
   

   Note: Requires NUGET_API_KEY to be set in GitHub repository secrets.

License 📄

This project is licensed under the MIT License. See the LICENSE file for details.

Generated Content 🤖

This project is a unique blend of manual craftsmanship and AI-powered development. While the initial core components were meticulously crafted by hand, the majority of the remaining code, including many classes, methods, and their corresponding unit tests, were generated with the assistance of Gemini, a large language model. This approach highlights the potential of generative AI in accelerating software development from scratch.

Contact 📧

For questions or support, please open an issue on the GitHub repository or contact sudheeshps@gmail.com.