Sie sind zurzeit offline. Es wird auf die erneute Herstellung einer Internetverbindung gewartet.

Gewusst wie: Implementieren eine Hilfsklasse DataSet JOIN in Visual c# .NET

Wichtig: Dieser Artikel wurde maschinell und nicht von einem Menschen übersetzt. Die Microsoft Knowledge Base ist sehr umfangreich und ihre Inhalte werden ständig ergänzt beziehungsweise überarbeitet. Um Ihnen dennoch alle Inhalte auf Deutsch anbieten zu können, werden viele Artikel nicht von Menschen, sondern von Übersetzungsprogrammen übersetzt, die kontinuierlich optimiert werden. Doch noch sind maschinell übersetzte Texte in der Regel nicht perfekt, insbesondere hinsichtlich Grammatik und des Einsatzes von Fremdwörtern sowie Fachbegriffen. Microsoft übernimmt keine Gewähr für die sprachliche Qualität oder die technische Richtigkeit der Übersetzungen und ist nicht für Probleme haftbar, die direkt oder indirekt durch Übersetzungsfehler oder die Verwendung der übersetzten Inhalte durch Kunden entstehen könnten.

Den englischen Originalartikel können Sie über folgenden Link abrufen: 326080
Eine Microsoft Visual Basic .NET Version dieses Artikels finden Sie unter
325688So wird 's gemacht: Implementieren einer Hilfsklasse DataSet JOIN in Visual Basic .NET
Hinweis : Dieser Artikel ist eine von einer Reihe von DataSetHelper -Artikel. Sie können den Code in die DataSetHelper -Klasse zusammenführen, die in diesem Artikel mit dem Code aufgeführt ist, die in anderen DataSetHelper -Artikeln zu eine einzelne Klasse mit einem umfassenderen Feature bereitgestellt wird.

Dieser Artikel bezieht sich auf die folgenden Namespaces für Microsoft .NET Framework-Klassenbibliotheken:
  • System.Data

Inhalt

Zusammenfassung
Dieser schrittweise aufgebaute Artikel beschreibt die implementieren und wie Verwenden einer DataSetHelper -Klasse, die Beispielcode, um ein DataTable -Objekt aus zwei oder mehr verwandten DataTable -Definitionen erstellen und Kopieren von Datensätzen, die sortiert und gefiltert werden von der Quelle DataTable -Objekte an das Ziel DataTable enthält.

Zu diesem Zweck verwenden Sie die folgenden öffentlichen Methoden:
  • CreateJoinTable
  • InsertJoinInto
  • SelectJoinInto
Die SelectJoinInto -Methode ruft Methoden InsertJoinInto und CreateJoinTable . Sie können auch eine private Helfer Methode und Daten-Member verwenden, zum Speichern der analysierten Feldliste.

Die DataSetHelper -Klasse beinhaltet eine DataSet -Membervariable. Optional können Sie die DataSet -Membervariable ein vorhandenes DataSet zuweisen. Wenn die Membervariable auf ein gültiges DataSet verweist, werden alle DataTable -Objekte, die die CreateJoinTable oder SelectJoinInto -Methode erstellt, die dem DataSet hinzugefügt. In beiden Fällen gibt der Methodenaufruf einen Verweis auf das DataTable -Objekt zurück. Die InsertJoinInto -Methode erfordert ein Ziel DataTable und nicht wieder etwas.

Weitere Informationen zu DataSet -Objekten finden Sie die Artikel der Microsoft Knowledge Base:
313485INFO: Wegweiser für ADO.NET DataSet DataView und DataViewManager
back to the top

Voraussetzungen

Die folgende Liste führt die empfohlene Hardware, Software, Netzwerkinfrastruktur und Service Packs, die erforderlich sind:
  • Microsoft Windows XP, Windows 2000 oder Windows NT 4.0 Service Pack 6a
  • Microsoft Visual Studio .NET
