Gewusst wie: Marshallen eines VARIANT für ADO.NET (C++/CLI)

Artikel
02/26/2013

Veranschaulicht das Hinzufügen eines systemeigenen VARIANT-Datentyps zu einer Datenbank und das Marshallen einer System.Object-Zeichenfolge aus einer Datenbank in einen systemeigenen VARIANT-Datentyp.

Beispiel

In diesem Beispiel wird die Klasse DatabaseClass erstellt, die mit einem ADO.NET-DataTable-Objekt interagiert.Beachten Sie, dass diese Klasse eine systemeigene C++-class ist (im Vergleich zu einer ref class oder einer value class).Dies ist notwendig, weil wir diese Klasse von systemeigenem Code aus verwenden möchten und verwaltete Typen in systemeigenem Code nicht verwendet werden können.Diese Klasse wird mit der CLR als Ziel kompiliert. Dies wird durch die der Klassendeklaration vorangestellte #pragma managed-Direktive angezeigt.Weitere Informationen über diese Direktive finden Sie unter verwaltet, nicht verwaltet.

Beachten Sie den privaten Member der DatabaseClass-Klasse: gcroot<DataTable ^> table.Da systemeigene Typen keine verwalteten Typen enthalten können, ist das gcroot-Schlüsselwort erforderlich.Weitere Informationen zu gcroot finden Sie unter Gewusst wie: Deklarieren von Handles in systemeigenen Typen.

Bei dem übrigen Code in diesem Beispiel handelt es sich um systemeigenen C++-Code, was durch die #pragma unmanaged-Direktive vor main angezeigt wird.In diesem Beispiel erstellen wir eine neue Instanz von DatabaseClass und rufen ihre Methoden auf, um eine Tabelle zu erstellen und einige Zeilen darin zu füllen.Beachten Sie, dass systemeigene VARIANT-Typen als Werte für die Datenbankspalte ObjectCol übergeben werden.Innerhalb der DatabaseClass werden diese VARIANT-Typen mit der Marshalling-Funktionalität des System.Runtime.InteropServices-Namespaces in verwaltete Objekte gemarshallt.Dabei wird die Methode GetObjectForNativeVariant zum Marshallen eines VARIANT in ein Object und die Methode GetNativeVariantForObject zum Marshallen eines Object in einen VARIANT verwendet.

// adonet_marshal_variant.cpp
// compile with: /clr /FU System.dll /FU System.Data.dll /FU System.Xml.dll
#include <comdef.h>
#include <gcroot.h>
#include <iostream>
using namespace std;

#using <System.Data.dll>
using namespace System;
using namespace System::Data;
using namespace System::Runtime::InteropServices;

#define MAXCOLS 100

#pragma managed
class DatabaseClass
{
public:
    DatabaseClass() : table(nullptr) { }

    void AddRow(VARIANT *objectColValue)
    {
        // Add a row to the table.
        DataRow ^row = table->NewRow();
        row["ObjectCol"] = Marshal::GetObjectForNativeVariant(
            IntPtr(objectColValue));
        table->Rows->Add(row);
    }

    void CreateAndPopulateTable()
    {
        // Create a simple DataTable.
        table = gcnew DataTable("SampleTable");

        // Add a column of type String to the table.
        DataColumn ^column1 = gcnew DataColumn("ObjectCol",
            Type::GetType("System.Object"));
        table->Columns->Add(column1);
    }

    int GetValuesForColumn(wchar_t *dataColumn, VARIANT *values,
        int valuesLength)
    {
        // Marshal the name of the column to a managed
        // String.
        String ^columnStr = Marshal::PtrToStringUni(
                (IntPtr)dataColumn);

        // Get all rows in the table.
        array<DataRow ^> ^rows = table->Select();
        int len = rows->Length;
        len = (len > valuesLength) ? valuesLength : len;
        for (int i = 0; i < len; i++)
        {
            // Marshal each column value from a managed object
            // to a VARIANT.
            Marshal::GetNativeVariantForObject(
                rows[i][columnStr], IntPtr(&values[i]));
        }

        return len;
    }

private:
    // Using gcroot, you can use a managed type in
    // a native class.
    gcroot<DataTable ^> table;
};

#pragma unmanaged
int main()
{
    // Create a table and add a few rows to it.
    DatabaseClass *db = new DatabaseClass();
    db->CreateAndPopulateTable();

    BSTR bstr1 = SysAllocString(L"This is a BSTR in a VARIANT.");
    VARIANT v1;
    v1.vt = VT_BSTR;
    v1.bstrVal = bstr1;
    db->AddRow(&v1);

    int i = 42;
    VARIANT v2;
    v2.vt = VT_I4;
    v2.lVal = i;
    db->AddRow(&v2);

    // Now retrieve the rows and display their contents.
    VARIANT values[MAXCOLS];
    int len = db->GetValuesForColumn(
        L"ObjectCol", values, MAXCOLS);
    for (int i = 0; i < len; i++)
    {
        switch (values[i].vt)
        {
            case VT_BSTR:
                wcout << L"ObjectCol: " << values[i].bstrVal << endl;
                break;
            case VT_I4:
                cout << "ObjectCol: " << values[i].lVal << endl;
                break;
            default:
                break;
        }

    }

    SysFreeString(bstr1);
    delete db;

    return 0;
}

Kompilieren des Codes

Um den Code über die Kommandozeile zu kompilieren, speichern Sie das Codebeispiel in einer Datei mit dem Namen adonet_marshal_variant.cpp, und geben Sie die folgende Anweisung ein:
```
cl /clr /FU System.dll /FU System.Data.dll /FU System.Xml.dll adonet_marshal_variant.cpp
```