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

Článek
12/01/2021
15 min ke čtení

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

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

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

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

Příklad

V tomto příkladu je vytvořena třída DatabaseClass pro interakci s objektem ADO.NET DataTable. Všimněte si, že tato třída je nativní 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 nelze použít spravované typy v nativním kódu. Tato třída bude zkompilována pro cílení na CLR, jak je označeno direktivou #pragma managed předcházející deklaraci třídy. Další informace o této direktivě 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 o najdete gcroot v tématu gcroot.

Zbytek kódu v tomto příkladu je nativní kód jazyka C++, jak je označeno #pragma unmanaged direktivou předcházející main . 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í řetězce jazyka C++ se předá jako hodnoty pro databázový sloupec StringCol. Uvnitř třídy DatabaseClass jsou tyto řetězce zařazené do spravovaných řetězců pomocí funkce zařazování, která se nachází v oboru názvů System.Runtime.InteropServices. Konkrétně se metoda PtrToStringAnsi používá k zařazování objektu na řetězec a metoda StringToHGlobalAnsi slouží k zařazování řetězce do objektu .

Poznámka

Paměť přidělená pomocí StringToHGlobalAnsi se musí zrušením přidělení voláním freeHGlobal nebo .

// 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 ( ) do databáze a jak zařadit BSTRBSTR z databáze do BSTR .

Příklad

Zbytek kódu v tomto příkladu je nativní kód jazyka C++, jak je označeno #pragma unmanaged direktivou předcházející main . 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á jako hodnoty pro databázový sloupec StringCol. Uvnitř třídy DatabaseClass jsou tyto řetězce zařazené do spravovaných řetězců pomocí funkce zařazování, která se nachází v oboru názvů System.Runtime.InteropServices. Konkrétně se metoda PtrToStringBSTR používá k zařazování objektu na řetězec a metoda StringToBSTR se používá k zařazování řetězce do objektu .

Poznámka

Paměť přidělená pomocí funkce StringToBSTR se musí zrušením přidělení voláním freeBSTR nebo .

// 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 ( ) do databáze a jak zařadit wchar_t *wchar_t * z databáze do nativního řetězce Unicode.

Příklad

Zbytek kódu v tomto příkladu je nativní kód jazyka C++, jak je označeno #pragma unmanaged direktivou předcházející main . 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á jako hodnoty pro databázový sloupec StringCol. Uvnitř třídy DatabaseClass jsou tyto řetězce zařazené do spravovaných řetězců pomocí funkce zařazování, která se nachází v oboru názvů System.Runtime.InteropServices. Konkrétně se metoda PtrToStringMun používá k zařazování objektu do řetězce a metoda StringToHGlobal Při zařazování řetězce do objektu se používá metoda .

Poznámka

Paměť přidělená objektem StringToHGlobalMun musí být zrušením přidělení voláním metody FreeHGlobal nebo .

// 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í varianty pro ADO.NET

Demonstruje způsob přidání nativního objektu do databáze a zařazení VARIANTVARIANT z databáze do nativního VARIANT objektu .

Příklad

Zbytek kódu v tomto příkladu je nativní kód jazyka C++, jak je označeno #pragma unmanaged direktivou předcházející main . 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. Nativní typy VARIANT se předaly jako hodnoty databázového sloupce ObjectCol. Uvnitř třídy DatabaseClass jsou tyto typy zařazeny do spravovaných objektů pomocí funkce zařazování, která se nachází v oboru názvů VARIANTVARIANT Konkrétně se metoda GetObjectForNativeVariant používá k zařazování objektu do objektu a metoda GetNativeVariantForObject se používá k zařazování objektu do objektu .

// 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 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í pole SAFEARRAY pro ADO.NET

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

Příklad

Zbytek kódu v tomto příkladu je nativní kód jazyka C++, jak je označeno #pragma unmanaged direktivou předcházející main . 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 jsou předávány jako hodnoty pro sloupec databáze ArrayIntsCol. V DatabaseClass jsou tyto SAFEARRAY typy zařazeny do spravovaných objektů pomocí funkce zařazování nalezené v oboru názvů SAFEARRAY . Konkrétně se metoda kopírování používá k zařazování do spravovaného pole celých čísel a metoda, která je použita k zařazování spravovaného pole celých čísel do .

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

Chcete-li 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 bezpečnostních problémech týkajících se ADO.NET najdete v tématu zabezpečení aplikací ADO.NET.

Sekce	Description
ADO.NET	poskytuje přehled ADO.NET, sadu tříd, které zpřístupňují služby pro přístup k datům v programátoru .net.

Viz také

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

Nativní a interoperabilita .NET

System. Runtime. InteropServices

Vzájemná funkční spolupráce

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

Ohodnoťte vaše zkušenosti

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í varianty pro ADO.NET

Příklad

Probíhá kompilace kódu

Zařazování pole SAFEARRAY pro ADO.NET

Příklad

Probíhá kompilace kódu

Zabezpečení rozhraní .NET Framework

Související oddíly

Viz také