In diesem Artikel wird vorausgesetzt, dass Sie über Erfahrungen auf den folgenden Gebieten verfügen:
  • Visual c#-syntax
  • ADO.NET-Grundlagen und -Syntax
back to the top

DataSetHelper-Shell-Klasse

Der Code in diesem Abschnitt deklariert die Shell-Klasse, die alle DataSetHelper -Artikel Methoden und Membervariablen hinzufügen.
  1. Starten Sie Visual Studio .NET.
  2. Zeigen im Menü Datei auf neu , und klicken Sie dann auf Projekt .
  3. Klicken Sie unter Projekttypen auf Visual C#-Projekte , und klicken Sie Klassenbibliothek unter Vorlagen , klicken Sie im Dialogfeld Neues Projekt .
  4. Geben Sie im Feld Name DataSetHelper .
  5. Ersetzen Sie den Klassencode durch folgenden Code:
    public class DataSetHelper{    public DataSet ds;    public DataSetHelper(ref DataSet DataSet)    {	ds = DataSet;    }    public DataSetHelper()    {	ds = null;    }}					
    können Sie zwei Überladungen für den Konstruktor um eine Instanz der Klasse mit oder ohne einen Verweis auf ein gültiges DataSet zu erstellen. Für eine Klasse, die einen Verweis auf ein gültiges DataSet enthält, werden die DataTable -Objekte, die die Methoden zurück, das DataSet auch automatisch hinzugefügt.
back to the top

Feld Liste Parser

Dieser Abschnitt enthält den Code für ein Feld Liste Parser. Die analysierte Struktur wird verwendet, sodass CreateJoinTable und die InsertJoinInto -Methoden nicht die Feldliste Analysepunkt müssen. Diese Methoden müssen die Feldliste Analysepunkte, wenn Sie aus der SelectJoinInto -Methode oder Ihren eigenen Code aufgerufen werden. Der analysierte Feldliste und der nicht analysierten Feldliste befinden sich in private Membervariablen der DataSetHelper -Klasse.
  1. Fügen Sie die folgende private Klassendefinition in der DataSetHelper -Klasse, die Sie in den Abschnitt "DataSetHelper Shell Class" erstellt haben:
    private class FieldInfo{    public string RelationName;    public string FieldName;	//source table field name    public string FieldAlias;	//destination table field name    public string Aggregate;}					
    Hinweis : Diese Klasse ist üblich, andere DataSetHelper -Artikel und enthält einige Felder, die in diesem Artikel nicht verwendet.

  2. Fügen Sie die folgenden private Membervariablen auf die Klassendefinition unmittelbar nach der DataSet -Deklaration:
    private System.Collections.ArrayList m_FieldInfo; private string m_FieldList; 					
  3. Fügen Sie die folgende private Methode, auf die Klassendefinition. Diese Methode entspricht der Methode, die in anderen Artikeln DataSetHelper verwendet wird.
    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);    }}					
back to the top

CreateJoinTable-Methode

Dieser Abschnitt enthält den Code für die CreateJoinTable -Methode.

Im folgenden ist die Aufrufkonvention für die CreateJoinTable -Methode:
dt = dsHelper.CreateJoinTable("TestTable", ds.Tables["Employees"],    "FirstName FName,LastName LName,DepartmentEmployee.DepartmentName Department");				
dieser Aufruf-Beispiel erstellt eine neue DataTable mit einem TableName TestTable und drei Felder (FName, LName und Abteilung). Diese drei Felder haben denselben Datentyp wie der Vorname und der Nachname Felder in der Tabelle Personal und das DepartmentName-Feld in der übergeordneten Tabelle, die über das DepartmentEmployee DataRelation -Objekt zugegriffen wird.

