Gewusst wie: Marshallen von BSTR-Zeichenfolgen für ADO.NET

Artikel
08/20/2008

Aktualisiert: November 2007

Veranschaulicht das Hinzufügen einer COM-Zeichenfolge (BSTR) zu einer Datenbank und das Marshallen einer System.String-Zeichenfolge aus einer Datenbank in eine BSTR-Zeichenfolge.

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 managed, unmanaged.

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 zum Datentyp 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 COM-Zeichenfolgen als Werte für die Datenbankspalte StringCol übergeben werden. Innerhalb der DatabaseClass werden diese Zeichenfolgen mit der Marshalling-Funktionalität des System.Runtime.InteropServices-Namespaces in verwaltete Zeichenfolgen gemarshallt. Dabei wird die Methode PtrToStringBSTR zum Marshallen einer BSTR in eine String und die Methode StringToBSTR zum Marshallen einer String in eine BSTR verwendet.

Hinweis:
Der durch StringToBSTR reservierte Arbeitsspeicher muss durch Aufrufen von FreeBSTR oder SysFreeString freigegeben werden.

// adonet_marshal_string_bstr.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(BSTR stringColValue)
    {
        // Add a row to the table.
        DataRow ^row = table->NewRow();
        row["StringCol"] = Marshal::PtrToStringBSTR(
            (IntPtr)stringColValue);
        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("StringCol",
            Type::GetType("System.String"));
        table->Columns->Add(column1);
    }

    int GetValuesForColumn(BSTR dataColumn, BSTR *values,
        int valuesLength)
    {
        // Marshal the name of the column to a managed
        // String.
        String ^columnStr = Marshal::PtrToStringBSTR(
                (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 string
            // to a BSTR.
            values[i] = (BSTR)Marshal::StringToBSTR(
                (String ^)rows[i][columnStr]).ToPointer();
        }

        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 str1 = SysAllocString(L"This is string 1.");
    db->AddRow(str1);

    BSTR str2 = SysAllocString(L"This is string 2.");
    db->AddRow(str2);

    // Now retrieve the rows and display their contents.
    BSTR values[MAXCOLS];
    BSTR str3 = SysAllocString(L"StringCol");
    int len = db->GetValuesForColumn(
        str3, values, MAXCOLS);
    for (int i = 0; i < len; i++)
    {
        wcout << "StringCol: " << values[i] << endl;

        // Deallocate the memory allocated using
        // Marshal::StringToBSTR.
        SysFreeString(values[i]);
    }

    SysFreeString(str1);
    SysFreeString(str2);
    SysFreeString(str3);
    delete db;

    return 0;
}

StringCol: This is string 1.
StringCol: This is string 2.

Kompilieren des Codes

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