Comment faire : implémentation une classe d'assistance DataSet JOIN dans Visual C# .NET

Traductions disponibles Traductions disponibles
Numéro d'article: 326080 - Voir les produits auxquels s'applique cet article
Agrandir tout | Réduire tout

Sommaire

Résumé

Cet article étape par étape explique comment implémenter et comment utiliser une classe DataSetHelper qui inclut du code exemple pour créer un objet DataTable à partir de deux ou plusieurs définitions de DataTable connexes et copier des enregistrements qui sont triés et filtrés à partir des objets DataTable source vers la destination DataTable .

Pour ce faire, utilisez les méthodes publiques suivantes :
  • CreateJoinTable
  • InsertJoinInto
  • SelectJoinInto
La méthode SelectJoinInto appelle le CreateJoinTable et les méthodes InsertJoinInto . Vous pouvez également utiliser un membres de méthode et de données d'assistance privée pour stocker la liste de champs analysée.

La classe DataSetHelper inclut une variable membre DataSet . Si vous le souhaitez, vous pouvez affecter un DataSet existant à la variable membre DataSet . Si la variable membre pointe vers un DataSet valide, les objets DataTable qui crée la CreateJoinTable ou la méthode SelectJoinInto sont ajoutés vers le DataSet . Dans les deux cas, l'appel de la méthode renvoie une référence à l'objet DataTable . La méthode InsertJoinInto requiert une cible existante DataTable et ne renvoie rien.

Pour plus d'informations sur les objets DataSet , cliquez sur le numéro ci-dessous pour afficher l'article correspondant dans la Base de connaissances Microsoft :
313485 INFO : présentation des ADO.NET DataSet, DataView et DataViewManager

Configuration requise

La liste suivante met en évidence le matériel recommandé, logiciel infrastructure réseau et service packs sont requis :
  • Microsoft Windows XP, Windows 2000 ou Windows NT 4.0 Service Pack 6 a
  • Microsoft Visual Studio .NET
Cet article suppose que vous êtes familiarisé avec les sujets suivants :
  • Visual C# .NET syntaxe
  • Notions fondamentales ADO.NET et la syntaxe

Classe d'environnement DataSetHelper

Le code dans cette section déclare la classe interface à laquelle tous les articles relatifs à DataSetHelper ajoutez les méthodes et les variables membres.
  1. Démarrez Visual Studio .NET.
  2. Dans le menu Fichier , pointez sur Nouveau , puis cliquez sur projet .
  3. Dans la boîte de dialogue Nouveau projet , cliquez sur projets Visual C# sous types de projet , puis cliquez sur bibliothèque de classes sous modèles .
  4. Dans la zone Nom , tapez DataSetHelper .
  5. Remplacez le code de classe par le code suivant :
    public class DataSetHelper
    {
        public DataSet ds;
    
        public DataSetHelper(ref DataSet DataSet)
        {
    	ds = DataSet;
        }
        public DataSetHelper()
        {
    	ds = null;
        }
    }
    					
    vous pouvez utiliser les deux surcharges pour le constructeur pour créer une instance de la classe avec ou sans une référence à un DataSet valide. Pour une classe qui contient une référence à un DataSet valide, les objets DataTable qui les méthodes renvoient sont également ajoutés automatiquement vers le DataSet .

Analyseur de liste de champs