Verwenden Sie die folgende Syntax, um Felder in der Feldliste angeben:
[relationname.]fieldname[ alias], ...				
für diese Syntax Folgendes beachten:
  • Der Spaltenname und der Datentyp -Eigenschaften sind die einzigen Eigenschaften, die an das Ziel DataTable kopiert werden.
  • Das Ergebnis ausgewertete wird für Felder kopiert, die einen Ausdruck enthalten.
  • Sie können ein Feld in das Ziel DataTable umbenennen, indem Sie einen Aliasnamen angeben.
  • Die Feldliste kann eine Teilmenge der Feldnamen enthalten, die in einer anderen Reihenfolge als die Reihenfolge in der Quelle DataTable aufgeführt sind. Wenn die Feldliste leer ist, wird eine Ausnahme ausgelöst.
  • Die DataRelation muss mit den übergeordneten Tabellen verknüpfen. Beispielsweise müssen eine Tabelle erstellen, die Felder von den Kunden, die Angestellten und die Tabellen Orders kombiniert werden sollen, Sie verwenden Sie die Orders-Tabelle als die Quelltabelle und verweisen dann mithilfe von Beziehungen auf Felder in der Customers und der Tabelle Personal.
Fügen Sie die CreateJoinTable -Methode aufrufen, die folgende Methode der DataSetHelper -Klasse, die Sie in den Abschnitt "DataSetHelper Shell Class" erstellt haben:
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;    }}				
back to the top

InsertJoinInto-Methode

Dieser Abschnitt enthält Code für die InsertJoinInto -Methode. Der InsertJoinInto -Methode werden Datensätze, die sortiert werden, aus der Quelltabelle gefiltert und verknüpften Tabellen in die Zieltabelle kopiert. Beim Aufrufen der ParseFieldList -Eigenschaft können Sie Listen, die zuvor analysiert wurden, analysieren, wenn diese Listen verfügbar sind. Wenn die Feldliste leer ist, wird eine Ausnahme ausgelöst.

Im folgenden ist die Aufrufkonvention für die InsertJoinInto -Methode:
dsHelper.InsertJoinInto(ds.Tables["TestTable"], ds.Tables["Employees"],     "FirstName FName,LastName LName,DepartmentEmployee.DepartmentName Department",     "EmployeeID<5", "BirthDate");				
die Aufruf-Beispiel kopiert Datensätze aus der Personal- DataTable (DepartmentName Felder und einer zugehörigen DataTable ) die TestTable DataTable , die nach dem gefiltert "EmployeeID < 5" und nach Geburtsdatum sortiert ist.

Hinweis : der Filter und die Sortierung Ausdrücke gelten nur für die Quelltabelle und nicht zu allen verknüpften Tabellen.

Fügen Sie die InsertJoinInto -Methode aufrufen, die folgende Methode der DataSetHelper -Klasse, die Sie in den Abschnitt "DataSetHelper Shell Class" erstellt haben:
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);        }    }}				
back to the top

SelectJoinInto-Methode

Dieser Abschnitt enthält den Code für die SelectJoinInto -Methode. Diese Methode ist eine Kombination von CreateJoinTable und die InsertJoinInto -Methoden. Die SelectJoinInto -Methode erstellt eine neue Datentabelle basierend auf vorhandenen DataTable -Objekte und kopiert Datensätze, die sortiert und in die neue Datentabelle gefiltert werden.

Im folgenden ist die Aufrufkonvention für die SelectJoinInto -Methode:
dt = dsHelper.SelectInto("TestTable", ds.Tables["Employees"],     "FirstName FName,LastName LName,DepartmentEmployee.DepartmentName Department", "EmployeeID<5", "BirthDate");				
dieser Beispiel-Aufruf wird eine DataTable mit dem Namen TestTable mit drei Felder erstellt. Diese drei Felder basieren auf der Vorname und die Felder Nachname der Mitarbeiter DataTable und Feld DepartmentName, der die DataTable , die über die DepartmentEmployee DataRelation verwiesen wird. Dann in diesem Beispiel zu TestTable, DataTable , die auf gefiltert, Datensätze aus der Employees- DataTable kopiert "EmployeeID < 5" und nach Geburtsdatum sortiert ist.

Hinweis : der Filter und die Sortierung Ausdrücke gelten nur für die Quelltabelle und nicht an verknüpfte Tabellen.

