Quel est le meilleur moyen de supprimer les doublons d'une table?

Comment puis-je supprimer les doublons de lignes?. (Ajuster la requête pour le rejoindre sur votre 4 colonnes de clé)

EDIT: avec vos nouvelles informations, je crois que le plus simple serait de mettre en œuvre IEqualityComparer<T> et l'utilisation Distinctes sur vos lignes de données. Sinon, si vous travaillez avec IEnumerable/IList au lieu de DataTable/DataRow, il est certainement possible avec certains LINQ-to-objets de kung-fu.

EDIT: exemple IEqualityComparer

public class MyRowComparer : IEqualityComparer<DataRow>
{

    public bool Equals(DataRow x, DataRow y)
    {
        return (x.Field<int>("ID") == y.Field<int>("ID")) &&
            string.Compare(x.Field<string>("Name"), y.Field<string>("Name"), true) == 0 &&
          ... //extend this to include all your 4 keys...
    }

    public int GetHashCode(DataRow obj)
    {
        return obj.Field<int>("ID").GetHashCode() ^ obj.Field<string>("Name").GetHashCode() etc.
    }
}

Vous pouvez l'utiliser comme ceci:

var uniqueRows = myTable.AsEnumerable().Distinct(MyRowComparer);

OriginalL'auteur liggett78

Il doit être pris en compte dans ce Tableau.AcceptChanges() doit être appelée pour terminer la suppression. Sinon supprimé la ligne est toujours présent dans la DataTable avec RowState ensemble Supprimé. Et De La Table.Les lignes.Le comte n'est pas modifié après la suppression.

OriginalL'auteur Alexey

Liggett78 la réponse est beaucoup mieux - esp. que la mienne avait une erreur! Correction comme suit...

DELETE TableWithDuplicates
    FROM TableWithDuplicates
        LEFT OUTER JOIN (
            SELECT PK_ID = Min(PK_ID), --Decide your method for deciding which rows to keep
                KeyColumn1,
                KeyColumn2,
                KeyColumn3,
                KeyColumn4
                FROM TableWithDuplicates
                GROUP BY KeyColumn1,
                    KeyColumn2,
                    KeyColumn3,
                    KeyColumn4
            ) AS RowsToKeep
            ON TableWithDuplicates.PK_ID = RowsToKeep.PK_ID
    WHERE RowsToKeep.PK_ID IS NULL

OriginalL'auteur

"Ce datatable est en cours de création par la lecture d'un fichier CSV et non pas à partir d'une base."

De façon à mettre une contrainte unique sur les quatre colonnes dans la base de données, et les inserts sont des doublons sous votre conception n'irai pas. Sauf s'il décide de l'échec plutôt que de le faire lorsque cela arrive, mais ce n'est sûrement configurable dans votre fichier CSV importer le script.

OriginalL'auteur JeeBee

C'est un code très simple ne nécessitant pas de linq, ni des colonnes individuelles pour faire le filtre.
Si toutes les valeurs des colonnes dans une rangée sont nulles, il sera supprimé.

    public DataSet duplicateRemoval(DataSet dSet) 
{
bool flag;
int ccount = dSet.Tables[0].Columns.Count;
string[] colst = new string[ccount];
int p = 0;
DataSet dsTemp = new DataSet();
DataTable Tables = new DataTable();
dsTemp.Tables.Add(Tables);
for (int i = 0; i < ccount; i++)
{
dsTemp.Tables[0].Columns.Add(dSet.Tables[0].Columns[i].ColumnName, System.Type.GetType("System.String"));
}
foreach (System.Data.DataRow row in dSet.Tables[0].Rows)
{
flag = false;
p = 0;
foreach (System.Data.DataColumn col in dSet.Tables[0].Columns)
{
colst[p++] = row[col].ToString();
if (!string.IsNullOrEmpty(row[col].ToString()))
{  //Display only if any of the data is present in column
flag = true;
}
}
if (flag == true)
{
DataRow myRow = dsTemp.Tables[0].NewRow();
//Response.Write("<tr style=\"background:#d2d2d2;\">");
for (int kk = 0; kk < ccount; kk++)
{
myRow[kk] = colst[kk];         
//Response.Write("<td class=\"table-line\" bgcolor=\"#D2D2D2\">" + colst[kk] + "</td>");
}
dsTemp.Tables[0].Rows.Add(myRow);
}
} return dsTemp;
}