Cette section contient le code d'un analyseur de liste de champ. La structure analysée est utilisée afin que le CreateJoinTable et les méthodes InsertJoinInto n'aient pas à d'analyse de la liste de champs. Ces méthodes doivent d'analyse la liste de champs si elles sont appelées à partir de la méthode SelectJoinInto ou à partir de votre propre code. La liste de champs analysée et la liste de champs non analysée sont stockées dans les variables membres privés de la classe DataSetHelper .
  1. Ajouter la définition de classe privée suivante dans la classe DataSetHelper qui vous avez créé dans la section " ":
    private class FieldInfo
    {
        public string RelationName;
        public string FieldName;	//source table field name
        public string FieldAlias;	//destination table field name
        public string Aggregate;
    }
    					
    Remarque : cette classe est commune à d'autres articles relatifs à DataSetHelper et contient des champs qui n'utilise pas de cet article.

  2. Ajouter des variables membre privé suivantes à la définition de classe immédiatement après la déclaration de DataSet :
    private System.Collections.ArrayList m_FieldInfo; private string m_FieldList; 
    					
  3. Ajoutez la méthode privée suivante à la définition de classe. Cette méthode est identique à la méthode qui est utilisée dans d'autres articles DataSetHelper .
    private void ParseFieldList(string FieldList, bool AllowRelation)
    {
        /*
         * This code parses FieldList into FieldInfo objects  and then 
         * adds them to the m_FieldInfo private member
         * 
         * FieldList systax:  [relationname.]fieldname[ alias], ...
        */ 
        if (m_FieldList == FieldList) return;
        m_FieldInfo = new System.Collections.ArrayList();
        m_FieldList = FieldList;
        FieldInfo Field; string[] FieldParts;
        string[] Fields=FieldList.Split(',');
        int i;
        for (i=0; i<=Fields.Length-1; i++)
        {
            Field=new FieldInfo();
            //parse FieldAlias
            FieldParts = Fields[i].Trim().Split(' ');
            switch (FieldParts.Length)
            {
                case 1:
                    //to be set at the end of the loop
                    break;
                case 2:
                    Field.FieldAlias=FieldParts[1];
                    break;
                default:
                    throw new Exception("Too many spaces in field definition: '" + Fields[i] + "'.");	                        
            }
            //parse FieldName and RelationName
            FieldParts = FieldParts[0].Split('.');
            switch (FieldParts.Length)
            {
                case 1: 
                    Field.FieldName=FieldParts[0];
                    break;
                case 2:
                    if (AllowRelation==false)
                        throw new Exception("Relation specifiers not permitted in field list: '" + Fields[i] + "'.");
                    Field.RelationName = FieldParts[0].Trim();
                    Field.FieldName=FieldParts[1].Trim();
                    break;
                default:
                    throw new Exception("Invalid field definition: " + Fields[i] + "'.");
            }
            if (Field.FieldAlias==null) 
                Field.FieldAlias = Field.FieldName;
            m_FieldInfo.Add (Field);
        }
    }
    					

CreateJoinTable, méthode

Cette section contient le code de la méthode CreateJoinTable .

Voici la convention d'appel de la méthode CreateJoinTable :
dt = dsHelper.CreateJoinTable("TestTable", ds.Tables["Employees"],
    "FirstName FName,LastName LName,DepartmentEmployee.DepartmentName Department");
				
cet exemple d'appel crée un nouveau DataTable avec un TableName de TestTable et de trois champs (pré, LName et service). Ces trois champs ont les même type que le prénom et les champs nom de la table Employés et le champ DepartmentName dans la table parente qui est accessible via l'objet DepartmentEmployee DataRelation de données.

Utilisez la syntaxe suivante pour spécifier les champs dans la liste de champs :
[relationname.]fieldname[ alias], ...
				
Remarque suivant pour cette syntaxe :
  • La nomcolonne et les propriétés Type de données sont les propriétés uniquement qui sont copiées dans la destination du DataTable .
  • Le résultat calculé est copié pour les champs qui contiennent une expression.
  • Vous pouvez renommer un champ de la destination du DataTable en spécifiant un nom d'alias.
  • La liste champ peut contenir un sous-ensemble de noms de champs qui sont répertoriés dans un ordre différent de celui de l'ordre de la source de DataTable . Si la liste de champs est vide, une exception est générée.
  • Le DataRelation doit relation entre les tables parent. Par exemple, si vous souhaitez créer une table qui combine des champs de la clientèle, les employés et les tables Commandes, vous devez utilisent la table Commandes en tant que table source et faire référence champs dans le clients et les tables Employés au moyen de relations.
