Procédure pas à pas : création d'un générateur de données personnalisé qui regroupe des générateurs standard

Article
08/21/2008

Mise à jour : novembre 2007

Dans Visual Studio Team System Database Edition, vous pouvez créer des instances des classes de générateur de données standard dans vos classes de générateur de données personnalisé. En suivant cette approche, vous pouvez facilement réduire la quantité de logique à inclure dans vos générateurs de données personnalisés. Par exemple, vous pouvez créer un générateur qui génère des données de chaîne aléatoires qui correspondent à plusieurs modèles complexes. Vous pouvez créer un générateur de données personnalisé qui contient la logique permettant de gérer les modèles multiples et vous pouvez utiliser le générateur RegularExpression standard pour gérer la mise en correspondance de modèles complexes.

Dans cette procédure pas à pas, vous créez un générateur de données personnalisé qui regroupe le générateur DateTime standard. Vous créez un générateur qui génère des données qui se trouvent dans l'une de deux plages de dates distinctes. Le générateur accepte deux plages distinctes comme entrée, puis génère une date aléatoire qui figure dans l'une des deux plages.

Remarque :
Pour plus d'informations sur l'objectif de ce générateur de données personnalisé et pour apprendre à atteindre le même objectif en utilisant une extensibilité normale, consultez Procédure pas à pas : création d'un générateur de données personnalisé pour une contrainte de validation.

Dans cette procédure pas à pas, vous exécutez les tâches suivantes :

Créer une classe qui hérite de Generator.
Créer des propriétés d'entrée afin que l'utilisateur puisse indiquer les deux plages de dates.
Créer une propriété de sortie à utiliser comme sortie de générateur.
Créer deux instances du générateur DateTime standard pour représenter chacune des deux plages possibles.
Substituer les méthodes Generator et, au sein de celles-ci, déléguer le travail aux générateurs standard.
Signer le générateur avec un nom fort.

Composants requis

Pour exécuter cette procédure pas à pas, vous devez disposer des éléments suivants :

Database Edition

Création de la classe du générateur de données personnalisé

Pour créer la classe du générateur de données personnalisé

Dans Visual Studio, créez un projet Bibliothèque de classes dans le langage de votre choix, puis nommez-le GeneratorDateRanges2.
Dans le menu Projet, cliquez sur Ajouter une référence.

La boîte de dialogue Ajouter une référence s'affiche.
Cliquez sur l'onglet .NET. Dans la liste Nom du composant, cliquez sur Microsoft.VisualStudio.TeamSystem.Data, puis sur OK.
Dans le menu Projet, cliquez sur Ajouter une référence.

La boîte de dialogue Ajouter une référence s'affiche.
Cliquez sur l'onglet Parcourir, puis recherchez l'emplacement ...\Program Files\Microsoft Visual Studio 9.0\DBPro\Extensions.
Cliquez sur Microsoft.VisualStudio.TeamSystem.Data.Generators.dll, puis sur OK.
(Facultatif, Visual Basic uniquement) Dans l'Explorateur de solutions, cliquez sur Afficher tous les fichiers, puis développez le nœud Références pour vérifier les nouvelles références.

En haut de la fenêtre Code, avant la déclaration de classe, ajoutez la ligne de code suivante :

Imports Microsoft.VisualStudio.TeamSystem.Data.DataGenerator
Imports Microsoft.VisualStudio.TeamSystem.Data.Generators
Imports System.Data.SqlTypes

using Microsoft.VisualStudio.TeamSystem.Data.DataGenerator;
using Microsoft.VisualStudio.TeamSystem.Data.Generators;
using System.Data.SqlTypes;

Renommez la classe Class1 en GeneratorDateRanges2, puis indiquez qu'elle hérite de Generator, comme illustré dans l'exemple suivant.

