C++ DLL Port from C# -- 3

@MuhammadUzair16

Hi I am a software engineer with over 16 years of experience building Windows native libraries, C#/C++ interop layers, and algorithmic ports where the output must match exactly rather than just be functionally close. I can review your existing C# DLL and test suite, map the public API carefully, then re-implement the same logic as a native C++ DLL in Visual Studio with the required exports, header, .lib, and solution structure. I will pay particular attention to calling conventions, data type sizes, string/buffer ownership, struct alignment, and P/Invoke compatibility so the DLL works cleanly from both unmanaged C++ and C#. My approach would be to first confirm the exported method signatures and target architecture, port the algorithms method by method, run the supplied tests against both versions, then deliver the DLL package with concise build/use instructions and any C++ design notes that matter. A couple of details I would like to confirm are whether you need x64 only or both x86/x64, and whether any methods pass arrays, strings, callbacks, or custom structs across the DLL boundary. Please contact me to discuss details.

@kamran2012

Good to see this project, I will port your C# DLL to a native C++ DLL in Visual Studio, keeping every public method name, parameter, and calling convention identical so it works both from unmanaged C++ and via P/Invoke without changing your existing C# consumers. On a similar algorithmic library port, matching the exported signatures exactly on the first pass eliminated a full round of interop debugging. I will structure yours the same way. Questions: 1) Do any of the C# algorithms use managed types like List or Dictionary that need a specific marshalling strategy on the C++ side? 2) Are you targeting x64 only, or do you also need a 32 bit build? Share the C# source and test suite and I will confirm the method count and timeline today. Ready to start whenever you are. Kamran

@brayanstiven5

Hola Puedo terminar eso en un día. Después de cenar, te llamaré.

@toriquldev123

Hello There! I’m Md. Toriqul Islam, and I’m excited to partner with you. I can dive into your project immediately. I’m a software developer with over 10 years of experience in C#, modern C++, Visual Studio, native DLL development, and interoperability. I understand you need to port your existing C# algorithm library to a native C++ DLL while preserving all public APIs, calling conventions, and behavior. The final solution will include a Windows DLL, LIB, header files, Visual Studio project, successful unit test validation, and seamless compatibility with both native C++ and C# through P/Invoke. I have experience with DLL development and cross-language interoperability. I am skilled in C++, C#, Visual Studio, Win32 DLLs, P/Invoke, native interoperability, and algorithm implementation. Approach: I'll first analyze the C# implementation and unit tests, map each public API, reimplement the algorithms in modern C++, preserve the original calling conventions and exported interfaces, validate behavior against your test suite, and deliver a clean, maintainable Visual Studio solution with complete build documentation. I’m ready to start immediately and would be happy to discuss your project. Feel free to share the C# source code and test suite. Looking forward to hearing from you. Best regards, Md. Toriqul Islam

@intelliresponse

As a veteran developer with over 13 years of programming experience, I am uniquely skilled in bridging the gap between C# and C++. Over my career, I have handled numerous projects that required the porting of algorithmic libraries, just like this one. Recently, I even completed an AI emergency caller project using Vapi and Twilio where interoperability played a crucial role. I'm confident that this experience will serve me well in comprehensively reviewing your existing C# source code, implementing every public method identically in modern C++ using Visual Studio 2026, and ensuring seamless integration via P/Invoke on both unmanaged C++ and C# fronts. To ensure we stay on track with deadlines let's break down the task: reviewing the codebase should take around a day if it's not excessively long; implementing should take about 2-4 days depending upon the intricacy; running tests to compare results is usually fast but due importance will be given to avoid discrepancies. But also keep in mind that giving me a reasonable flexibility in timeline can help me deliver my best work rather than working under unnecessary pressure . Together we can seamlessly navigate through this project and surpass your expectations just as I have done before.

@craigd43

As a seasoned developer with years of experience in both C# and C++ programming, I'm well-suited for the task of porting your algorithmic library. My primary goal is to ensure that the existing logic and functionality are seamlessly transformed into C++, while preserving the code's stability and mirroring its use from unmanaged C++ and from C# via P/Invoke. Having previously developed strategies that facilitate optimal interop between these two languages, I'm already equipped to anticipate and mitigate any potential challenges that may arise. In conclusion, my comprehensive understanding of your project requirements along with my shared commitment to delivering high-quality code within given timeframes make me an ideal fit for your needs. Let's collaborate on this undertaking where my expertise will ensure a successful transition to a native C++ DLL whilst retaining all functionality and inter-operability.

@AndrewJSMAN

I’ve ported algorithmic libraries from C# to native C++ multiple times, including exact API-preserving DLL exports with P/Invoke compatibility. This is a direct match—C# logic to modern C++ with identical signatures, calling conventions, and test validation. I’ll start by analyzing the C# source and test suite, then implement the C++ version in a clean VS 2022 project using `__declspec(dllexport)` and `__stdcall` for consistency, ensuring unmanaged/C# interop out of the box. Build artifacts (DLL/.lib/header) will be delivered with minimal build notes highlighting memory management choices and ABI stability. Deliverables include passed unit tests and a short design note on edge cases handled. Available to start immediately.

@nintysix96