Fügen Sie die SelectJoinInto -Methode aufrufen, die folgende Methode der DataSetHelper -Klasse, die Sie in den Abschnitt "DataSetHelper Shell Class" erstellt haben:
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;}				
back to the top

Testen Sie die Anwendung

  1. Speichern Sie und kompilieren Sie die DataSetHelper -Klasse, die Sie in den vorherigen Abschnitten erstellt haben.
  2. Gehen Sie folgendermaßen eine neue Visual C#-Windows-Anwendung erstellen vor:
    1. Starten Sie Visual Studio .NET.
    2. Zeigen im Menü Datei auf neu , und klicken Sie dann auf Projekt .
    3. Klicken Sie im Dialogfeld Neues Projekt klicken Sie unter Projekttypen auf Visual C#-Projekte , und klicken Sie dann unter Vorlagen auf Windows-Anwendung .
  3. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe und klicken Sie dann auf Vorhandenes Projekt hinzufügen . Fügen Sie das DataSetHelper-Projekt hinzu.
  4. Klicken Sie im Menü Projekt auf Verweis hinzufügen .
  5. Klicken Sie im Dialogfeld Verweis hinzufügen klicken Sie auf die Registerkarte Projekte , und fügen Sie der Windows Forms-Anwendung einen Verweis auf das DataSetHelper-Projekt hinzu.
  6. Ziehen Sie im Formular-Designer drei Button -Steuerelemente und ein DataGrid -Steuerelement aus der Toolbox auf das Formular. Benennen Sie die Schaltflächen BtnCreateJoin , BtnInsertJoinInto und BtnSelectJoinInto . Halten Sie den Standardnamen für das DataGrid -Steuerelement (dataGrid1).
  7. Im Formularcode, fügen Sie die folgende Using -Anweisung am Anfang des Codefensters:
    using System.Data;					
  8. Fügen Sie die folgenden Variablen Deklarationen hinzu die Formulardefinition:
    DataSet ds; DataSetHelper.DataSetHelper dsHelper;					
  9. Fügen Sie dem Form_Load -Ereignis den folgenden Code:
    ds = new DataSet();dsHelper = new DataSetHelper.DataSetHelper(ref ds);//Create source tablesDataTable 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. Fügen Sie das BtnCreateJoin_Click -Ereignis den folgenden Code:
    dsHelper.CreateJoinTable("EmpDept",ds.Tables["Employees"],     "FirstName FName,LastName LName,BirthDate,DepartmentEmployee.DepartmentName Department");dataGrid1.SetDataBinding(ds, "EmpDept");					
  11. Fügen Sie das BtnInsertJoinInto_Click -Ereignis den folgenden Code:
    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. Fügen Sie das BtnSelectJoinInto_Click -Ereignis den folgenden Code:
    dsHelper.SelectJoinInto("EmpDept2", ds.Tables["Employees"],    "FirstName,LastName,BirthDate BDate,DepartmentEmployee.DepartmentName Department",     "JobTitle='Manager'", "DepartmentID");dataGrid1.SetDataBinding(ds, "EmpDept2");					
  13. Führen Sie die Anwendung, und klicken Sie dann auf die Schaltflächen. Beachten Sie, dass das DataGrid mit den Tabellen und die Daten aus dem Code aufgefüllt wird.

    Hinweis : Klicken Sie nur auf die Schaltflächen BtnSelectJoinInto und BtnCreateJoin einmal. Wenn Sie mehr als einmal auf eine dieser Schaltflächen klicken, erhalten Sie eine Fehlermeldung, die Sie die gleiche Tabelle two times hinzufügen möchten. Darüber hinaus müssen Sie BtnCreateJoin vor dem Klicken auf BtnInsertJoinInto ; andernfalls das Ziel DataTable wird nicht erstellt. Wenn Sie mehrere Male die BtnInsertJoinInto -Schaltfläche klicken, füllen Sie das DataGrid mit doppelten Datensätzen.
back to the top

