Přístup k datům s použitím technologie ADO.NET (C++/CLI)

Článek
10/12/2023

ADO.NET je rozhraní API rozhraní .NET Framework pro přístup k datům a poskytuje výkon a snadné použití, které neodpovídají předchozím řešením pro přístup k datům. Tato část popisuje některé problémy související s ADO.NET, které jsou jedinečné pro uživatele visual C++, například zařazování nativních typů.

ADO.NET běží v modulu CLR (Common Language Runtime). Proto každá aplikace, která komunikuje s ADO.NET, musí také cílit na CLR. To však neznamená, že nativní aplikace nemohou používat ADO.NET. Tyto příklady ukazují, jak pracovat s ADO.NET databází z nativního kódu.

Zařazování řetězců ANSI pro ADO.NET

Ukazuje, jak přidat nativní řetězec (char *) do databáze a jak zařadí System.String z databáze do nativního řetězce.

Příklad

V tomto příkladu je třída DatabaseClass vytvořena pro interakci s ADO.NET DataTable objektu. Všimněte si, že tato třída je nativní jazyk C++ class (ve srovnání s ref class nebo value class). To je nezbytné, protože chceme použít tuto třídu z nativního kódu a nemůžete použít spravované typy v nativním kódu. Tato třída bude zkompilována tak, aby cílila na CLR, jak je uvedeno #pragma managed direktivou předcházející deklaraci třídy. Další informace o této směrnici najdete v tématu spravované, nespravované.

Poznamenejte si privátního člena Třídy DatabaseClass: gcroot<DataTable ^> table. Vzhledem k tomu, že nativní typy nemohou obsahovat spravované typy, gcroot je klíčové slovo nezbytné. Další informace naleznete gcrootv tématu Postupy: Deklarace popisovačů v nativních typech.

Zbytek kódu v tomto příkladu je nativní kód C++, jak je uvedeno #pragma unmanaged direktivou mainpředcházející . V tomto příkladu vytváříme novou instanci DatabaseClass a voláme její metody pro vytvoření tabulky a naplnění některých řádků v tabulce. Mějte na paměti, že nativní řetězce C++ se předávají jako hodnoty pro databázový sloupec StringCol. Uvnitř Třídy DatabaseClass jsou tyto řetězce zařazovány do spravovaných řetězců pomocí funkcí zařazování nalezených v System.Runtime.InteropServices oboru názvů. Konkrétně se metoda PtrToStringAnsi používá k zařazování char * na String, a metoda StringToHGlobalAnsi se používá k zařazování String na char *.

Poznámka:

Paměť přidělená službou StringToHGlobalAnsi musí být uvolněna voláním nebo FreeHGlobal GlobalFree.

