Datos y objetos de datos

Artículo
08/10/2011

Los datos que se transfieren como parte de una operación de arrastrar y colocar se almacenan en un objeto de datos. Conceptualmente, un objeto de datos se compone de uno o varios de los siguientes pares:

Un Object que contiene los datos reales.
Un identificador del formato de datos correspondiente.

Los datos en sí pueden estar compuestos de cualquier elemento que se puede representar como una clase base Object. El formato de datos correspondiente es una cadena o Type que proporciona información sobre el formato de los datos. Los objetos de datos permiten hospedar varios pares de datos/formato de datos; esto permite que un mismo objeto de datos proporcione los datos en varios formatos.

Objetos de datos

Todos los objetos de datos deben implementar la interfaz IDataObject, que proporciona el siguiente conjunto de métodos estándar que habilitan y facilitan la transferencia de datos.

Método	Resumen
GetData	Recupera un objeto de datos en un formato de datos especificado.
GetDataPresent	Comprueba si los datos están disponibles en un formato especificado o se pueden convertir a él.
GetFormats	Devuelve una lista de formatos en los que se almacenan los datos de este objeto de datos; o bien, a los que se pueden convertir.
SetData	Almacena los datos especificados en este objeto de datos.

WPF proporciona una implementación básica de IDataObject en la clase DataObject. La clase DataObject estándar es suficiente para muchos escenarios comunes de transferencia de datos.

Hay varios formatos predefinidos, tales como mapa de bits, CSV, archivo, HTML, RTF, cadena, texto y audio. Para obtener información sobre formatos de datos predefinidos proporcionados con WPF, consulte el tema de referencia de la clase DataFormats.

Los objetos de datos suelen incluir una función para convertir automáticamente datos almacenados en un formato a un formato diferente al extraer los datos; esta función se denomina autoconversión. Al consultar los formatos de datos disponibles en un objeto de datos, los formatos de datos autoconvertibles se pueden filtrar para distinguirlos de los formatos de datos nativos llamando al método GetFormats o GetDataPresent y estableciendo el parámetro autoConvert en false. Al agregar datos a un objeto de datos con el método SetData, se puede prohibir la autoconversión de los datos estableciendo el parámetro autoConvert en false.

Trabajar con objetos de datos

En esta sección se describen las técnicas comunes para crear objetos de datos y trabajar con ellos.

Crear nuevos objetos de datos

La clase DataObject proporciona varios constructores sobrecargados que facilitan la operación de rellenar una nueva instancia de DataObject con un solo par de datos/formato de datos.

En el ejemplo de código siguiente se crea un nuevo objeto de datos y se utiliza uno de los constructores sobrecargados DataObject(DataObject) para inicializar el objeto de datos con una cadena y un formato de datos especificado. En este caso, el formato de los datos lo especifica una cadena; la clase DataFormats proporciona un conjunto de cadenas de tipo predefinidas. Se permite la autoconversión de los datos almacenados de forma predeterminada.

Dim stringData As String = "Some string data to store..."
Dim dataFormat As String = DataFormats.UnicodeText
Dim dataObject As New DataObject(dataFormat, stringData)

string stringData = "Some string data to store...";
string dataFormat = DataFormats.UnicodeText;
DataObject dataObject = new DataObject(dataFormat, stringData);

Para obtener más ejemplos de código en los que se crean objetos de datos, consulte Cómo: Crear un objeto de datos.

Almacenar datos en varios formatos

Un mismo objeto de datos puede almacenar los datos en varios formatos. El uso estratégico de varios formatos de datos dentro de un mismo objeto de datos hace que el objeto de datos se pueda utilizar potencialmente por una mayor diversidad de destinos de colocación que si únicamente fuese posible representar un formato de datos. En general, tenga en cuenta que un origen de arrastre debe ser válido con respecto a los formatos de datos los destinos potenciales pueden utilizar.

