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

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 326080 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Alles erweitern | Alles schließen

Auf dieser Seite

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

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

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.

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 "" 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);
        }
    }
    					

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 "" 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;
    }
}
				

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 "" 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);
        }
    }
}
				

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 "" 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;
}
				

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 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. 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.

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);
        }
    					

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.

Eigenschaften

Artikel-ID: 326080 - Geändert am: Mittwoch, 3. September 2003 - Version: 2.3
Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft ADO.NET 1.1
  • Microsoft ADO.NET 1.0
  • Microsoft Visual C# .NET 2003 Standard Edition
  • Microsoft Visual C# .NET 2002 Standard Edition
Keywords: 
kbmt kbhowtomaster kbsystemdata KB326080 KbMtde
Maschinell übersetzter Artikel
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
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.

Ihr Feedback an uns

 

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