Attention :
Par défaut, le nom que vous donnez à votre classe est le nom qui apparaît dans la liste affichée dans la colonne Générateur de la fenêtre Détails de la colonne. Vous devez spécifier un nom qui ne crée pas de conflit avec le nom d'un générateur standard ou d'un autre générateur personnalisé.

Public Class GeneratorDateRanges2
    Inherits Generator

End Class

public class GeneratorDateRanges2: Generator
{
}

Dans le menu Fichier, cliquez sur Enregistrer tout.

Ajout des propriétés d'entrée

Ce générateur de données personnalisé accepte deux plages de dates comme entrée. Pour spécifier chaque plage, l'utilisateur indique les dates minimales et maximales pour chacune d'elles. Par conséquent, vous devez créer quatre propriétés d'entrée au total : deux dates minimales et deux dates maximales.

Pour ajouter les propriétés d'entrée

Créez quatre variables membres pour contenir les dates minimales et maximales des deux plages de dates, comme illustré dans l'exemple suivant.

Dim range1MinValue As SqlDateTime
Dim range1MaxValue As SqlDateTime

Dim range2MinValue As SqlDateTime
Dim range2MaxValue As SqlDateTime

SqlDateTime range1MinValue;
SqlDateTime range1MaxValue;

SqlDateTime range2MinValue;
SqlDateTime range2MaxValue;

Créez quatre propriétés pour définir les dates minimales et maximales des deux plages de dates, comme illustré dans l'exemple suivant. Les propriétés doivent comporter l'InputAttribute pour les identifier comme propriétés d'entrée.

<Input(Visible:= true, TypeConverter:= GetType(SqlDateTimeConverter))> _
Public Property Range1Min() As SqlDateTime
    Set(ByVal value As SqlDateTime)
        range1MinValue = value
    End Set
    Get
        Return range1MinValue
    End Get
End Property

<Input(Visible:= true, TypeConverter:= GetType(SqlDateTimeConverter))> _
Public Property Range1Max() As SqlDateTime
    Set(ByVal value As SqlDateTime)
        range1MaxValue = value
    End Set
    Get
        Return range1MaxValue
    End Get
End Property

<Input(Visible:= true, TypeConverter:= GetType(SqlDateTimeConverter))> _
Public Property Range2Min() As SqlDateTime
    Set(ByVal value As SqlDateTime)
        range2MinValue = value
    End Set
    Get
        Return range2MinValue
    End Get
End Property

<Input(Visible:= true, TypeConverter:= GetType(SqlDateTimeConverter))> _
Public Property Range2Max() As SqlDateTime
    Set(ByVal value As SqlDateTime)
        range2MaxValue = value
    End Set
    Get
        Return range2MaxValue
    End Get
End Property

[Input(Visible = true, TypeConverter = typeof(SqlDateTimeConverter))]
public SqlDateTime Range1Min
{
    set {range1MinValue = value;}
    get {return range1MinValue;}
}

[Input(Visible = true, TypeConverter = typeof(SqlDateTimeConverter))]
public SqlDateTime Range1Max
{
    set {range1MaxValue = value;}
    get {return range1MaxValue;}
}

[Input(Visible = true, TypeConverter = typeof(SqlDateTimeConverter))]
public SqlDateTime Range2Min
{
    set {range2MinValue = value;}
    get {return range2MinValue;}
}

[Input(Visible = true, TypeConverter = typeof(SqlDateTimeConverter))]
public SqlDateTime Range2Max
{
    set {range2MaxValue = value;}
    get {return range2MaxValue;}
}

Dans le menu Fichier, cliquez sur Enregistrer tout.

Ajout de la propriété de sortie

Ce générateur de données personnalisé retourne une date aléatoire en tant que sortie. Par conséquent, vous devez créer une propriété de sortie.

Pour ajouter la propriété de sortie