Pour appeler la méthode CreateJoinTable , ajoutez la méthode suivante à la classe DataSetHelper qui vous avez créé dans la section " ":
public DataTable CreateJoinTable(string TableName, DataTable SourceTable, string FieldList)
{
    /*
     * Creates a table based on fields of another table and related parent tables
     * 
     * FieldList syntax: [relationname.]fieldname[ alias][,[relationname.]fieldname[ alias]]...
    */ 
    if (FieldList==null)
    {
        throw new ArgumentException("You must specify at least one field in the field list.");
        //return CreateTable(TableName, SourceTable);
    }
    else
    {
        DataTable dt = new DataTable(TableName);
        ParseFieldList(FieldList, true);
        foreach(FieldInfo Field in m_FieldInfo)
        {
            if(Field.RelationName==null)
            {
                DataColumn dc = SourceTable.Columns[Field.FieldName];
                dt.Columns.Add(dc.ColumnName, dc.DataType, dc.Expression);
            }
            else
            {
                DataColumn dc = SourceTable.ParentRelations[Field.RelationName].ParentTable.Columns[Field.FieldName];
                dt.Columns.Add(dc.ColumnName, dc.DataType, dc.Expression);
            }
        }
        if (ds!=null)
            ds.Tables.Add(dt);
        return dt;
    }
}
				

InsertJoinInto, méthode

Cette section affiche code de la méthode InsertJoinInto . La méthode InsertJoinInto copie les enregistrements qui sont triés et filtrés à partir de la table source et liées les tables à la table de destination. Lorsque vous appelez la propriété ParseFieldList , vous pouvez analyser listes qui ont été analysés précédemment, si ces listes sont disponibles. Si la liste de champs est vide, une exception est générée.

Voici la convention d'appel de la méthode InsertJoinInto :
dsHelper.InsertJoinInto(ds.Tables["TestTable"], ds.Tables["Employees"], 
    "FirstName FName,LastName LName,DepartmentEmployee.DepartmentName Department", 
    "EmployeeID<5", "BirthDate");
				
l'exemple d'appel copie des enregistrements à partir du employés DataTable (et du champ DepartmentName un DataTable liées) à la TestTable DataTable , qui est filtré sur " n° employé < 5 » et est trié par date de naissance.

Remarque : le filtre et les expressions de tri s'appliquent uniquement à la table source et non aux toutes les tables connexes.

Pour appeler la méthode InsertJoinInto , ajoutez la méthode suivante à la classe DataSetHelper qui vous avez créé dans la section " ":
public void InsertJoinInto(DataTable DestTable, DataTable SourceTable, 
    string FieldList, string RowFilter, string Sort)
{
    /*
    * Copies the selected rows and columns from SourceTable and inserts them into DestTable
    * FieldList has same format as CreatejoinTable
    */ 
    if (FieldList==null)
    {
        throw new ArgumentException("You must specify at least one field in the field list.");
        //InsertInto(DestTable, SourceTable, RowFilter, Sort);
    }
    else
    {
    ParseFieldList(FieldList, true);
    DataRow[] Rows = SourceTable.Select(RowFilter, Sort);
    foreach(DataRow SourceRow in Rows)
    {
            DataRow DestRow = DestTable.NewRow();
            foreach(FieldInfo Field in m_FieldInfo)
            {
                if(Field.RelationName==null)
                {
                    DestRow[Field.FieldName] = SourceRow[Field.FieldName];
                }
                else
                {
                    DataRow ParentRow = SourceRow.GetParentRow(Field.RelationName);
                    DestRow[Field.FieldName] = ParentRow[Field.FieldName];
                }
            }
            DestTable.Rows.Add(DestRow);
        }
    }
}
				

SelectJoinInto, méthode

Cette section contient le code de la méthode SelectJoinInto . Cette méthode est une combinaison des méthodes InsertJoinInto et le CreateJoinTable . La méthode SelectJoinInto crée un nouveau DataTable basés sur existants DataTable objets et les copies enregistrements qui sont triés et filtrés dans le nouveau DataTable .

Voici la convention d'appel de la méthode SelectJoinInto :
dt = dsHelper.SelectInto("TestTable", ds.Tables["Employees"], 
    "FirstName FName,LastName LName,DepartmentEmployee.DepartmentName Department", "EmployeeID<5", "BirthDate");
				
