Procédure pas à pas : création d'un générateur de données personnalisé

Article
08/15/2011

Lorsque vous développez votre schéma de base de données, vous pouvez tester plus efficacement les modifications proposées en remplissant une base de données de test avec les données qui représentent les données de production de la manière la plus fidèle possible. Les générateurs de données personnalisés fournissent des données de test qui satisfont vos spécifications de manière plus précise que les générateurs de données intégrés. Par exemple, vous pouvez créer un générateur pour remplir une colonne de table avec des chaînes aléatoires dans une liste ou avec des nombres d'une plage que vous spécifiez. Pour plus d'informations, consultez Vue d'ensemble de l'extensibilité des générateurs de données.

Dans cette rubrique pas à pas, vous créerez un générateur de données personnalisé qui génère des chaînes d'adresse aléatoires. Dans cette procédure pas à pas, vous exécuterez les tâches suivantes :

Créer une bibliothèque de classes pour votre générateur de données d'adresses personnalisé qui hérite de Generator.
Ajouter une propriété de sortie à utiliser comme sortie de générateur.
Substituer la méthode OnGenerateNextValues pour générer les données.
Signer l'assembly du générateur.
Créer un fichier XML associé à l'assembly utilisé pour l'inscription.
Créer un projet de base de données et un plan de génération de données pour tester votre générateur de données personnalisé.

Composants requis

Pour effectuer cette procédure, il est indispensable d'installer Visual Studio Premium ou Visual Studio Ultimate.

Création d'une bibliothèque de classes pour le générateur personnalisé

La première étape consiste à créer une bibliothèque de classes pour votre générateur d'adresses personnalisé.

Pour créer une bibliothèque de classes pour un générateur personnalisé

Créez un projet de bibliothèque de classes Visual C# et nommez-le SampleGenerator.
Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis cliquez sur Ajouter une référence.
Cliquez sur l'onglet .NET.
Dans la colonne Nom du composant, sélectionnez les composants suivants :
- Microsoft.Data.Schema
- Microsoft.Data.Schema.Sql
- Microsoft.Data.Schema.Tools
Conseil

Appuyez sur CTRL tout en cliquant pour sélectionner plusieurs composants.
Cliquez sur OK lorsque vous avez sélectionné tous les composants requis.

Les références sélectionnées s'afficheront sous le nœud Références du projet dans l'Explorateur de solutions.

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

using Microsoft.Data.Schema.Tools.DataGenerator;
using Microsoft.Data.Schema.Extensibility;
using Microsoft.Data.Schema;
using Microsoft.Data.Schema.Sql;

Renommez la classe Class1 en AddressGenerator.

Avertissement

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 n'est pas en conflit avec le nom d'un générateur intégré ou le nom d'un autre générateur personnalisé.
```
public class AddressGenerator
{
}
```
Spécifiez que votre classe hérite de Generator, comme illustré dans l'exemple suivant :
```
public class AddressGenerator : Generator
{
}
```
Ajoutez le DatabaseSchemaProviderCompatibilityAttribute, comme indiqué dans l'exemple suivant :
```
[DatabaseSchemaProviderCompatibility(typeof(SqlDatabaseSchemaProvider))]
public class AddressGenerator : Generator
{
}
```
Pour plus d'informations au sujet de l'attribut de compatibilité d'extension, consultez Extension des fonctionnalités de base de données de Visual Studio.
Dans le menu Fichier, cliquez sur Enregistrer tout.

Ajout d'une propriété de sortie au générateur

Dans la section précédente, vous avez créé une bibliothèque de classes qui a hérité de la classe Generator. Dans cette section, vous ajouterez une propriété de sortie à votre classe. Les propriétés de sortie contiennent les valeurs des données générées. Les propriétés de sortie spécifient également les types de données que ce générateur peut produire.

Pour ajouter une propriété de sortie

Créez les variables membres qui seront utilisées pour la génération de l'adresse, comme indiqué dans l'exemple suivant.

La variable _address sera utilisée lors d'une étape ultérieure dans une propriété de sortie.

