Remplacement de valeur dans DataTable

**kheironn** · 23/01/2012, 15h03

Bonjour.
Je suis un peu rouillé sur les DataTable et confronté à deux problèmes.
soit le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
private static DataSet MergeTableLignesByField(DataSet dataSet, DataTable originalTable, int columnIndex)
        {
            if(originalTable.Rows.Count > 0 && originalTable.Rows[0].ItemArray[columnIndex] is string)
            {
                DataTable newTable = originalTable.Clone();
                newTable.Clear();
 
                DataRow previousRow = null;
                for(int i = 0; i < originalTable.Rows.Count; i++)
                {
                    DataRow currentRow = originalTable.Rows[i];
                    bool matchLine = false;
                    if(previousRow != null)
                    {
                        // On compare les champs de deux lignes pour savoir si on peut les fusionner : tous les champs sont identiques sauf le champ spécifié
                        for(int j = 0; j < currentRow.ItemArray.Length; j++)
                            if(j != columnIndex)
                            {
                                matchLine = (currentRow.ItemArray[j].ToString() == previousRow.ItemArray[j].ToString());
                                if(!matchLine)
                                    break;
                            }
                        //Si les lignes sont identiques, on peut les fusionner et merger le champ voulu.
                        if(matchLine)
                        {
                            previousRow.BeginEdit();
                            string newValue = string.Concat(previousRow.ItemArray[columnIndex].ToString(), " | ", currentRow.ItemArray[columnIndex].ToString());
                            previousRow.ItemArray[columnIndex] = newValue;
                            previousRow.AcceptChanges();
                            previousRow.EndEdit();
                        }
                    }
 
                    if(!matchLine)
                    {
                        if(previousRow != null)
                            newTable.Rows.Add(previousRow.ItemArray);
                        previousRow = newTable.NewRow();
                        previousRow.ItemArray = currentRow.ItemArray;
                    }
 
                }
                //originalTable.Clear();
                //originalTable.Merge(newTable, true);
            }
            return dataSet;
        }

qui est censé faire :
Dans une table d'un DataSet, parcourir toutes les lignes successives, si on trouve plusieurs lignes avec les mêmes valeurs (sauf pour le champ indiqué par columnIndex) on ne prend qu'une ligne et on concatène le contenu du champ [columnIndex] de toutes les lignes qui matches.
C'est clair ?

Premier problème : previousRow.ItemArray[columnIndex] = newValue; ne change pas de valeur.
2ème pbm : c'est une usine à gaz... Il n'y aurait pas plus simple ?
Merci

p.s. :
mes données sont du genre :

nom1,prénom1,champ à concat 1, integer
nom1,prénom1,champ à concat 2, integer
nom2,prénom2,champ à concat 1, integer
nom2,prénom2,champ à concat 2, integer
nom3,prénom3,"texte", integer

et je veux fusionner les lignes 1 & 2 , et 3 & 4

**tomlev** · 23/01/2012, 15h44

Tu peux faire ça avec Linq, il faut juste créer un IEqualityComparer spécifique pour comparer les lignes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
void MergeTableLignesByField(DataTable table, int columnIndex)
{
    var comparer = new DataRowComparer(columnIndex);
    var groups = table.AsEnumerable().GroupBy(r => r, comparer);
    foreach (var g in groups)
    {
        MergeRows(g, columnIndex);
    }
}
 
 
void MergeRows(IEnumerable<DataRow> rows, int columnToMerge)
{
    string mergedValue = string.Join("|", rows.Select(r => r[columnToMerge]));
    int count = 0;
    foreach (var row in rows)
    {
        if (count == 0)
            row[columnToMerge] = mergedValue;
        else
            row.Delete();
        count++;
    }
}
 
class DataRowComparer : IEqualityComparer<DataRow>
{
    private readonly int[] _excludedColumnIndexes;
    public DataRowComparer(params int[] excludedColumnIndexes)
    {
        _excludedColumnIndexes = excludedColumnIndexes;
    }
 
    public bool Equals(DataRow x, DataRow y)
    {
        for (int i = 0; i < x.Table.Columns.Count; i++)
        {
            if (_excludedColumnIndexes.Contains(i))
                continue;
            if (!Equals(x[i], y[i]))
                return false;
        }
        return true;
    }
 
