Jak: MARSZAŁEK wariant dla obiektów ADO.NET (C + +/ CLI)

Artykuł
04/10/2013

Przedstawia sposób dodawania macierzystego VARIANT do bazy danych i sposobu zorganizowania System.Object z bazy danych w trybie macierzystym VARIANT.

Przykład

W tym przykładzie tworzony klasy DatabaseClass do interakcji z ADO.NET DataTable obiektu.Należy zauważyć, że ta klasa jest macierzystym C++ class (w porównaniu z ref class lub value class).Jest to konieczne, ponieważ chcemy użyć tej klasy z kodu macierzystego i typów zarządzanych nie można używać w kodzie macierzystym.Tej klasy będą kompilowane docelowych CLR, wskazywane przez #pragma managed dyrektywy poprzedzających deklaracji klasy.Aby uzyskać więcej informacji na temat niniejszej dyrektywy, zobacz managed, unmanaged.

Uwaga prywatnego członek klasy DatabaseClass: gcroot<DataTable ^> table.Ponieważ macierzystym typów nie może zawierać typy zarządzane gcroot konieczne jest słowo kluczowe.Aby uzyskać więcej informacji na gcroot, zobacz Jak: zadeklarować uchwytów macierzystych typów.

Reszta kodu w tym przykładzie jest kodu C++ macierzystego wskazywane przez #pragma unmanaged dyrektywa poprzedzających main.W tym przykładzie jesteśmy nowe wystąpienie DatabaseClass i wywołanie jej metod tworzenia tabeli i wypełniać niektóre wiersze w tabeli.Należy zauważyć, że macierzystego VARIANT typy są są przekazywane jako wartości dla kolumny bazy danych ObjectCol.Wewnątrz DatabaseClass te VARIANT typy są przekazywane międzyprocesowo do obiektów zarządzanych za pomocą funkcji kierującego, znajdujących się w System.Runtime.InteropServices obszaru nazw.W szczególności metody GetObjectForNativeVariant jest używana do zorganizowania VARIANT do Objectoraz metoda GetNativeVariantForObject jest używany do zorganizowania Object do VARIANT.

// 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;
}

Kompilowanie kodu

Aby skompilować kod z wiersza polecenia, Zapisz przykładowy kod w pliku o nazwie adonet_marshal_variant.cpp, a następnie wprowadź następującą instrukcję:
```
cl /clr /FU System.dll /FU System.Data.dll /FU System.Xml.dll adonet_marshal_variant.cpp
```