private Random _random;
private string _street;
private string _city;
private string _state;
private int _zipCode;
private string _address;

private static readonly List<String> _states =
            new List<string>() { "AK", "AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY" };

Créez une propriété privée pour la variable membre de _random, comme indiqué dans l'exemple suivant :

private Random Random
        {
            get
            {
                if (_random == null)
                    _random = new Random(base.Seed);

                return _random;
            }
        }

Créez une propriété publique pour la variable membre _address et ajoutez-lui l'OutputAttribute, comme indiqué dans l'exemple suivant :

[Output(Description = "Generates street and city values of \"2150 Newton Street, San Francisco\", with random state and zip code.", Name = "Address")]
        public string Address
        {
            get
            {
                return this._address;
            }
        }

Dans le menu Fichier, cliquez sur Enregistrer tout.

Substitution de la méthode OnGenerateNextValues

Visual Studio appelle la méthode OnGenerateNextValues de chaque générateur pour chaque ensemble de valeurs dont il a besoin. Lorsque vous créez un générateur de données, vous devez substituer cette méthode pour fournir une logique qui génère de nouvelles valeurs pour chacune de vos propriétés de sortie.

Pour substituer la méthode OnGenerateNextValues

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

protected override void OnGenerateNextValues()
{
    this._street = "2150 Newton Street";
            this._city = "San Francisco";
            this._state = _states[Random.Next(0, _states.Count)];
            this._zipCode = Int32.Parse(String.Format("{0}{1}{2}{3}{4}", GetRandomDigit(1), GetRandomDigit(), GetRandomDigit(), GetRandomDigit(), GetRandomDigit()));
            this._address = String.Format("{0}, {1}, {2} {3}", _street, _city, _state, _zipCode);
}

Ajoutez les méthodes suivantes, utilisées pour la création de la valeur pour la variable _zipcode :

private int GetRandomDigit()
        {
            return GetRandomDigit(0);
        }

        private int GetRandomDigit(int lowNumber)
        {
            return Random.Next(lowNumber, 10);
        }

Dans le menu Fichier, cliquez sur Enregistrer tout.

Signature du générateur

Ensuite, vous devez signer le générateur de données personnalisé avec un nom fort.

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

Dans le menu Projet, cliquez sur Propriétés SampleGenerator.
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...>.

La boîte de dialogue Créer une clé de nom fort s'affiche.
Dans la zone Nom du fichier de clé, tapez SampleGeneratorKey.
Saisissez et confirmez le 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.

Vous avez créé un générateur de données personnalisé.

Enregistrement de l'assembly de générateur

Une fois votre assembly signé et compilé, vous allez, à présent, collecter les informations de l'assembly générées dans le projet, notamment la version, la culture et le PublicKeyToken pour faciliter l'enregistrement de l'assembly du générateur.

Pour collecter des informations de l'assembly

Dans le menu Affichage, cliquez sur Autres fenêtres, puis cliquez sur Fenêtre Commande pour ouvrir la fenêtre Commande.
Dans la fenêtre Commande, tapez le code suivant. Pour FilePath, substituez le chemin d'accès et le nom de votre fichier .dll compilé. Placez le chemin d'accès et le nom de fichier entre guillemets.

Notes

Par défaut, le chemin d'accès de votre fichier .dll compilé est SampleGenerator\bin\Debug.
```
? System.Reflection.Assembly.LoadFrom(@"<FilePath>").FullName
```
Appuyez sur Entrée. La ligne doit ressembler à ce qui suit, avec votre PublicKeyToken spécifique :
```
" SampleGenerator, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn"
```
Notez ou copiez les informations de cet assembly, car elles seront utilisées dans la procédure suivante.

Ensuite, vous créez un fichier XML en utilisant les informations d'assembly collectées lors de la procédure précédente.

Pour créer le fichier XML

Dans l'Explorateur de solutions, sélectionnez le projet SampleGenerator.
Dans le menu Projet, cliquez sur Ajouter un nouvel élément.
Dans le volet Modèles, recherchez et sélectionnez l'élément Fichier XML.
Dans la zone de texte Nom, tapez SampleGenerator.Extensions.xml, puis cliquez sur le bouton Ajouter.