En el ejemplo siguiente se muestra cómo utilizar el método SetData para agregar datos a un objeto de datos en varios formatos.

                Dim dataObject As New DataObject()
                Dim sourceData As String = "Some string data to store..."

                ' Encode the source string into Unicode byte arrays.
                Dim unicodeText() As Byte = Encoding.Unicode.GetBytes(sourceData) ' UTF-16
                Dim utf8Text() As Byte = Encoding.UTF8.GetBytes(sourceData)
                Dim utf32Text() As Byte = Encoding.UTF32.GetBytes(sourceData)

                ' The DataFormats class does not provide data format fields for denoting
                ' UTF-32 and UTF-8, which are seldom used in practice; the following strings 
                ' will be used to identify these "custom" data formats.
                Dim utf32DataFormat As String = "UTF-32"
                Dim utf8DataFormat As String = "UTF-8"

                ' Store the text in the data object, letting the data object choose
                ' the data format (which will be DataFormats.Text in this case).
                dataObject.SetData(sourceData)
                ' Store the Unicode text in the data object.  Text data can be automatically
                ' converted to Unicode (UTF-16 / UCS-2) format on extraction from the data object; 
                ' Therefore, explicitly converting the source text to Unicode is generally unnecessary, and
                ' is done here as an exercise only.
                dataObject.SetData(DataFormats.UnicodeText, unicodeText)
                ' Store the UTF-8 text in the data object...
                dataObject.SetData(utf8DataFormat, utf8Text)
                ' Store the UTF-32 text in the data object...
                dataObject.SetData(utf32DataFormat, utf32Text)

DataObject dataObject = new DataObject();
string sourceData = "Some string data to store...";

// Encode the source string into Unicode byte arrays.
byte[] unicodeText = Encoding.Unicode.GetBytes(sourceData); // UTF-16
byte[] utf8Text = Encoding.UTF8.GetBytes(sourceData);
byte[] utf32Text = Encoding.UTF32.GetBytes(sourceData);

// The DataFormats class does not provide data format fields for denoting
// UTF-32 and UTF-8, which are seldom used in practice; the following strings 
// will be used to identify these "custom" data formats.
string utf32DataFormat = "UTF-32";
string utf8DataFormat  = "UTF-8";

// Store the text in the data object, letting the data object choose
// the data format (which will be DataFormats.Text in this case).
dataObject.SetData(sourceData);
// Store the Unicode text in the data object.  Text data can be automatically
// converted to Unicode (UTF-16 / UCS-2) format on extraction from the data object; 
// Therefore, explicitly converting the source text to Unicode is generally unnecessary, and
// is done here as an exercise only.
dataObject.SetData(DataFormats.UnicodeText, unicodeText);
// Store the UTF-8 text in the data object...
dataObject.SetData(utf8DataFormat, utf8Text);
// Store the UTF-32 text in the data object...
dataObject.SetData(utf32DataFormat, utf32Text);

Consultar los formatos disponibles en un objeto de datos

Dado que un mismo objeto de datos puede contener un número arbitrario de formatos de datos, los objetos de datos incluyen medios para recuperar una lista de los formatos de datos disponibles.

En el ejemplo de código siguiente se utiliza la sobrecarga de GetFormats para obtener una matriz de cadenas que representan todos los formatos de datos disponibles en un objeto de datos (tanto nativos como por autoconversión).

Dim dataObject As New DataObject("Some string data to store...")

' Get an array of strings, each string denoting a data format
' that is available in the data object.  This overload of GetDataFormats
' returns all available data formats, native and auto-convertible.
Dim dataFormats() As String = dataObject.GetFormats()

' Get the number of data formats present in the data object, including both
' auto-convertible and native data formats.
Dim numberOfDataFormats As Integer = dataFormats.Length

' To enumerate the resulting array of data formats, and take some action when
' a particular data format is found, use a code structure similar to the following.
For Each dataFormat As String In dataFormats
    If dataFormat = System.Windows.DataFormats.Text Then
        ' Take some action if/when data in the Text data format is found.
        Exit For
    ElseIf dataFormat = System.Windows.DataFormats.StringFormat Then
        ' Take some action if/when data in the string data format is found.
        Exit For
    End If
Next dataFormat

DataObject dataObject = new DataObject("Some string data to store...");