cet appel exemple crée un DataTable nommé TestTable avec trois champs. Ces trois champs sont basées sur le prénom et les champs nom du DataTable employés et le champ DepartmentName du DataTable qui est référencé par le DepartmentEmployee DataRelation . Puis Cet exemple copie enregistrements d' employés DataTable dans TestTable DataTable , qui est filtré sur " n° employé < 5 » et est trié par date de naissance.

Remarque : le filtre et les expressions de tri s'appliquent uniquement à la table source et non aux tables liées.

Pour appeler la méthode SelectJoinInto , ajoutez la méthode suivante à la classe DataSetHelper qui vous avez créé dans la section " ":
public DataTable SelectJoinInto(string TableName, DataTable SourceTable, string FieldList, string RowFilter, string Sort)
{
    /*
     * Selects sorted, filtered values from one DataTable to another.
     * Allows you to specify relationname.fieldname in the FieldList to include fields from
     *  a parent table. The Sort and Filter only apply to the base table and not to related tables.
    */ 
    DataTable dt = CreateJoinTable(TableName, SourceTable, FieldList);
    InsertJoinInto(dt, SourceTable, FieldList, RowFilter, Sort);
    return dt;
}
				

Testez l'application

  1. Enregistrez et puis compilez la classe DataSetHelper qui vous avez créé dans les sections précédentes.
  2. Procédez comme suit pour créer une nouvelle application de Windows Visual C# :
    1. Démarrez Visual Studio .NET.
    2. Dans le menu Fichier , pointez sur Nouveau , puis cliquez sur projet .
    3. Dans la boîte de dialogue Nouveau projet , cliquez sur projets Visual C# sous types de projet , puis cliquez sur application Windows sous modèles .
  3. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur la solution, puis cliquez sur Ajouter un projet existant . Pour ajouter le projet DataSetHelper.
  4. Dans le menu projet , cliquez sur Ajouter une référence .
  5. Dans la boîte de dialogue Ajouter une référence , cliquez sur l'onglet projets , puis ajouter une référence au projet DataSetHelper l'application Windows Forms.
  6. Dans le concepteur de formulaires, faites glisser trois contrôles Button et un contrôle DataGrid de la boîte à outils comme vers le formulaire. Nommez les boutons btnCreateJoin , btnInsertJoinInto et btnSelectJoinInto . Conservez le nom par défaut pour le contrôle DataGrid (dataGrid1).
  7. Dans le code du formulaire, ajoutez l'instruction using suivante en haut de la fenêtre Code :
    using System.Data;
    					
  8. Ajoutez les déclarations de variables suivantes à la définition du formulaire :
    DataSet ds; DataSetHelper.DataSetHelper dsHelper;
    					
  9. Ajoutez le code suivant à l'événement Form_Load :
    ds = new DataSet();
    dsHelper = new DataSetHelper.DataSetHelper(ref ds);
    //Create source tables
    DataTable dt = new DataTable("Employees");
    dt.Columns.Add("EmployeeID",Type.GetType("System.Int32") );
    dt.Columns.Add("FirstName", Type.GetType("System.String"));
    dt.Columns.Add("LastName", Type.GetType("System.String"));
    dt.Columns.Add("BirthDate", Type.GetType("System.DateTime"));
    dt.Columns.Add("JobTitle", Type.GetType("System.String"));
    dt.Columns.Add("DepartmentID", Type.GetType("System.Int32"));
    dt.Rows.Add(new object[] {1, "Tommy", "Hill", new DateTime(1970, 12, 31),  "Manager", 42});
    dt.Rows.Add(new object[] {2, "Brooke", "Sheals", new DateTime(1977, 12, 31), "Manager", 23});
    dt.Rows.Add(new object[] {3, "Bill", "Blast", new DateTime(1982, 5, 6), "Sales Clerk", 42});
    dt.Rows.Add(new object[] {1, "Kevin", "Kline", new DateTime(1978, 5, 13), "Sales Clerk", 42});
    dt.Rows.Add(new object[] {1, "Martha", "Seward", new DateTime(1976, 7, 4), "Sales Clerk", 23});
    dt.Rows.Add(new object[] {1, "Dora", "Smith", new DateTime(1985, 10, 22), "Trainee", 42});
    dt.Rows.Add(new object[] {1, "Elvis", "Pressman", new DateTime(1972, 11, 5), "Manager", 15});
    dt.Rows.Add(new object[] {1, "Johnny", "Cache", new DateTime(1984, 1, 23), "Sales Clerk", 15});
    dt.Rows.Add(new object[] {1, "Jean", "Hill", new DateTime(1979, 4, 14), "Sales Clerk", 42});
    dt.Rows.Add(new object[] {1, "Anna", "Smith", new DateTime(1985, 6, 26), "Trainee", 15});
    ds.Tables.Add(dt);
    
    dt = new DataTable("Departments");
    dt.Columns.Add("DepartmentID", Type.GetType("System.Int32"));
    dt.Columns.Add("DepartmentName", Type.GetType("System.String"));
    dt.Rows.Add(new object[] {15, "Men's Clothing"});
    dt.Rows.Add(new object[] {23, "Women's Clothing"});
    dt.Rows.Add(new object[] {42, "Children's Clothing"});
    ds.Tables.Add(dt);
    
    ds.Relations.Add("DepartmentEmployee",     ds.Tables["Departments"].Columns["DepartmentID"], 
        ds.Tables["Employees"].Columns["DepartmentID"]);
    					
  10. Ajoutez le code suivant à l'événement btnCreateJoin_Click :
    dsHelper.CreateJoinTable("EmpDept",ds.Tables["Employees"], 
        "FirstName FName,LastName LName,BirthDate,DepartmentEmployee.DepartmentName Department");
    dataGrid1.SetDataBinding(ds, "EmpDept");
    					
  11. Ajoutez le code suivant à l'événement btnInsertJoinInto_Click :
    dsHelper.InsertJoinInto(ds.Tables["EmpDept"], ds.Tables["Employees"], 
        "FirstName FName,LastName LName,BirthDate,DepartmentEmployee.DepartmentName Department",
        "JobTitle='Sales Clerk'", "DepartmentID");
    dataGrid1.SetDataBinding(ds, "EmpDept");
    					
  12. Ajoutez le code suivant à l'événement btnSelectJoinInto_Click :
    dsHelper.SelectJoinInto("EmpDept2", ds.Tables["Employees"],
        "FirstName,LastName,BirthDate BDate,DepartmentEmployee.DepartmentName Department", 
        "JobTitle='Manager'", "DepartmentID");
    dataGrid1.SetDataBinding(ds, "EmpDept2");
    					
  13. Exécuter l'application, puis cliquez sur chacun des boutons. Notez que le contrôle DataGrid est renseignée avec les tables et les données à partir du code.

    Remarque : cliquez vous pouvez uniquement sur la btnCreateJoin et les btnSelectJoinInto boutons une seule fois. Si vous cliquez sur un de ces boutons plusieurs fois, vous recevez un message d'erreur vous tentez d'ajouter la même table two times. En outre, vous devez cliquer sur btnCreateJoin avant de cliquer sur btnInsertJoinInto ; dans le cas contraire, la destination du DataTable n'est pas créé. Si vous cliquez sur le bouton btnInsertJoinInto plusieurs fois, vous remplir la grille de données avec les enregistrements en double.

