Données et objets de données

Les données transférées dans le cadre d’une opération de glisser-déplacer sont stockées dans un objet de données. Conceptuellement, un objet de données se compose d’une ou plusieurs des paires suivantes :

• Un Object qui contient les données réelles.

• Identificateur de format de données correspondant.

Les données elles-mêmes peuvent se composer de tout ce qui peut être représenté en tant que base Object. Le format de données correspondant est une chaîne ou un Type qui fournit un indicateur sur le format dans lequel se trouve les données. Les objets de données prennent en charge l’hébergement de plusieurs paires de format de données/données ; cela permet à un objet de données unique de fournir des données dans plusieurs formats.

Objets de données

Tous les objets de données doivent implémenter l’interface IDataObject, qui fournit l’ensemble standard suivant de méthodes qui permettent et facilitent le transfert de données.

WPF fournit une implémentation de base de IDataObject dans la classe DataObject. La classe DataObject stock est suffisante pour de nombreux scénarios de transfert de données courants.

Il existe plusieurs formats prédéfinis, tels que bitmap, CSV, fichier, HTML, RTF, chaîne, texte et audio. Pour plus d’informations sur les formats de données prédéfinis fournis avec WPF, consultez la rubrique de référence de classe DataFormats.

Les objets de données incluent généralement une fonctionnalité permettant de convertir automatiquement les données stockées dans un format différent tout en extrayant des données ; cette installation est appelée conversion automatique. Lors de l’interrogation des formats de données disponibles dans un objet de données, les formats de données convertibles automatiquement peuvent être filtrés à partir de formats de données natifs en appelant la méthode GetFormats(Boolean) ou GetDataPresent(String, Boolean) et en spécifiant le paramètre autoConvert comme false. Lors de l’ajout de données à un objet de données avec la méthode SetData(String, Object, Boolean), la conversion automatique des données peut être interdite en définissant le paramètre autoConvert sur false.

Utilisation d’objets de données

Cette section décrit les techniques courantes de création et d’utilisation d’objets de données.

Création d’objets de données

La classe DataObject fournit plusieurs constructeurs surchargés qui facilitent la remplissage d’une nouvelle instance DataObject avec une paire de format de données/données unique.

L’exemple de code suivant crée un objet de données et utilise l’un des constructeurs surchargés DataObject(DataObject(String, Object)) pour initialiser l’objet de données avec une chaîne et un format de données spécifié. Dans ce cas, le format de données est spécifié par une chaîne ; la classe DataFormats fournit un ensemble de chaînes de type prédéfinies. La conversion automatique des données stockées est autorisée par défaut.

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)

Pour plus d’exemples de code qui crée un objet de données, consultez Créer un objet de données.

Stockage de données dans plusieurs formats

Un objet de données unique est en mesure de stocker des données dans plusieurs formats. L’utilisation stratégique de plusieurs formats de données dans un seul objet de données peut potentiellement rendre l’objet de données consommable par une plus grande variété de cibles de suppression que si seul un format de données unique peut être représenté. Notez que, en général, une source de glissement doit être indépendante des formats de données consommables par les cibles de déplacement potentielles.

L’exemple suivant montre comment utiliser la méthode SetData(String, Object) pour ajouter des données à un objet de données dans plusieurs formats.

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)

Interrogation d’un objet de données pour les formats disponibles

Étant donné qu’un objet de données unique peut contenir un nombre arbitraire de formats de données, les objets de données incluent des fonctionnalités permettant de récupérer une liste de formats de données disponibles.

L’exemple de code suivant utilise la surcharge GetFormats pour obtenir un tableau de chaînes indiquant tous les formats de données disponibles dans un objet de données (natif et par conversion automatique).

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

Pour plus d’exemples de code qui interroge un objet de données pour les formats de données disponibles, consultez Répertorier les formats de données dans un objet de données. Pour obtenir des exemples d’interrogation d’un objet de données pour la présence d’un format de données particulier, consultez Déterminer si un format de données est présent dans un objet de données.

Récupération de données à partir d’un objet de données

La récupération de données à partir d’un objet de données dans un format particulier implique simplement d’appeler l’une des méthodes GetData et de spécifier le format de données souhaité. L’une des méthodes GetDataPresent peut être utilisée pour vérifier la présence d’un format de données particulier. GetData retourne les données dans un Object. Selon le format des données, cet objet peut être converti en un conteneur de type spécifique.

L’exemple de code suivant utilise la surcharge de GetDataPresent(String) pour vérifier si un format de données spécifié est disponible (natif ou par conversion automatique). Si le format spécifié est disponible, l’exemple récupère les données à l’aide de la méthode 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

Pour plus d’exemples de code qui récupère des données à partir d’un objet de données, consultez Récupérer des données dans un format de données particulier.

Suppression de données d’un objet de données

Les données ne peuvent pas être directement supprimées d’un objet de données. Pour supprimer efficacement les données d’un objet de données, procédez comme suit :

1. Créez un objet de données qui contiendra uniquement les données que vous souhaitez conserver.

2. Copiez les données souhaitées de l’ancien objet de données vers le nouvel objet de données. Pour copier les données, utilisez l’une des méthodes GetData pour récupérer un Object qui contient les données brutes, puis utilisez l’une des méthodes SetData pour ajouter les données au nouvel objet de données.

3. Remplacez l’ancien objet de données par le nouvel objet.