// adonet_marshal_string_native.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(char *stringColValue)
    {
        // Add a row to the table.
        DataRow ^row = table->NewRow();
        row["StringCol"] = Marshal::PtrToStringAnsi(
            (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(char *dataColumn, char **values,
        int valuesLength)
    {
        // Marshal the name of the column to a managed
        // String.
        String ^columnStr = Marshal::PtrToStringAnsi(
                (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 char *.
            values[i] = (char *)Marshal::StringToHGlobalAnsi(
                (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();
    db->AddRow("This is string 1.");
    db->AddRow("This is string 2.");

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

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

    delete db;

    return 0;
}

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

Probíhá kompilace kódu

Pokud chcete zkompilovat kód z příkazového řádku, uložte příklad kódu do souboru s názvem adonet_marshal_string_native.cpp a zadejte následující příkaz:
```
cl /clr /FU System.dll /FU System.Data.dll /FU System.Xml.dll adonet_marshal_string_native.cpp
```

Zařazování řetězců BSTR pro ADO.NET

Ukazuje, jak přidat řetězec modelu COM (BSTR) do databáze a jak zařadí System.String z databáze do BSTR.

Příklad

Zbytek kódu v tomto příkladu je nativní kód C++, jak je uvedeno #pragma unmanaged direktivou mainpředcházející . V tomto příkladu vytváříme novou instanci DatabaseClass a voláme její metody pro vytvoření tabulky a naplnění některých řádků v tabulce. Všimněte si, že řetězce modelu COM se předávají jako hodnoty pro sloupec Database StringCol. Uvnitř Třídy DatabaseClass jsou tyto řetězce zařazovány do spravovaných řetězců pomocí funkcí zařazování nalezených v System.Runtime.InteropServices oboru názvů. Konkrétně se metoda PtrToStringBSTR používá k zařazování BSTR na String, a metoda StringToBSTR se používá k zařazování String na BSTR.

Poznámka:

Paměť přidělená službou StringToBSTR musí být uvolněna voláním nebo FreeBSTR SysFreeString.

// 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.

Probíhá kompilace kódu

Pokud chcete zkompilovat kód z příkazového řádku, uložte příklad kódu do souboru s názvem adonet_marshal_string_native.cpp a zadejte následující příkaz:
```
cl /clr /FU System.dll /FU System.Data.dll /FU System.Xml.dll adonet_marshal_string_native.cpp
```

Zařazování řetězců unicode pro ADO.NET

Ukazuje, jak přidat nativní řetězec Unicode (wchar_t *) do databáze a jak zařadí System.String z databáze do nativního řetězce Unicode.

Příklad

Zbytek kódu v tomto příkladu je nativní kód C++, jak je uvedeno #pragma unmanaged direktivou mainpředcházející . V tomto příkladu vytváříme novou instanci DatabaseClass a voláme její metody pro vytvoření tabulky a naplnění některých řádků v tabulce. Všimněte si, že řetězce Unicode C++ se předávají jako hodnoty pro databázový sloupec StringCol. Uvnitř Třídy DatabaseClass jsou tyto řetězce zařazovány do spravovaných řetězců pomocí funkcí zařazování nalezených v System.Runtime.InteropServices oboru názvů. Konkrétně se metoda PtrToStringUni používá k zařazování wchar_t * na String, a metoda StringToHGlobalUni se používá k zařazování String na wchar_t *.

Poznámka:

Paměť přidělená službou StringToHGlobalUni musí být uvolněna voláním nebo FreeHGlobal GlobalFree.

// adonet_marshal_string_wide.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(wchar_t *stringColValue)
    {
        // Add a row to the table.
        DataRow ^row = table->NewRow();
        row["StringCol"] = Marshal::PtrToStringUni(
            (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(wchar_t *dataColumn, wchar_t **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 string
            // to a wchar_t *.
            values[i] = (wchar_t *)Marshal::StringToHGlobalUni(
                (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();
    db->AddRow(L"This is string 1.");
    db->AddRow(L"This is string 2.");

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

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

    delete db;

    return 0;
}

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

Probíhá kompilace kódu

Pokud chcete zkompilovat kód z příkazového řádku, uložte příklad kódu do souboru s názvem adonet_marshal_string_wide.cpp a zadejte následující příkaz:
```
cl /clr /FU System.dll /FU System.Data.dll /FU System.Xml.dll adonet_marshal_string_wide.cpp
```

Zařazování VARIANT pro ADO.NET

Ukazuje, jak přidat nativní VARIANT do databáze a jak zařašovat System.Object z databáze do nativní VARIANT.

Příklad

Zbytek kódu v tomto příkladu je nativní kód C++, jak je uvedeno #pragma unmanaged direktivou mainpředcházející . V tomto příkladu vytváříme novou instanci DatabaseClass a voláme její metody pro vytvoření tabulky a naplnění některých řádků v tabulce. Všimněte si, že nativní VARIANT typy se předávají jako hodnoty pro databázový sloupec ObjectCol. Uvnitř Třídy DatabaseClass jsou tyto VARIANT typy zařazovány do spravovaných objektů pomocí funkce zařazování nalezené v System.Runtime.InteropServices oboru názvů. Konkrétně se metoda GetObjectForNativeVariant používá k zařazování na VARIANT Object, a metoda GetNativeVariantForObject se používá k zařazování do Object 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;
}

ObjectCol: This is a BSTR in a VARIANT.
ObjectCol: 42

Probíhá kompilace kódu

Pokud chcete zkompilovat kód z příkazového řádku, uložte příklad kódu do souboru s názvem adonet_marshal_variant.cpp a zadejte následující příkaz:
```
cl /clr /FU System.dll /FU System.Data.dll /FU System.Xml.dll adonet_marshal_variant.cpp
```

Zařazování SAFEARRAY pro ADO.NET

Ukazuje, jak přidat nativní SAFEARRAY do databáze a jak zařašovat spravované pole z databáze do nativní SAFEARRAY.

Příklad

Zbytek kódu v tomto příkladu je nativní kód C++, jak je uvedeno #pragma unmanaged direktivou mainpředcházející . V tomto příkladu vytváříme novou instanci DatabaseClass a voláme její metody pro vytvoření tabulky a naplnění některých řádků v tabulce. Všimněte si, že nativní SAFEARRAY typy se předávají jako hodnoty pro sloupec databáze ArrayIntsCol. Uvnitř Třídy DatabaseClass jsou tyto SAFEARRAY typy zařazovány do spravovaných objektů pomocí funkce zařazování nalezené v System.Runtime.InteropServices oboru názvů. Konkrétně se metoda Copy používá k zařazování SAFEARRAY do spravovaného pole celých čísel a metoda Copy se používá k zařazování spravovaného pole celých čísel na SAFEARRAY.

// adonet_marshal_safearray.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(SAFEARRAY *arrayIntsColValue)
    {
        // Add a row to the table.
        DataRow ^row = table->NewRow();
        int len = arrayIntsColValue->rgsabound[0].cElements;
        array<int> ^arr = gcnew array<int>(len);

        int *pData;
        SafeArrayAccessData(arrayIntsColValue, (void **)&pData);
        Marshal::Copy(IntPtr(pData), arr, 0, len);
        SafeArrayUnaccessData(arrayIntsColValue);

        row["ArrayIntsCol"] = arr;
        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("ArrayIntsCol",
            Type::GetType("System.Int32[]"));
        table->Columns->Add(column1);
    }

    int GetValuesForColumn(wchar_t *dataColumn, SAFEARRAY **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 array
            // of Int32s to a SAFEARRAY of type VT_I4.
            values[i] = SafeArrayCreateVector(VT_I4, 0, 10);
            int *pData;
            SafeArrayAccessData(values[i], (void **)&pData);
            Marshal::Copy((array<int> ^)rows[i][columnStr], 0,
                IntPtr(pData), 10);
            SafeArrayUnaccessData(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();

    // Create a standard array.
    int originalArray[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    // Create a SAFEARRAY.
    SAFEARRAY *psa;
    psa = SafeArrayCreateVector(VT_I4, 0, 10);

    // Copy the data from the original array to the SAFEARRAY.
    int *pData;
    HRESULT hr = SafeArrayAccessData(psa, (void **)&pData);
    memcpy(pData, &originalArray, 40);
    SafeArrayUnaccessData(psa);
    db->AddRow(psa);

    // Now retrieve the rows and display their contents.
    SAFEARRAY *values[MAXCOLS];
    int len = db->GetValuesForColumn(
        L"ArrayIntsCol", values, MAXCOLS);
    for (int i = 0; i < len; i++)
    {
        int *pData;
        SafeArrayAccessData(values[i], (void **)&pData);
        for (int j = 0; j < 10; j++)
        {
            cout << pData[j] << " ";
        }
        cout << endl;
        SafeArrayUnaccessData(values[i]);

        // Deallocate the memory allocated using
        // SafeArrayCreateVector.
        SafeArrayDestroy(values[i]);
    }

    SafeArrayDestroy(psa);
    delete db;

    return 0;
}

0 1 2 3 4 5 6 7 8 9

Probíhá kompilace kódu

Pokud chcete zkompilovat kód z příkazového řádku, uložte příklad kódu do souboru s názvem adonet_marshal_safearray.cpp a zadejte následující příkaz:
```
cl /clr /FU System.dll /FU System.Data.dll /FU System.Xml.dll adonet_marshal_safearray.cpp
```

Zabezpečení rozhraní .NET Framework

Informace o problémech se zabezpečením souvisejících s ADO.NET najdete v tématu Zabezpečení ADO.NET aplikací.

Oddíl	Popis
ADO.NET	Poskytuje přehled ADO.NET, sada tříd, které zpřístupňují služby přístupu k datům programátorům .NET.

Viz také

Programování pro .NET v jazyce C++/CLI (Visual C++)

Nativní funkce a vzájemná funkční spolupráce rozhraní .NET

System.Runtime.InteropServices

Vzájemná funkční spolupráce

Sdílet prostřednictvím

Přístup k datům s použitím technologie ADO.NET (C++/CLI)

Zařazování řetězců ANSI pro ADO.NET

Příklad

Probíhá kompilace kódu

Zařazování řetězců BSTR pro ADO.NET

Příklad

Probíhá kompilace kódu

Zařazování řetězců unicode pro ADO.NET

Příklad

Probíhá kompilace kódu

Zařazování VARIANT pro ADO.NET

Příklad

Probíhá kompilace kódu

Zařazování SAFEARRAY pro ADO.NET

Příklad

Probíhá kompilace kódu

Zabezpečení rozhraní .NET Framework

Viz také

Váš názor

Další materiály

Sdílet prostřednictvím

Přístup k datům s použitím technologie ADO.NET (C++/CLI)

Zařazování řetězců ANSI pro ADO.NET

Příklad

Probíhá kompilace kódu

Zařazování řetězců BSTR pro ADO.NET

Příklad

Probíhá kompilace kódu

Zařazování řetězců unicode pro ADO.NET

Příklad

Probíhá kompilace kódu

Zařazování VARIANT pro ADO.NET

Příklad

Probíhá kompilace kódu

Zařazování SAFEARRAY pro ADO.NET

Příklad

Probíhá kompilace kódu

Zabezpečení rozhraní .NET Framework

Související oddíly

Viz také

Váš názor

Další materiály