Wykorzystanie kodu C++ w C#

Przymierzam się do stworzenia edytora poziomów do Shadow Clones. Zamierzam użyć C# i Windows.Forms – wybór taki głównie z powodu szybkości i wygody pisania, ale także z chęci zdobycia większego doświadczenia w pisaniu na tę platformę. Na razie jednak czynię pewne przygotowania (niewiele ich jest – bo i niewiele ostatnio chce mi się robić) – między innymi uczę się Ale po kolei: zamówienie na edytor wymaga ode mnie użycia części kodu gry w edytorze, by pewne rzeczy były zrealizowane identycznie (z tego, co udało mi się wymyślić, przeczytać i usłyszeć, chodzi głównie o wyszukiwanie ścieżek). Ponieważ przepisywanie kodu z C++ do C# mi się nie uśmiecha (szczególnie, jeśli byłoby tego dużo), postanowiłem poszukać sposobu na wykorzystanie kodu w C++ pod C#.

I znalazłem – zaraz go przedstawię i napiszę, co o nim myślę

Zakładam, że kod C++, który chcemy uruchomić spod C# jest w bibliotece DLL (nie jest to konieczne). W każdym razie, do zrobienia są 3 projekty:

• C++, DLL – tu będzie ten ważny kod C++
• C++/CLI, Class Library – wrapper powyższego
• C#, Console Application – program testowy

Projekt 1 – normalny DLL, żeby można było z tego normalnie korzystać. Projekt 3 to zwykły test, w którym jedyna “ciekawa” operacja to dodanie referencji do DLLki wyprodukowanej przez najważniejsze projekt 2. To w nim jest najbrzydszy kod. Czemu? Wystarczy spojrzeć na “C++/CLI” i wszystko jasne

Cała sztuka polega na tym, żeby dołączyć DLL pierwszego projektu do projektu 2 i napisać klasy .NET opakowujące i dające dostęp C#-owemu kodowi do klas C++ z projektu 1. Tutaj trzeba też dokonać ewentualnych konwersji (np. std::string <-> System::String).

Pokrótce napisałem, o co chodzi – teraz pora na komentarz. Ogólnie rzecz biorąc, to cieszę się że to wszystko jest w ogóle możliwe w dosyć prosty sposób. Natomiast samo wykonanie… właściwie aż tak strasznie złe nie jest. Co prawda ciężko się pisze w Visual C++ ze szwankującym IntelliSensem kod z typowo sisharpowymi pozagnieżdżanymi namespace’ami, konieczność używania konstrukcji typu daszki (“^”) czy “gcnew” też nie jest przyjemna, jednak wszystko to jest poukładane w miarę logicznie. Podsumowując – jest fajnie

Dopisane:

Okazało się, że niezbyt klarownie wytłumaczyłem, o co mi chodzi Dodam więc trochę kodu: to powinno być już całkiem zrozumiałe

Część 1: kod C++

// Plik Foo.hpp
#include <string>

class DLLDEF CFoo
{
public:
  CFoo();
  ~CFoo();

  std::string getString() const;

  unsigned int getNumber() const;
  void setNumber(unsigned int _value);

private:
  std::string mString;
  unsigned int mNumber;
};

// Plik Foo.cpp
#include "Foo.hpp"

CFoo::CFoo()
{ }
CFoo::~CFoo()
{ }

std::string CFoo::getString()
{
  return mString;
}

unsigned int CFoo::getNumber() const
{
  return mNumber;
}

void CFoo::setNumber(unsigned int _value)
{
  mNumber = _value;
}

Część 2: Kod C++/CLI

// Plik FooWrapper.h
#include "Foo.hpp"
#using <mscorlib.dll>

namespace Bar
{
public ref class Foo
{
public:
  Foo();
  ~Foo();

  System::String^ GetString();

  unsigned int GetNumber();
  void SetNumber(unsigned int value);

private:
  Foo* NativePtr;
};
}

// Plik FooWrapper.cpp
#include "FooWrapper.h"
namespace Bar
{
Foo::Foo()
{
  NativePtr = new CFoo();
}
Foo::~Foo()
{
  delete CFoo();
}

System::String^ Foo::GetString()
{
  std::string nts = NativePtr->getString();
  System::String^ out = gcnew System::String(nts.c_str());
  return out;
}

unsigned int Foo::GetNumber()
{
  return NativePtr->getNumber();
}

void Foo::SetNumber(unsigned int value)
{
  NativePtr->setNumber(value);
}
}

Do tego trzeba jakoś dolinkować implementację CFoo – można dołączyć LIB (jeśli jest w DLLce), albo po prostu dołączyć plik Foo.cpp do projektu.

Część 3 – Kod C#

// Plik FooTest.cs
using System;

namespace FooTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Bar.Foo foo = new Bar.Foo();
            string str = foo.GetString();
            uint num = foo.GetNumber();
            foo.SetNumber(666);
        }
    }
}

Trzeba tylko dołączyć referencję do wrappera do projektu. I śmiga

Wrapper robi tutaj konwersję std::string -> System::String, równie dobrze może konwertować obiekty pojemników STL na ich .NETowe odpowiedniki, jak również wiele innych rzeczy