Compartir a través de

Datos y objetos de datos

  • Artículo

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 consta de uno o varios de los pares siguientes:

  • Un Object que contiene los datos reales.

  • Un identificador de formato de datos correspondiente.

Los propios datos pueden constar de cualquier cosa que se pueda representar como base Object. El formato de datos correspondiente es una cadena o Type que proporciona una sugerencia sobre el formato de los datos. Los objetos de datos admiten el hospedaje de múltiples pares de datos/formatos de datos; esto permite que un único objeto de datos proporcione 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 permiten 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, como mapa de bits, CSV, archivo, HTML, RTF, cadena, texto y audio. Para obtener información sobre los formatos de datos predefinidos proporcionados con WPF, vea el tema de referencia de la clase DataFormats.

Los objetos de datos suelen incluir una instalación para convertir automáticamente los datos almacenados en un formato diferente al extraer datos; esta instalación se conoce como conversión automática. Al consultar los formatos de datos disponibles en un objeto de datos, los formatos de datos autoconvertibles pueden filtrarse de los formatos de datos nativos llamando al método GetFormats(Boolean) o GetDataPresent(String, Boolean) y especificando el parámetro autoConvert como false. Al agregar datos a un objeto de datos con el método SetData(String, Object, Boolean), se puede prohibir la conversión automática de datos estableciendo el parámetro autoConvert como false.

Trabajar con objetos de datos

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

Crear nuevos objetos de datos

La clase DataObject proporciona varios constructores sobrecargados que facilitan el llenado de una nueva instancia DataObject con un único par de datos/formato de datos.

El siguiente código de ejemplo crea un nuevo objeto de datos y utiliza uno de los constructores sobrecargados DataObject(DataObject(String, Object)) para inicializar el objeto de datos con una cadena y un formato de datos especificado. En este caso, el formato de los datos se especifica mediante una cadena; la clase DataFormats proporciona un conjunto de cadenas de tipo predefinido. La conversión automática de los datos almacenados se permite de forma predeterminada.

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

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

Para obtener más ejemplos de código que crea un objeto de datos, vea Crear un objeto de datos.

Almacenar datos en varios formatos

Un solo objeto de datos puede almacenar datos en varios formatos. El uso estratégico de varios formatos de datos dentro de un único objeto de datos puede hacer que el objeto de datos consuma una variedad más amplia de destinos de colocación que si solo se pudiera representar un único formato de datos. Tenga en cuenta que, en general, un origen de arrastre debe ser independiente de los formatos de datos consumibles por posibles destinos de colocación.

El siguiente ejemplo muestra cómo utilizar el método SetData(String, Object) para añadir datos a un objeto de datos en múltiples formatos.

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);

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)

Consulta de un objeto de datos para formatos disponibles

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

El siguiente código de ejemplo usa la sobrecarga GetFormats para obtener una matriz de cadenas que denotan todos los formatos de datos disponibles en un objeto de datos (tanto nativos como por conversión automática).

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;
    }
}

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

Para obtener más ejemplos de código que consulta un objeto de datos para los formatos de datos disponibles, vea Mostrar los formatos de datos en un objeto de datos. Para obtener ejemplos de consulta de un objeto de datos para la presencia de un formato de datos determinado, vea Determinar si un formato de datos está presente en un objeto de datos.

Recuperar datos de un objeto de datos

La recuperación de datos de un objeto de datos en un formato determinado simplemente implica llamar a uno de los métodos GetData y especificar el formato de datos deseado. Se puede usar uno de los métodos GetDataPresent para comprobar la presencia de un formato de datos concreto. GetData devuelve los datos en un Object; dependiendo del formato de los datos, este objeto se puede convertir a un contenedor específico del tipo.

El siguiente código de ejemplo usa la sobrecarga GetDataPresent(String) para comprobar si un formato de datos especificado está disponible (nativo o por conversión automática). Si el formato especificado está disponible, el ejemplo recupera los datos utilizando el método GetData(String).

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[];
}

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

Para obtener más ejemplos de código que recupera datos de un objeto de datos, vea Recuperar datos en un formato concreto.

Eliminar datos de un objeto de datos

Los datos no se pueden eliminar directamente de un objeto de datos. Para eliminar eficazmente los datos de un objeto de datos, siga estos pasos:

  1. Cree un nuevo objeto de datos que contenga solo los datos que desea conservar.

  2. "Copie" los datos deseados del objeto de datos antiguo al nuevo objeto de datos. Para copiar los datos, utilice uno de los métodos GetData para recuperar un Object que contenga los datos sin procesar, y luego utilice uno de los métodos SetData para añadir los datos al nuevo objeto de datos.

  3. Reemplace el objeto de datos anterior por el nuevo.

Nota:

Los métodos SetData solo añaden datos a un objeto de datos; no reemplazan los datos, incluso si los datos y el formato de los datos son exactamente los mismos que una llamada anterior. Si se llama a SetData dos veces para los mismos datos y el mismo formato de datos, los datos/formato de datos estarán presentes dos veces en el objeto de datos.