// Get an array of strings, each string denoting a data format
// that is available in the data object.  This overload of GetDataFormats
// returns all available data formats, native and auto-convertible.
string[] dataFormats = dataObject.GetFormats();

// Get the number of data formats present in the data object, including both
// auto-convertible and native data formats.
int numberOfDataFormats = dataFormats.Length;

// To enumerate the resulting array of data formats, and take some action when
// a particular data format is found, use a code structure similar to the following.
foreach (string dataFormat in dataFormats)
{
    if (dataFormat == DataFormats.Text)
    {
        // Take some action if/when data in the Text data format is found.
        break;
    }
    else if(dataFormat == DataFormats.StringFormat)
    {
        // Take some action if/when data in the string data format is found.
        break;
    }
}

Para obtener más ejemplos de código en que se consultan los formatos de datos disponibles en un objeto de datos, consulte Cómo: Mostrar los formatos de datos en un objeto de datos. Para obtener ejemplos sobre cómo consultar un objeto de datos para comprobar si está presente en él un formato de datos determinado, consulte Cómo: Determinar si un formato de datos está presente en un objeto de datos.

Recuperar datos de un objeto de datos

Para recuperar los datos de un objeto de datos en un formato concreto basta con llamar a uno de los métodos GetData y especificar el formato de datos deseado. Uno de los métodos GetDataPresent se puede utilizar para comprobar la presencia de un formato de datos determinado. GetData devuelve los datos de un Object; según cuál sea el formato de datos, este objeto se puede convertir a un contenedor específico del tipo.

En el ejemplo de código siguiente se utiliza la sobrecarga de GetDataPresent para comprobar si está disponible un formato de datos concreto (nativo o por autoconversión). Si el formato especificado está disponible, entonces el ejemplo recupera los datos mediante el método GetData.

Dim dataObject As New DataObject("Some string data to store...")

Dim desiredFormat As String = DataFormats.UnicodeText
Dim data() As Byte = Nothing

' Use the GetDataPresent method to check for the presence of a desired data format.
' This particular overload of GetDataPresent looks for both native and auto-convertible 
' data formats.
If dataObject.GetDataPresent(desiredFormat) Then
    ' If the desired data format is present, use one of the GetData methods to retrieve the
    ' data from the data object.
    data = TryCast(dataObject.GetData(desiredFormat), Byte())
End If

DataObject dataObject = new DataObject("Some string data to store...");

string desiredFormat = DataFormats.UnicodeText;
byte[] data = null;

// Use the GetDataPresent method to check for the presence of a desired data format.
// This particular overload of GetDataPresent looks for both native and auto-convertible 
// data formats.
if (dataObject.GetDataPresent(desiredFormat))
{
    // If the desired data format is present, use one of the GetData methods to retrieve the
    // data from the data object.
    data = dataObject.GetData(desiredFormat) as byte[];
}

Para obtener más ejemplos de código en que se recuperan datos de un objeto de datos, consulte Cómo: Recuperar datos en un formato concreto.

Quitar datos de un objeto de datos

No es posible quitar directamente los datos de un objeto de datos. Para quitar de manera efectiva los datos de un objeto de datos, siga estos pasos:

Cree un nuevo objeto de datos que únicamente contendrá los datos que desea conservar.
"Copie" los datos deseados de del objeto de datos anterior al nuevo. Para copiar los datos, utilice uno de los métodos GetData para recuperar una clase Object que contiene los datos sin procesar y, a continuación, utilice uno de los métodos SetData para agregar los datos al nuevo objeto de datos.
Reemplace el objeto de datos anterior por el nuevo.

Nota
Los métodos SetData únicamente agregan datos a un objeto de datos; no reemplazan esos datos, aunque los datos y el formato de datos sean exactamente iguales que en una llamada anterior.Al llamar dos veces a SetData para obtener los mismos datos y formato de datos hará que el par de datos/formato de datos esté presente dos veces en el objeto de datos.

Historial de cambios

Fecha	Historial	Motivo
1 de abril de 2011	Se ha agregado un tema.	Comentarios de los clientes.

1 de abril de 2011

Se ha agregado un tema.

Comentarios de los clientes.

Compartir a través de