Wrapping native C++ struct in C++/CLI

Habe ich noch nie gearbeitet, die entweder mit C++ oder C++/CLI, aber ich möchte eine native C++ - Bibliothek in ein C# - Projekt. Ich habe ein wenig gegoogelt, gelernt, ein paar Dinge über C++/CLI und beschlossen, give it a head start. Aber ich bin mir nicht sicher, ob ich das Tue es rechts.

Habe ich Folgendes struct in einem einheitlichen namespace:

avcodec.h

typedef struct AVCodecDescriptor {
    enum AVCodecID     id;
    enum AVMediaType type;

    const char      *name;
    const char *long_name;
    int             props;
} AVCodecDescriptor;

Nun möchte ich zum Abschluss noch struct in C++/CLI für die Verwendung in C#:

public ref struct AVCodecDescriptorWrapper {

    private:
        struct AVCodecDescriptor *_avCodecDescriptor;

    public:
        AVCodecDescriptorWrapper() {
            _avCodecDescriptor = new AVCodecDescriptor();
        }
        ~AVCodecDescriptorWrapper() {
            delete _avCodecDescriptor;
        }

        //what do?
        property AVCodecID Id {
            AVCodecID get() {
                return; //what comes here ????
            }
        }

};

Jedoch, wie es scheint, bin ich etwas schrecklich falsch, denn ich bin nicht einmal in der Lage, um zu sehen, die Felder der struct AVCodecDescriptor in C++/CLI. Muss ich wickeln Sie die enums in den struct zu? Muss ich kopieren Sie Sie in C++/CLI und warf es (gut, enum AVCodecID hat wie 350 Werte - ein copy/paste scheint ridiculus.)

Mit new und delete ist eher sinnlos hier. private: AVCodecDescriptor _avCodecDescriptor; genügt. Und ja, Sie haben zu wickeln alles. Einschließlich der Enumerationen. Sie müssen deklariert werden als verwaltete Typen. Und dann ordnen Sie Sie aus dem nicht verwalteten auf verwaltete. Als für die Art, wie Sie wickeln, sollten Sie wirklich es so? Wie sind Sie gehen zu verwalten, die Lebensdauer der const char* Mitglieder. Ehrlich gesagt, es ist mir nicht klar, dass C++/CLI ist es einfacher werden wird als p/invoke.
1) privat: AVCodecDescriptor _avCodecDescriptor nicht funktionieren, da die VS sagt mir, dass ich nicht verwenden können, eine nicht verwaltete Mitglied in einer verwalteten Klasse. 2) Danke für die Klärung! 3) Wie muss ich sonst wickeln? Es ist die Art und Weise eine Menge tutorials handling. 4) ich bin nicht vertraut mit P/Invoke entweder. Aber ich muss irgendwo anfangen. Ich hörte eine Menge Leute sagen, P/Invoke kann wesentlich langsamer sein und da die Bibliothek mit dem ich arbeite ist ffmpeg.. naja, Sie wissen schon.
return (ManagedAVCodecID)_avCodecDescriptor->id; Sie brauchen einen finalizer als gut. Ziemlich sicher, dass ffmpeg bereits verpackt vor. Viele tote Projekte, obwohl, bekommen es eigentlich fertig zu sein scheint eine hohe Hürde.
Nicht nur viele tote Projekte, sondern auch Billionen von sogenannten 'Wrapper', die nicht wirklich wickeln Sie die ffmpeg-Bibliotheken, aber nur konstruieren, Befehl Linie Argumente und übergeben Sie an ffmpeg. :/

InformationsquelleAutor Acrotygma | 2014-01-30

c#c++-cli clr wrapper

Müssen Sie erstellen eine gleichwertige CLI-Klasse von native Struktur und Enums.

public ref class ManagedAVCodecDescriptor {
    ManagedAVCodecIDClass id;
    ManagedAVMediaTypeClass type;

    String^ name;
    String^ long_name;
    int props;
};

Enum entspricht der Klasse sieht wie folgt aus:

public enum class ManagedAVCodecIDClass
{
    xyx = 1,
    abc = 2,
    ...
}

Nun in Ihrem AVCodecDescriptorWrapper sollten Sie sich AVCodecDescriptor Objekt und stellen alle Informationen in der ManagedAVCodecDescriptor Objekt und übergeben es an C# - Klasse.

ManagedAVCodecDescriptor^ mObject = gcnew ManagedAVCodecDescriptor();
mObject.setSomeValue(nativeStruct->somevalue);

und pass mObject in C# - code als allgemein C# - Objekt.

InformationsquelleAutor Nishant Kumar

1

Bevorzuge ich .NET-Struktur in nativen code.
Sie definieren:
```
public enum class AVCodecID : long
{
    mp4 = 1,
    mpeg2 = 2,
    ...
```
}
```
public ref class AVCodecDescriptor
{
    AVCodecID id,
    ...
    System::String name
    ...
}
```
und Wann immer Sie brauchen, in C++ - code ein, den Sie anrufen
```
AVCodecDescriptor cd = gcnew AVCodecDescriptor();
```
Ist es nicht immer praktisch, Sie müssen die Dateien mit es kompiliert, die mit /clr-Schalter und manchmal kann man verrückt mit der Konvertierung von managed/unmanaged Saiten, aber viele Male, dies war ganz passend für mich. Trotzdem können Sie verwenden .NET Enumerationen, die ganz einfach in C++ native code, Eingabe von enum-Werten in int.
- Die nativen Strukturen bereits vorhanden sind; Sie sind Teil eines vorhandenen nativen Bibliothek.
InformationsquelleAutor Ivo Peterka
1

Funktioniert das nicht?
```
   property int Id {
        int get() {
            return _avCodecDescriptor->id;
        }
    }
```
BTW, Sie sollten mit einigen smart-pointer für die Verwaltung des Lebenszyklus der native Objekt, wie jetzt Sie wird Speicherverlust, wenn die .NET-Objekt ist finalizer statt entsorgt. Für ein Beispiel, siehe mein scoped_ptr für C++/CLI (stellen Sie sicher verwaltete Objekt richtig befreit, im Besitz native Objekt)

InformationsquelleAutor Ben Voigt

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.