Cómo: Convertir cadenas Unicode para ADO.NET

Artículo
08/23/2008

Actualización: noviembre 2007

Muestra cómo agregar una cadena Unicode nativa (wchar_t *) a una base de datos y cómo convertir System.String de una base de datos en una cadena Unicode nativa.

Ejemplo

En este ejemplo, la clase DatabaseClass se crea para interactuar con un objeto DataTable de ADO.NET. Tenga en cuenta que esta clase es una class de C++ nativa (si se compara con una ref class o value class). Esto es necesario porque deseamos utilizar esta clase desde código nativo y no se pueden utilizar tipos administrados en código nativo. Esta clase se compilará para CLR, según indica la directiva #pragma managed que precede a la declaración de clase. Para obtener más información sobre esta directiva, vea managed, unmanaged.

Tenga en cuenta el miembro privado de la clase DatabaseClass: gcroot<DataTable ^> table. Como los tipos nativos no pueden contener tipos administrados, es necesario utilizar la palabra clave gcroot. Para obtener más información sobre gcroot, vea Cómo: Declarar controladores en tipos nativos.

El resto del código de este ejemplo es código nativo de C++, según indica la directiva #pragma unmanaged que precede a main. En este ejemplo, se crea una nueva instancia de DatabaseClass y se llama a sus métodos para crear una tabla y rellenar algunas filas de la tabla. Observe que la cadenas Unicode de C++ se pasan como valores para la columna de base de datos StringCol. Dentro de DatabaseClass, estas cadenas se convierten en cadenas administradas utilizando la funcionalidad de cálculo de referencias que encontramos en el espacio de nombres System.Runtime.InteropServices. En concreto, el método PtrToStringUni se utiliza para convertir wchar_t * en String y el método StringToHGlobalUni, para convertir String en wchar_t *.

Nota:
La memoria asignada por StringToHGlobalUni se debe desasignar llamando a FreeHGlobal o a 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.

Compilar el código

Para compilar el código de la línea de comandos, guarde el ejemplo de código en un archivo denominado adonet_marshal_string_wide.cpp y escriba la instrucción siguiente:
```
cl /clr /FU System.dll /FU System.Data.dll /FU System.Xml.dll adonet_marshal_string_wide.cpp
```