Le fichier SampleGenerator.Extensions.xml est ajouté au projet dans l'Explorateur de solutions.

Notes

Vous devez utiliser le nom de votre dll (dans ce cas, « SampleGenerator » suivi de « .Extensions.xml ») pour que l'enregistrement de l'assembly se fasse correctement.

Ouvrez le fichier SampleGenerator.Extensions.xml et mettez-le à jour pour qu'il corresponde au fichier XML suivant. Remplacez les données de l'assembly (version, culture et PublicKeyToken) que vous avez extraites au cours de la procédure précédente.

Notes

Le type d'extension doit utiliser le nom qualifié complet de la classe. Dans ce cas: type d'extension = « SampleGenerator.AddressGenerator ».

<?xml version="1.0" encoding="utf-8"?>
<extensions assembly="" version="1" xmlns="urn:Microsoft.Data.Schema.Extensions" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="urn:Microsoft.Data.Schema.Extensions Microsoft.Data.Schema.Extensions.xsd">
 
<extension type="SampleGenerator.AddressGenerator" assembly="SampleGenerator, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn" enabled="true"/>
 
</extensions>

Dans le menu Fichier, cliquez sur Enregistrer tout.

L'étape suivante vous invite à copier l'assembly et le fichier XML dans le répertoire Extensions. Au démarrage de Visual Studio Premium, celui-ci se charge d'identifier les extensions à l'intérieur du répertoire et des sous-répertoires %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions et de les enregistrer en vue de les utiliser au cours de la session.

Pour copier et enregistrer l'assembly et le fichier XML dans le répertoire Extensions

Créez un dossier appelé CustomGenerators dans le répertoire %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\.
Copiez le fichier assembly SampleGenerator.dll du répertoire ProjectFolder\SampleGenerator\SampleGenerator\bin\Debug\ vers le répertoire %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\ CustomGenerators que vous avez créé.
Copiez le fichier SampleGenerator.Extensions.xml du répertoire ProjectFolder\SampleGenerator\SampleGenerator\ vers le répertoire %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\ CustomGenerators que vous avez créé.

Notes

Il est recommandé de placer vos assemblys d'extension dans un même dossier au sein du répertoire %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions. Cette stratégie vous aidera à identifier les extensions incluses dans le produit et celles qui correspondent à vos créations personnalisées. Vous devez envisager d'organiser également vos extensions en dossiers spécifiques à la catégorie.

Test du générateur d'adresses

Maintenant que vous avez créé le générateur de données d'adresses, vous devez démarrer une nouvelle instance de Visual Studio. Lorsque Visual Studio démarrera, il enregistrera l'assembly SampleGenerator que vous avez ajouté %Program Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomGenerators. Vous créerez ensuite un projet de base de données dans lequel vous pouvez vérifier que le générateur de données d'adresses fonctionne correctement.

Pour créer le projet de base de données

Démarrez une nouvelle instance de Visual Studio, qui reconnaîtra l'assembly SampleGenerator.dll et l'enregistrera.
Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.

La boîte de dialogue Nouveau projet s'affiche.
Sous Modèles installés, développez le nœud Base de données, puis cliquez sur le nœud SQL Server.
Dans la liste des modèles, cliquez sur Projet de base de données SQL Server 2008.
Dans Nom, tapez SampleGeneratorDB.

Notes

Si vous avez déjà effectué toutes les étapes de Procédure pas à pas : création d'un générateur de données personnalisé pour une contrainte de validation, vous avez créé le projet SampleGeneratorDB et vous pouvez passer à l'étape 9.
Activez la case à cocher Créer le répertoire pour la solution.
Acceptez les valeurs par défaut pour l'Emplacement, Nom de solution, puis Ajouter au contrôle de code source, et enfin cliquez sur OK.
Cliquez sur OK.

Le nouveau projet de base de données, SampleGeneratorDB, s'affiche dans l'Explorateur de solutions.
Dans le menu Affichage, cliquez sur Vue Schéma de base de données.