Idées d'amélioration

  • La nomcolonne et les propriétés Type de données sont les propriétés uniquement qui sont copiées dans la destination du DataTable . Vous pouvez étendre la méthode CreateTable pour copier des propriétés supplémentaires, telles que la propriété MaxLength , ou vous pouvez créer des nouvelles colonnes de clé.
  • La propriété Expression n'est pas copiée ; au lieu de cela, le résultat calculé est copié. Par conséquent, vous ne devez pas ajouter des champs qui sont référencées par l'expression à la table de destination. En outre, la colonne de destination peut apparaître dans la liste des résultats qu'une des colonnes qui dépend dans le cas contraire de cette colonne. Vous pouvez modifier la méthode CreateTable pour copier l' expression (la colonne InsertInto ignore les colonnes avec une expression ), bien que cela soit soumis aux restrictions qui sont mentionnées plus haut dans ce paragraphe.
  • Vous pouvez fusionner la fonctionnalité du CreateJoinTable , le InsertJoinInto et les méthodes SelectJoinInto dans le CreateTable , le InsertInto et les méthodes SelectInto . Pour plus d'informations sur la CreateTable , le InsertInto et les méthodes SelectInto , cliquez sur le numéro ci-dessous pour afficher l'article correspondant dans la Base de connaissances Microsoft :
    326009 Comment faire : implémentation une classe d'assistance DataSet SELECT INTO dans Visual C# .NET
    Si vous ne souhaitez pas fusionner ces méthodes, mais si vous avez les deux jeux de méthodes dans une classe unique, vous pouvez activer la CreateJoinTable et les méthodes InsertJoinInto gérer une liste de champ vide en supprimant les instructions lève et par uncommenting les appels à la CreateTable et les méthodes InsertInto dans les lignes suivantes de code :
        if (FieldList==null)
        {
            throw new ArgumentException("You must specify at least one field in the field list.");
            //return CreateTable(TableName, SourceTable);
        }
    					
    - et -
        if (FieldList==null)
        {
            throw new ArgumentException("You must specify at least one field in the field list.");
            //InsertInto(DestTable, SourceTable, RowFilter, Sort);
        }
    					