Créez une variable membre pour contenir la date aléatoire qui représente la sortie, comme illustré dans l'exemple suivant.
```
Dim randomDateValue As SqlDateTime
```
```
SqlDateTime randomDateValue;
```
Créez une propriété pour retourner la date aléatoire en tant que sortie, comme illustré dans l'exemple suivant. La propriété doit comporter l'OutputAttribute pour l'identifier comme propriété de sortie.
```
<Output()> _
Public ReadOnly Property RandomDate() As SqlDateTime
    Get
        Return randomDateValue
    End Get
End Property
```
```
[Output]
public SqlDateTime RandomDate
{
    get {return randomDateValue;}
}
```
Dans le menu Fichier, cliquez sur Enregistrer tout.

Substitution de la méthode OnInitialize

Pour substituer la méthode OnInitialize

Créez une variable membre pour générer des nombres aléatoires, comme indiqué dans l'exemple suivant. Cette variable effectue un choix aléatoire entre les deux plages de dates possibles.
```
Dim randomRange As Random
```
```
Random randomRange;
```

Créez et instanciez deux variables membres qui sont les générateurs DateTime standard, comme illustré dans l'exemple suivant.

Dim range1 As DatabaseDateTime = New DatabaseDateTime()
Dim range2 As DatabaseDateTime = New DatabaseDateTime()

DatabaseDateTime range1 = new DatabaseDateTime();
DatabaseDateTime range2 = new DatabaseDateTime();

Substituez la méthode OnInitialize, comme illustré dans l'exemple suivant. Dans cette méthode, vous donnez une valeur de départ à l'objet Random et rendez votre générateur déterministe. Vous appelez également la méthode Initialize des générateurs standard.

Protected Overrides Sub OnInitialize(ByVal initInfo As GeneratorInit)

    randomRange = New Random(Me.Seed)  'deterministic

    range1.Initialize(initInfo)
    range2.Initialize(initInfo)

    MyBase.OnInitialize(initInfo)
End Sub

protected override void OnInitialize(GeneratorInit initInfo)
{
    randomRange = new Random(this.Seed);  //deterministic

    range1.Initialize(initInfo);
    range2.Initialize(initInfo);

    base.OnInitialize(initInfo);
}

Dans le menu Fichier, cliquez sur Enregistrer tout.

Substitution d'autres méthodes

Pour substituer d'autres méthodes

Substituez OnSetInputValues, comme illustré dans l'exemple suivant. Le paramètre inputs à cette méthode est un IDictionary de toutes les propriétés de générateur standard définies par l'utilisateur, telles que les propriétés Valeur de départ et Pourcentage Null. Vous appelez les méthodes SetInputValues des générateurs standard pour leur passer ces valeurs. Vous définissez ensuite les propriétés Min et Max de chaque générateur standard avec les propriétés d'entrée personnalisées créées dans ce générateur de données.

Protected Overrides Sub OnSetInputValues(ByVal inputs As IDictionary(Of String, Object))

    'It is important to call MyBase.OnSetInputValues first to get the inputs
    'from the Properties window first.
    '--------------------------------------------------------------------------
    MyBase.OnSetInputValues(inputs)

    range1.SetInputValues(inputs)
    range2.SetInputValues(inputs)

    range1.Min = range1MinValue
    range1.Max = range1MaxValue
    range2.Min = range2MinValue
    range2.Max = range2MaxValue

    range1.Distribution = New Uniform()
    range2.Distribution = New Uniform()
End Sub

protected override void OnSetInputValues(IDictionary<string, object> inputs)
{
    //It is important to call base.OnSetInputValues first to get the inputs
    //from the Properties window first.
    //-------------------------------------------------------------------------
    base.OnSetInputValues(inputs);

    range1.SetInputValues(inputs);
    range2.SetInputValues(inputs);

    range1.Min = range1MinValue;
    range1.Max = range1MaxValue;
    range2.Min = range2MinValue;
    range2.Max = range2MaxValue;

    range1.Distribution = new Uniform();
    range2.Distribution = new Uniform();
}