La vue Schéma s'affiche si elle n'était pas déjà visible.

Ensuite, vous ajouterez une table simple au projet, avec une colonne unique et un type SQL varchar.

Pour ajouter une table au projet de base de données

Dans la Vue Schéma, développez le nœud SampleGeneratorDB, puis le nœud Schémas, développez le nœud dbo, puis cliquez sur Tables.
Dans le menu Projet, cliquez sur Ajouter un nouvel élément.

Notes

Vous pouvez également cliquer avec le bouton droit sur le projet SampleGeneratorDB dans la Vue Schéma, pointer sur Ajouter, puis cliquer sur Table.
Dans Modèles, cliquez sur Table.

Notes

Dans la liste Catégories, vous pouvez cliquer sur Tables et vues pour rechercher plus facilement un modèle de table.
Dans Nom, tapez Addresses pour attribuer ce nom à la nouvelle table.
Cliquez sur Ajouter pour ajouter la table au projet de base de données.

L'Explorateur de solutions affiche le nouveau fichier pour la table dans votre projet de base de données. La vue Schéma affiche le nouvel objet table. L'éditeur Transact-SQL apparaît et affiche la définition de votre nouvelle table.
Dans l'éditeur Transact-SQL, modifiez la définition de la table afin qu'elle corresponde à l'exemple suivant :
```
CREATE TABLE [dbo].[Addresses]
(
address varchar(100)
)
```
Dans le menu Fichier, cliquez sur Enregistrer Addresses.table.sql.

Une fois la table en place, vous pouvez à présent configurer la base de données pour le déploiement.

Pour configurer les paramètres de déploiement du projet

Dans l'Explorateur de solutions, cliquez sur SampleGeneratorDB (le projet, pas la solution).
Dans le menu Projet, cliquez sur Propriétés SampleGeneratorDB.

La fenêtre Propriétés du projet s'affiche.

Notes

Vous pouvez également cliquer avec le bouton droit sur SampleGeneratorDB dans l'Explorateur de solutions, puis cliquer sur Propriétés.
Cliquez sur l'onglet Déployer.
Dans la liste Déployer une action, cliquez sur Créer un script de déploiement (.sql) et le déployer vers la base de données.
Cliquez sur le bouton Modifier pour spécifier la connexion cible.
Spécifiez les informations de connexion au serveur de base de données vers lequel vous souhaitez déployer la base de données SampleGeneratorDB.
Dans Sélectionner ou entrer un nom de base de données, tapez SampleGeneratorDB.
Cliquez sur OK.

Connexion cible est rempli avec la chaîne de connexion. Notez que le Nom de la base de données cible a la valeur SampleGeneratorDB.
Acceptez les valeurs par défaut pour les autres options.
Dans le menu Fichier, cliquez sur Enregistrer les éléments sélectionnés.

Les paramètres de génération du projet sont enregistrés.

Ensuite, vous générerez le projet de base de données.

Pour générer le projet de base de données

Dans le menu Générer, cliquez sur Générer la solution.

Votre projet de base de données est généré. En cas de réussite, le message « La génération a réussi » est visible dans la barre d'état, et les résultats de la génération sont affichés dans la fenêtre Sortie.

Ensuite, vous déploierez le projet de base de données.

Pour déployer le projet de base de données vers le serveur de base de données.

Dans l'Explorateur de solutions, cliquez sur SampleGeneratorDB (le projet, pas la solution).
Dans le menu Générer, cliquez sur Déployer SampleGeneratorDB.

Votre projet de base de données est déployé à l'aide de la connexion que vous avez spécifiée dans la configuration de build. Le message « Déploiement terminé » apparaît dans la barre d'état et dans la fenêtre Sortie.

Création et configuration du plan de génération de données

Ensuite, vous créerez le plan de génération de données. Le plan de génération de données contient les informations sur les tables et les colonnes que vous souhaitez remplir de données. Pour plus d'informations, consultez Comment : créer des plans de génération de données.

Pour créer et configurer le plan de génération de données