Verbesserung Ideen

  • Der Spaltenname und der Datentyp -Eigenschaften sind die einzigen Eigenschaften, die an das Ziel DataTable kopiert werden. Sie können die CreateTable -Methode kopieren Sie zusätzliche Eigenschaften, wie die MaxLength -Eigenschaft erweitern, oder Sie können neue Schlüsselspalten erstellen.
  • Die Expression -Eigenschaft wird nicht kopiert; stattdessen wird das Ergebnis ausgewertete kopiert. Sie müssen daher keinen Felder hinzufügen, die durch den Ausdruck in die Zieltabelle verwiesen wird. Darüber hinaus kann die Zielspalte weiter oben in der Ergebnisliste als Spalten angezeigt, von denen diese Spalte andernfalls abhängt. Sie können die Methode CreateTable , um den Ausdruck (die Spalte InsertInto ignoriert Spalten mit einem Expression ), kopieren, obwohl dies unterliegen, die Einschränkungen ist die weiter oben in diesem Absatz erwähnten ändern.
  • Sie können die Funktionalität von CreateJoinTable , InsertJoinInto und die Methoden SelectJoinInto in CreateTable , InsertInto und die Methoden SelectInto zusammenführen. Weitere Informationen zu CreateTable , InsertInto und die Methoden SelectInto folgendem Artikel der Microsoft Knowledge Base:
    326009So wird 's gemacht: Implementieren einer DataSet SELECT INTO-Hilfsklasse in Visual c# .NET
    Wenn Sie nicht diese Methoden zusammenführen möchten, jedoch Wenn Sie beide Sätze von Methoden in einer einzelnen Klasse haben, können Sie die CreateJoinTable und die InsertJoinInto -Methoden, um eine Liste leere Feld durch die throw -Anweisungen entfernen und die Aufrufe von CreateTable und die InsertInto Methoden in der folgenden Codezeilen uncommenting behandeln aktivieren:
        if (FieldList==null)    {        throw new ArgumentException("You must specify at least one field in the field list.");        //return CreateTable(TableName, SourceTable);    }					
    - und -
        if (FieldList==null)    {        throw new ArgumentException("You must specify at least one field in the field list.");        //InsertInto(DestTable, SourceTable, RowFilter, Sort);    }					
back to the top

Problembehandlung

  • Der Feldname und der Alias Teile der Feldliste müssen DataColumn -Namenskonventionen entsprechen. Der Parser schränkt auch die Namen, dass der Name keinen Punkt (.) enthalten, muss ein Komma (,) oder ein Leerzeichen ().
  • Wenn Sie mehr als einmal auf eine Schaltfläche klicken, wird dieselbe Tabelle zweimal zum DataSet hinzugefügt, die zu einer Ausnahme führt. Um dieses Problem zu umgehen, können Sie Code hinzufügen, an die Testanwendung, um zu überprüfen, ob eine DataTable mit dem gleichen Namen bereits vorhanden ist. Alternativ können Sie die DataSetHelper -Klasse ohne Verweis auf ein DataSet erstellen und binden Sie die DataGrid.DataSource -Eigenschaft direkt an die dt Variable statt mithilfe der Aufruf der SetDataBinding -Methode.
  • Wenn die Quelltabelle benutzerdefinierte Datentypen (d. h., eine Klasse) verwendet, müssen Sie die InsertJoinInto -Methode, um eine Tiefe Kopie der Daten durchzuführen Code hinzufügen. Andernfalls wird nur ein Verweis kopiert.
back to the top

Warnung: Dieser Artikel wurde automatisch übersetzt.

Eigenschaften

Artikelnummer: 326080 – Letzte Überarbeitung: 09/03/2003 23:26:44 – Revision: 2.3

Microsoft ADO.NET 1.1, Microsoft ADO.NET 1.0, Microsoft Visual C# .NET 2003 Standard Edition, Microsoft Visual C# .NET 2002 Standard Edition

  • kbmt kbhowtomaster kbsystemdata KB326080 KbMtde
Feedback
/html>