Substituez OnValidateInputs pour valider les entrées, comme illustré dans l'exemple suivant.

Protected Overrides Sub OnValidateInputs()

    range1.ValidateInputs()
    range2.ValidateInputs()

    MyBase.OnValidateInputs()
End Sub

protected override void OnValidateInputs()
{
    range1.ValidateInputs();
    range2.ValidateInputs();

    base.OnValidateInputs();
}

Substituez la méthode Dispose(Boolean) pour nettoyer les générateurs standard, comme illustré dans l'exemple suivant.

Protected Overrides Sub Dispose(ByVal disposing As Boolean)

    range1.Dispose()
    range2.Dispose()

    MyBase.Dispose(disposing)
End Sub

protected override void Dispose(bool disposing)
{
    range1.Dispose();
    range2.Dispose();

    base.Dispose(disposing);
}

Dans le menu Fichier, cliquez sur Enregistrer tout.

Substitution de la méthode OnGenerateNextValues

Database Edition appelle la méthode OnGenerateNextValues du générateur pour créer les données nécessaires. Vous devez substituer cette méthode pour fournir la logique qui génère la date aléatoire pour la propriété de sortie. Dans cette procédure pas à pas, vous déléguez la responsabilité de la génération de la date aléatoire au générateur DateTime standard.

Pour substituer la méthode OnGenerateNextValues

Substituez la méthode OnGenerateNextValues, comme illustré dans l'exemple suivant.

Protected Overrides Sub OnGenerateNextValues()

    'Generate a random date from either range 1 or range 2.
    'Randomly select either range 1 or range 2 by randomly 
    'generating an odd or an even random number.
    '------------------------------------------------------------
    If (randomRange.Next() Mod 2 = 0) Then  'check for odd or even

        'the standard generator does the work
        range1.GenerateNextValues()
        randomDateValue = range1.Result.Value
    Else
        'the standard generator does the work
        range2.GenerateNextValues()
        randomDateValue = range2.Result.Value
    End If

    MyBase.OnGenerateNextValues()
End Sub

protected override void OnGenerateNextValues()
{
    //Generate a random date from either range 1 or range 2.
    //Randomly select either range 1 or range 2 by randomly 
    //generating an odd or an even random number.
    //------------------------------------------------------------
    if (randomRange.Next() % 2 == 0)  //check for odd or even
    {
        //the standard generator does the work
        range1.GenerateNextValues();
        randomDateValue = range1.Result.Value;
    }
    else
    {
        //the standard generator does the work
        range2.GenerateNextValues();
        randomDateValue = range2.Result.Value;
    }

    base.OnGenerateNextValues();
}

Dans le menu Fichier, cliquez sur Enregistrer tout.

Définition du convertisseur de type

Pour spécifier les propriétés d'entrée pour ce générateur de données dans la fenêtre Propriétés, vous devez fournir un convertisseur de type qui convertit les valeurs d'entrée vers et depuis le type SqlDateTime.

Pour créer la classe de convertisseur de type SqlDateTime

Dans le menu Projet, cliquez sur Ajouter une classe.

La boîte de dialogue Ajouter un nouvel élément s'affiche alors.
Dans la zone Nom, tapez SqlDateTimeConverter.

En haut de la fenêtre Code, avant la déclaration de classe, ajoutez les lignes de code suivantes :

Imports System.ComponentModel
Imports System.Data.SqlTypes
Imports System.Globalization

using System.ComponentModel;
using System.Data.SqlTypes;
using System.Globalization;

Renommez la classe Class1 en GeneratorDateRanges, puis indiquez qu'elle hérite de TypeConverter.

Public Class SqlDateTimeConverter
    Inherits TypeConverter

End Class

public class SqlDateTimeConverter: TypeConverter
{
}

Dans la déclaration de classe, ajoutez le constructeur de classe. Si vous écrivez la classe de convertisseur de type dans Visual Basic, passez à étape 6.
```
public SqlDateTimeConverter()
{
}
```