Dans l'Explorateur de solutions, sélectionnez le nœud Plans de génération de données.
Dans le menu Projet, cliquez sur Ajouter un nouvel élément.
Dans le volet Catégories, cliquez sur Plans de génération de données.
Dans le volet Modèles, cliquez sur Plan de génération de données.
Dans la zone de texte Nom, tapez SampleGenerator.dgen.
Cliquez sur Ajouter.

Le plan de génération de données est créé. Le plan de génération de données apparaît.

La fenêtre du plan de génération de données est divisée horizontalement en deux volets. Le volet supérieur répertorie les tables définies dans le schéma de projet de base de données, dans ce cas, la table dbo.Addresses. Le volet inférieur affiche les détails de la colonne pour la table mise en surbrillance dans le volet supérieur, dans ce cas, la colonne d'adresse.

Notes

Si la fenêtre Aperçu de la génération de données n'est pas ouverte, vous pouvez l'ouvrir en ouvrant le menu Données, en pointant sur Générateur de données, puis en cliquant sur le nom de la fenêtre Afficher un aperçu de la génération de données. Par défaut, la fenêtre Aperçu de la génération de données est ancrée et affiche des onglets au bas de la fenêtre du plan de génération de données. Pour développer la vue, cliquez sur la fenêtre, puis sur Document avec onglet dans le menu Fenêtre. Vous pouvez également cliquer avec le bouton droit dans la barre de titre, puis cliquer sur Ancrer en tant que document avec onglet.
Dans le concepteur SampleGenerator.dgen, vérifiez que la table dbo.Addresses et la colonne d'adresses sont activées.
Dans le concepteur SampleGenerator.dgen, sélectionnez la colonne d'adresse et cliquez sur le Générateur déroulant pour sélectionner l'AddressGenerator.

Votre générateur d'adresses personnalisé est maintenant configuré correctement.
Dans le menu Fichier, cliquez sur Enregistrer tout.

Exécution du plan de génération de données pour générer les adresses

Enfin, vous exécuterez le plan de génération de données et consulterez votre générateur de données d'adresses personnalisé en action.

Pour exécuter le plan pour générer les données

Dans l'Explorateur de solutions, cliquez sur SampleGenerator.dgen.

Notes

Le plan de génération de données doit également être ouvert. Si le plan n'est pas ouvert, ouvrez-le d'abord.
Dans le menu Données, pointez sur Générateur de données, puis cliquez sur Générer les données.

La boîte de dialogue Se connecter à la base de données s'affiche.
Dans la liste Informations de connexion de génération de données, cliquez sur la base de données SampleGeneratorDB, puis sur OK.
Cliquez sur Oui lorsque vous êtes invité à effacer le contenu des tables avant d'insérer de nouvelles lignes.

Les données sont générées. Dans la fenêtre Remplissage, la colonne d'état est mise à jour selon l'état de la génération de données. La barre d'état résume la génération de données pour toutes les tables.
(Facultatif) Utilisez un outil différent pour vous connecter à la base de données. Vous pouvez utiliser l'éditeur Transact-SQL fourni dans Visual Studio Premium pour cette étape. Pour plus d'informations, consultez le document Editing Database Scripts and Objects with the Transact-SQL Editor sur le site Web de Microsoft.
Affichez les nouvelles données en exécutant la requête suivante :
```
use SampleGeneratorDB

select * from dbo.Addresses
```
L'onglet Résultats doit afficher des adresses avec l'état aléatoire et les valeurs de code postal.

Étapes suivantes

Visual Studio Premium et Visual Studio Ultimate incluent le générateur DateTime, qui peut être utilisé avec les colonnes qui ont une contrainte de validation qui requiert qu'une date se situe dans une certaine plage, en utilisant les propriétés Min et Max du générateur. Dans Procédure pas à pas : création d'un générateur de données personnalisé pour une contrainte de validation, vous créerez un générateur de données personnalisé pour une colonne avec une contrainte de validation qui requiert qu'une date se situe dans l'une de deux plages distinctes.

Voir aussi

Partager via