Cela peut même être utilisé pour supprimer des données nulles à partir d'une feuille excel.

OriginalL'auteur Srikanth V M

Je n'étais pas chaud à l'idée à l'aide de Linq solution ci-dessus j'ai donc écrit ceci:

///<summary>
///Takes a datatable and a column index, and returns a datatable without duplicates
///</summary>
///<param name="dt">The datatable containing duplicate records</param>
///<param name="ComparisonFieldIndex">The column index containing duplicates</param>
///<returns>A datatable object without duplicated records</returns>
public DataTable duplicateRemoval(DataTable dt, int ComparisonFieldIndex)
{
try
{
//Build the new datatable that will be returned
DataTable dtReturn = new DataTable();
for (int i = 0; i < dt.Columns.Count; i++)
{
dtReturn.Columns.Add(dt.Columns[i].ColumnName, System.Type.GetType("System.String"));
}
//Loop through each record in the datatable we have been passed
foreach (DataRow dr in dt.Rows)
{
bool Found = false;
//Loop through each record already present in the datatable being returned
foreach (DataRow dr2 in dtReturn.Rows)
{
bool Identical = true;
//Compare the column specified to see if it matches an existing record
if (!(dr2[ComparisonFieldIndex].ToString() == dr[ComparisonFieldIndex].ToString()))
{
Identical = false;
}
//If the record found identically matches one we already have, don't add it again
if (Identical)
{
Found = true;
break;
}
}
//If we didn't find a matching record, we'll add this one
if (!Found)
{
DataRow drAdd = dtReturn.NewRow();
for (int i = 0; i < dtReturn.Columns.Count; i++)
{
drAdd[i] = dr[i];
}
dtReturn.Rows.Add(drAdd);
}
}
return dtReturn;
}
catch (Exception)
{
//Return the original datatable if something failed above
return dt;
}
}

En outre, cela fonctionne sur TOUTES les colonnes plutôt qu'un index de colonne:

///<summary>
///Takes a datatable and returns a datatable without duplicates
///</summary>
///<param name="dt">The datatable containing duplicate records</param>
///<returns>A datatable object without duplicated records</returns>
public DataTable duplicateRemoval(DataTable dt)
{
try
{
//Build the new datatable that will be returned
DataTable dtReturn = new DataTable();
for (int i = 0; i < dt.Columns.Count; i++)
{
dtReturn.Columns.Add(dt.Columns[i].ColumnName, System.Type.GetType("System.String"));
}
//Loop through each record in the datatable we have been passed
foreach (DataRow dr in dt.Rows)
{
bool Found = false;
//Loop through each record already present in the datatable being returned
foreach (DataRow dr2 in dtReturn.Rows)
{
bool Identical = true;
//Compare all columns to see if they match the existing record
for (int i = 0; i < dt.Columns.Count; i++)
{
if (!(dr2[i].ToString() == dr[i].ToString()))
{
Identical = false;
}
}
//If the record found identically matches one we already have, don't add it again
if (Identical)
{
Found = true;
break;
}
}
//If we didn't find a matching record, we'll add this one
if (!Found)
{
DataRow drAdd = dtReturn.NewRow();
for (int i = 0; i < dtReturn.Columns.Count; i++)
{
drAdd[i] = dr[i];
}
dtReturn.Rows.Add(drAdd);
}
}
return dtReturn;
}
catch (Exception)
{
//Return the original datatable if something failed above
return dt;
}
}

OriginalL'auteur Dave Lucre