Suivant le constructeur de classe, ajoutez une méthode qui vérifie si ce convertisseur de type peut exécuter une conversion particulière.

Public Overrides Function CanConvertFrom(ByVal context As ITypeDescriptorContext, ByVal sourceType As Type) As Boolean
    Dim result As Boolean
    result = False
    If (sourceType Is GetType(System.String)) Then
        result = True
    Else
        result = MyBase.CanConvertFrom(context, sourceType)
    End If
    Return result
End Function

public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
    bool result = false;
    if (sourceType == typeof(string))
    {
        result = true;
    }
    else
    {
        result = base.CanConvertFrom(context, sourceType);
    }
    return result;
}

Enfin, ajoutez les méthodes du convertisseur.

Public Overrides Function ConvertFrom(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal culture As System.Globalization.CultureInfo, ByVal value As Object) As Object
    Dim dateTimeString As String
    dateTimeString = value.ToString
    If (dateTimeString.Length > 0) Then
        Dim dateTime As Date
        dateTime = Date.Parse(dateTimeString, culture)
        Return New SqlDateTime(dateTime)
    End If
    Return MyBase.ConvertFrom(context, culture, value)
End Function

Public Overrides Function CanConvertTo(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal destinationType As System.Type) As Boolean
    If (destinationType Is GetType(System.String)) Then
        Return True
    End If
    Return MyBase.CanConvertTo(context, destinationType)
End Function

Public Overrides Function ConvertTo(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal culture As System.Globalization.CultureInfo, ByVal value As Object, ByVal destinationType As System.Type) As Object
    If (destinationType Is GetType(System.String)) Then
        Dim dateTime As Date
        dateTime = CType(value, SqlDateTime).Value
        dateTime.ToString(culture)
    End If
    Return MyBase.ConvertTo(context, culture, value, destinationType)
End Function

        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            string dateTimeString = value as string;
            if (dateTimeString != null)
            {
                DateTime dateTime = DateTime.Parse(dateTimeString, culture);
                return new SqlDateTime(dateTime);
            }
            return base.ConvertFrom(context, culture, value);
        }

        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            if (destinationType == typeof(string))
            {
                return true;
            }
            return base.CanConvertTo(context, destinationType);
        }

        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string))
            {
                DateTime dateTime = ((SqlDateTime)value).Value;
                dateTime.ToString(culture);
            }
            return base.ConvertTo(context, culture, value, destinationType);
        }

Dans le menu Fichier, cliquez sur Enregistrer tout.

Signature du générateur

Tous les générateurs de données personnalisés doivent être signés avec un nom fort avant d'être inscrits.

Pour signer le générateur avec un nom fort

Dans le menu Projet, cliquez sur Propriétés de GeneratorDateRanges2 pour ouvrir les propriétés du projet.
Sous l'onglet Signature, activez la case à cocher Signer l'assembly.
Dans la zone Choisir un fichier de clé de nom fort, cliquez sur <Nouveau...>.
Dans la zone Nom du fichier de clé, tapez GeneratorDateRanges2Key, tapez et confirmez un mot de passe, puis cliquez sur OK.

Lorsque vous générez votre solution, le fichier de clé est utilisé pour signer l'assembly.
Dans le menu Fichier, cliquez sur Enregistrer tout.
Dans le menu Générer, cliquez sur Générer la solution.

Votre générateur de données a maintenant été généré. Vous devez ensuite l'inscrire sur votre ordinateur afin de pouvoir l'utiliser dans des plans de génération de données.

Sécurité

Pour plus d'informations, consultez Sécurité des générateurs de données.

Étapes suivantes

Maintenant que vous avez généré votre générateur de données, vous devez l'inscrire sur votre ordinateur. Pour plus d'informations, consultez l'une des rubriques suivantes :

Voir aussi

Partager via