Rough numbers above are placeholders for now. We'll nail down the actual price and timeline once we've looked at the C# source together. Looks like you've got a working C# DLL with custom algorithms and you need an identical native C++ version that plays nicely on both sides of the managed/unmanaged boundary. The tricky part with this kind of port isn't the logic itself, it's getting the calling conventions, type marshalling, and __declspec(dllexport) signatures right so P/Invoke from C# behaves exactly like the original. That's the piece most people get wrong. Here's how we'd approach this: - Source review: We go through every public method in the C# source and map out the types, ref/out parameters, and any .NET-specific behaviour (exceptions, structs, strings) that needs a clean C++ equivalent before we touch a line of code. - Core port: Rewrite the algorithm logic in modern C++ (Visual Studio 2022/2026), keeping method names and parameter order identical. Where C# leans on managed types like string or List, we'll use straightforward C-compatible alternatives (const char*, plain arrays) that P/Invoke can handle without gymnastics. - Export layer: A clean extern "C" export block in the header with matching .lib, so unmanaged C++ callers link against it normally and C# can use DllImport with no extra wrappers. - Test pass: Run your unit test suite against the new DLL and diff results against the C# version until they match exactly. Any edge-case divergence gets flagged with an explanation. - Docs: Short build instructions (VS solution, build configs, any runtime dependencies) and a note on every C++-specific design choice we made. After a quick look at the source and test suite, we'll send a proper proposal with a firm timeline and price. Want to jump on a short call or share the C# source so we can give you an accurate estimate? Best, 96 Studio

@mundadiya

With a strong background in C# and C++, I understand the need to port your existing C# DLL to a native C++ DLL in Visual Studio, ensuring seamless interoperability. My experience in similar projects involving algorithmic libraries and interop considerations equips me to meet your requirements. How critical is the adherence to the current library's behavior during the transition? Regards, mundadiya

@gianmput15

❤️❤️❤️Hi, I respect your benefit and do my best!❤️❤️❤️ ⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐ ✔ Review and re-implement the C# DLL source code in modern C++ (Visual Studio 2026) ✔ Preserve public method names, parameters, and calling conventions ✔ Produce a Windows DLL, .lib, header file, and matching Visual Studio project/solution ✔ Ensure exported functions are consumable from unmanaged C++ and C# via P/Invoke ✔ Run and pass the supplied unit tests ✔ Deliver concise build instructions and explain C++-specific design choices I have extensive experience porting algorithmic libraries between C# and C++, ensuring seamless interop and precise results. I'll deliver a high-quality C++ DLL that mirrors the original C# library's behavior. Do you have any specific requirements or considerations for the C++ implementation that I should be aware of? Best regards.

@tatumm17

I can port your working C# DLL to C++ while preserving the exact functionality of your custom algorithms. I have extensive experience translating complex algorithms between languages, ensuring consistency and performance. My background includes multiple projects where I successfully migrated libraries from managed to native code, maintaining stability and efficiency. I’ll focus on a careful code translation, rigorous testing, and seamless integration with any existing systems. Are there any specific performance targets or platform constraints I should consider?

@salahuddin1973

Hello I can deliver a native C++ DLL with the same logic as your existing C# DLL, ensuring seamless integration and functionality. I understand the importance of maintaining identical public methods, parameters, and calling conventions. I will review the provided C# source code and test suite to guarantee accurate replication. My approach involves re-implementing the public methods in modern C++ using Visual Studio 2026, while ensuring compatibility with both unmanaged C++ and C# via P/Invoke. I will produce a Windows DLL, .lib, header file, and a clean Visual Studio project, along with concise build instructions. Are you aiming for a direct translation of the C# code or would you like me to suggest potential optimizations for the C++ implementation? Similar work here: https://www.freelancer.pk/u/salahuddin1973 I am ready to start immediately and expect to deliver the completed project within 5-8 days, depending on the complexity of the algorithms and the speed of feedback. Best regards, Naufal

@chazcarey

I can port your C# algorithm library to a native C++ DLL while preserving behavior and interop compatibility. My approach: Review the C# source and supplied tests Map each public API to a stable native export Re-implement the logic in modern C++ Use explicit calling conventions and fixed-width types Handle strings, arrays, structs, memory ownership, and exceptions safely across the DLL boundary Build a C# P/Invoke test harness and unmanaged C++ test client Compare outputs against the original DLL and resolve any edge-case differences Deliverables: Native Windows DLL Matching .lib and header files Clean Visual Studio solution/project Passing unit tests C# P/Invoke examples Build and integration instructions Notes on any ABI or marshalling decisions Estimated timeline: 2-3days, depending on the number and complexity of exported methods. I have experience with C#, C++, Windows DLL exports, P/Invoke, ABI compatibility, debugging, and algorithmic code migration.

@lazarr4

Hello, I ported a C# math-heavy library to C++ for a client last year—kept the exact same method names and calling conventions, just swapped the runtime. The tricky bit was matching the floating-point precision under different compilers, but we sorted that with standardized build flags. I’d recreate the DLL in modern C++ with Visual Studio 2022, keeping the interface identical so the existing C# code still calls it via P/Invoke without changes. The main challenge will be replicating the C# algorithms’ behavior precisely in C++, especially around edge cases like NaN handling or overflow. I’ll document the build process step-by-step and note any C++ quirks that could affect interop. You’ll get a clean solution folder with the .lib and header, ready for integration. If the unit tests fail at first, I’ll adjust the C++ logic until the outputs match the C# version exactly. Thanks, Lazar.