    public int GetHashCode(DataRow row)
    {
        unchecked // Overflow is fine, just wrap
        {
            int hash = 17;
            for (int i = 0; i < row.Table.Columns.Count; i++)
            {
                if (_excludedColumnIndexes.Contains(i))
                    continue;
                object fieldValue = row[i];
                int fieldHash = fieldValue != null ? fieldValue.GetHashCode() : 0;
                hash = hash * 23 + fieldHash;
            }
            return hash;
        }
    }
}

(il faut référencer l'assembly System.Data.DataSetExtensions)

Au passage, j'ai fait une autre modif : le paramètre dataSet de ta méthode n'est pas utilisé, il est juste renvoyé tel quel, donc je l'ai viré et j'ai mis le type de retour en void

**kheironn** · 23/01/2012, 15h48

J'ai modifié mon code, la substitution s'opère :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
private static DataSet MergeTableLignesByField(DataSet dataSet, DataTable originalTable, int columnIndex)
        {
            if(originalTable.Rows.Count > 0 && originalTable.Rows[0].ItemArray[columnIndex] is string)
            {
                DataTable newTable = originalTable.Clone();
                newTable.Clear();
 
                object[] newValues = null;
                for(int i = 0; i < originalTable.Rows.Count; i++)
                {
                    DataRow currentRow = originalTable.Rows[i];
                    bool matchLine = false;
                    if(newValues != null)
                    {
                        // On compare les champs de deux lignes pour savoir si on peut les fusionner : tous les champs sont identiques sauf le champ spécifié
                        for(int j = 0; j < currentRow.ItemArray.Length; j++)
                            if(j != columnIndex)
                            {
                                matchLine = (currentRow.ItemArray[j].ToString() == newValues[j].ToString());
                                if(!matchLine)
                                    break;
                            }
                        //Si les lignes sont identiques, on peut les fusionner et merger le champ voulu.
                        if(matchLine)
                        {
                            newValues[columnIndex] = string.Concat(newValues[columnIndex].ToString(), " | ", currentRow.ItemArray[columnIndex].ToString());
                           // previousRow.ItemArray = newValues;
                        }
                    }
 
                    if(!matchLine)
                    {
                        if(newValues != null)
                            newTable.Rows.Add(newValues);
                        newValues = currentRow.ItemArray;
                    }
 
                }
                originalTable.Clear();
                originalTable.Merge(newTable, true);
            }
            return dataSet;
        }

J'ai vu ton code, Tomlev, je testerai pour ma culture => le besoin n'existe plus, on s'est aperçu qu'il existe des cas pour lesquels le problème de ligne ne serait pas réglé comme ça.

Mon DataSet, c'est parce que c'est du code appelé par 4 surcharges d'une méthode d'extension. Je pensais que c'était nécessaire :
voici l'un des surcharges :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
        public static DataSet MergeTableLignesByField(this DataSet dataSet, string tableName, string fieldName)
        {
            DataTable originalTable = dataSet.Tables[tableName];
            int columnIndex = originalTable.Columns[fieldName].Ordinal;
            return MergeTableLignesByField(dataSet, originalTable, columnIndex);
        }

Merci à toi.

**kheironn** · 24/01/2012, 12h34

Tomlev
Pour ma culture, j'ai testé ton code.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

rows.Select(r => r[columnToMerge])

me retourne null. Je ne comprends pas pourquoi.

**tomlev** · 24/01/2012, 14h23

Envoyé par kheironn

Tomlev
Pour ma culture, j'ai testé ton code.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

rows.Select(r => r[columnToMerge])

me retourne null. Je ne comprends pas pourquoi.

Bizarre, pourtant j'ai testé et chez moi ça fonctionne bien...

Qu'est-ce qui retourne null d'ailleurs ? Le Select ? normalement c'est pas possible, ça devrait renvoyer un IEnumerable<object>... Ou alors c'est juste r[columnToMerge] qui renvoie null pour certains r ? normalement c'est pas possible non plus, ça devrait renvoyer DBNull s'il n'y a pas de valeur

**kheironn** · 24/01/2012, 14h55

rows contient mes trois lignes (normal) et ajoute une dernière ligne null.
Ce serait donc la méthode de création des groupes qui ne va pas.

Remplacement de valeur dans DataTable

C#

Vue hybride

Discussions similaires

Partager

Partager