Résolution des problèmes

  • Le nom de champ et les parties alias de la liste de champs doivent vous conformer à conventions d'appellation DataColumn . L'analyseur limite également le nom, dans cette le nom ne doit pas contenir un point (.), une virgule (,) ou un espace ().
  • Si vous cliquez sur un bouton plusieurs fois, la même table est ajoutée deux fois vers le DataSet , qui entraîne une exception. Pour contourner ce problème, vous pouvez ajouter le code à l'application test pour vérifier si un DataTable du même nom existe déjà. Sinon, vous pouvez créer la classe DataSetHelper sans référence à un DataSet et puis lier la propriété de DataGrid.DataSource directement à la variable dt au lieu de à l'aide l'appel de méthode SetDataBinding .
  • Si la table source utilise des types de données personnalisées (une classe), vous devez ajouter du code à la méthode InsertJoinInto pour effectuer une copie en profondeur des données. Sinon, seule une référence est copiée.

Propriétés

Numéro d'article: 326080 - Dernière mise à jour: mercredi 3 septembre 2003 - Version: 2.3
Les informations contenues dans cet article s'appliquent au(x) produit(s) suivant(s):
  • Microsoft ADO.NET 1.1
  • Microsoft ADO.NET 1.0
  • Microsoft Visual C# .NET 2003 Initiation
  • Microsoft Visual C# .NET 2002 Initiation
Mots-clés : 
kbmt kbhowtomaster kbsystemdata KB326080 KbMtfr
Traduction automatique
IMPORTANT : Cet article est issu du système de traduction automatique mis au point par Microsoft (http://support.microsoft.com/gp/mtdetails). Un certain nombre d?articles obtenus par traduction automatique sont en effet mis à votre disposition en complément des articles traduits en langue française par des traducteurs professionnels. Cela vous permet d?avoir accès, dans votre propre langue, à l?ensemble des articles de la base de connaissances rédigés originellement en langue anglaise. Les articles traduits automatiquement ne sont pas toujours parfaits et peuvent comporter des erreurs de vocabulaire, de syntaxe ou de grammaire (probablement semblables aux erreurs que ferait une personne étrangère s?exprimant dans votre langue !). Néanmoins, mis à part ces imperfections, ces articles devraient suffire à vous orienter et à vous aider à résoudre votre problème. Microsoft s?efforce aussi continuellement de faire évoluer son système de traduction automatique.
La version anglaise de cet article est la suivante: 326080
L'INFORMATION CONTENUE DANS CE DOCUMENT EST FOURNIE PAR MICROSOFT SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE. L'UTILISATEUR ASSUME LE RISQUE DE L'UTILISATION DU CONTENU DE CE DOCUMENT. CE DOCUMENT NE PEUT ETRE REVENDU OU CEDE EN ECHANGE D'UN QUELCONQUE PROFIT.

Envoyer des commentaires

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com