Holen Sie sich die Unterschiede in den 2 Datensätze c#

Ich denke, das problem ist, dass Sie nicht verstehen .NET-DataSets. Eine DataTable bleibt der "original" - Kopie von jeder geladene Wert in es. Wenn ein Wert geändert wird, wird die DataTable in der Lage ist zu erkennen, das zu ändern. Ebenso die DataTable hält verfolgen der Zeilen, die Hinzugefügt oder gelöscht wurden. Die HasChanges() Funktion einfach kriecht durch die DataTables und prüft, um zu sehen, ob es irgendwelche änderungen (geänderte Wert, neue Zeilen, gelöschte Zeilen, etc.)

Finden Sie in der MSDN-Dokumentation:

http://msdn.microsoft.com/en-us/library/system.data.dataset.haschanges.aspx

Vergleich der beiden Datensätze ist schwierig, und ich bin mir nicht bewusst irgendeine eingebaute Funktion, um diese zu bewältigen (da jeder Programmierer Ihre eigene definition der "äquivalenz").

Finden Sie unter:

• Wie vergleichen Sie 2 dataTables auf StackOverflow
• Vergleich von Daten mit Hilfe von LINQ auf CodeProject

Den code unten vergleicht zwei DataTables Suche für hinzugefügte/gelöschte Zeilen basierend auf einem Schlüssel-Spalte und geänderten Zeilen durch vergleichen der Werte der übereinstimmenden Zeilen (wieder, basierend auf dem Schlüssel). Es wäre ziemlich trivial, zu erweitern, zu vergleichen, Datensätze (durch den Vergleich von ähnlich benannten Tabellen zwischen DataSets).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;

namespace DataSetComparison
{
    class Program
    {
        static void Main( string[] args )
        {

            var l_table1 = new DataTable();
            l_table1.Columns.Add( "Key", typeof( int ) );
            l_table1.Columns.Add( "Name", typeof( string ) );
            l_table1.Columns.Add( "Age", typeof( int ) );

            var l_table2 = new DataTable();
            l_table2.Columns.Add( "Key", typeof( int ) );
            l_table2.Columns.Add( "Name", typeof( string ) );
            l_table2.Columns.Add( "Age", typeof( int ) );

            l_table1.Rows.Add( l_table1.NewRow() );
            l_table1.Rows[l_table1.Rows.Count - 1]["Key"] = 0;
            l_table1.Rows[l_table1.Rows.Count - 1]["Name"] = "Alfred Harisson";
            l_table1.Rows[l_table1.Rows.Count - 1]["Age"] = 36;
            l_table1.Rows.Add( l_table1.NewRow() );
            l_table1.Rows[l_table1.Rows.Count - 1]["Key"] = 1;
            l_table1.Rows[l_table1.Rows.Count - 1]["Name"] = "Matthew George";
            l_table1.Rows[l_table1.Rows.Count - 1]["Age"] = 41;
            l_table1.Rows.Add( l_table1.NewRow() );
            l_table1.Rows[l_table1.Rows.Count - 1]["Key"] = 2;
            l_table1.Rows[l_table1.Rows.Count - 1]["Name"] = "Franklin Henry";
            l_table1.Rows[l_table1.Rows.Count - 1]["Age"] = 33;

            l_table2.Rows.Add( l_table2.NewRow() );
            l_table2.Rows[l_table2.Rows.Count - 1]["Key"] = 0;
            l_table2.Rows[l_table2.Rows.Count - 1]["Name"] = "Alfred Harisson";
            l_table2.Rows[l_table2.Rows.Count - 1]["Age"] = 36;
            l_table2.Rows.Add( l_table2.NewRow() );
            l_table2.Rows[l_table2.Rows.Count - 1]["Key"] = 1;
            l_table2.Rows[l_table2.Rows.Count - 1]["Name"] = "Matthew George";
            l_table2.Rows[l_table2.Rows.Count - 1]["Age"] = 42; //Record 1 "modified"
            //Record 2 "deleted"
            //Record 3 "added":
            l_table2.Rows.Add( l_table2.NewRow() );
            l_table2.Rows[l_table2.Rows.Count - 1]["Key"] = 3;
            l_table2.Rows[l_table2.Rows.Count - 1]["Name"] = "Lester Kulick";
            l_table2.Rows[l_table2.Rows.Count - 1]["Age"] = 33;

            //Using table 1 as the control, find changes in table 2

            //Find deleted rows:
            var l_table2Keys = l_table2.Select().Select( ( r ) => (int) r["Key"] );
            var l_deletedRows = l_table1.Select().Where( ( r ) => !l_table2Keys.Contains( (int) r["Key"] ) );

            foreach ( var l_deletedRow in l_deletedRows )
                Console.WriteLine( "Record " + l_deletedRow["Key"].ToString() + " was deleted from table 2." );

            //Find added rows:
            var l_table1Keys = l_table1.Select().Select( ( r ) => (int) r["Key"] );
            var l_addedRows = l_table2.Select().Where( ( r ) => !l_table1Keys.Contains( (int) r["Key"] ) );

            foreach ( var l_addedRow in l_addedRows )
                Console.WriteLine( "Record " + l_addedRow["Key"].ToString() + " was added to table 2." );

            //Find modified rows:
            var l_modifiedRows = l_table2.Select()
                                         .Join(
                                            l_table1.Select(),
                                            r => (int) r["Key"],
                                            r => (int) r["Key"],
                                            ( r1, r2 ) => new
                                                {
                                                    Row1 = r1,
                                                    Row2 = r2
                                                } )
                                        .Where(
                                            values => !( values.Row1["Name"].Equals( values.Row2["Name"] ) &&
                                                         values.Row1["Age"].Equals( values.Row2["Age"] ) ) )
                                        .Select( values => values.Row2 );

            foreach ( var l_modifiedRow in l_modifiedRows )
                Console.WriteLine( "Record " + l_modifiedRow["Key"].ToString() + " was modified in table 2." );

            Console.WriteLine( "Press any key to quit..." );
            Console.ReadKey( true );

        }
    }
}

Ausgabe der Konsole:

Datensatz 2 gelöscht wurde (Tabelle 2).

Datensatz 3 wurde Hinzugefügt (Tabelle 2).

Satz 1 wurde geändert (Tabelle 2).

Wie Sie sehen können, von einigen der anderen Antworten ist es nicht einfach, die Differenz der zwei Datensätze.

Das ist der Zweck des DataSet.GetChanges(). Wenn Sie beginnen mit einem Datensatz und die änderungen direkt auf das dataset (d.h. wenn ein Benutzer aktualisiert eine Zelle, wenn ein Benutzer ein Formular abschickt, etc...), dann wird der DataSet-änderungen verfolgt. Auf diese Weise können Sie call-DataSet.GetChanges (), um die Veränderungen (oder Unterschied). Sie kann dann nur die änderungen.

Ist es ein schwieriges problem zu nehmen, eine erste dataset und eine endgültige dataset und die Unterschiede angezeigt bekommen. Auch die Zusammenlegung der Letzte Datensatz mit dem alten Datensatz nicht sinnvoll, da der Letzte Datensatz ist das Ergebnis der Zusammenführung.