Remplacement de valeur dans DataTable

Version imprimable

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

Code:

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 :

Citation:

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

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

Code:

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

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

Code:

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:

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.

24/01/2012, 12h34
kheironn

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

Code:

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

me retourne null. Je ne comprends pas pourquoi.
24/01/2012, 14h23
tomlev

Citation:

Envoyé par kheironn

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

Code:

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
24/01/2012, 14h55
kheironn

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.
24/01/2012, 15h08
tomlev

Citation:

Envoyé par kheironn

rows contient mes trois lignes (normal) et ajoute une dernière ligne null.

Bizarre... pourtant les lignes de rows viennent d'un GroupBy sur les lignes de la table, et la table ne peut pas contenir une ligne nulle...

Sinon tu peux toujours essayer d'ajouter un .Where(r => r != null) avant le Select
24/01/2012, 17h29
kheironn

Merci pour l'info.
Comme le besoin n'existe plus, je vais remettre ça a plus tard.
Mon nouveau besoin est de récupérer toutes les lignes ayant des champs tous les champs identiques parmi une liste de champs. de faire un max sur un champ de mettre cette valeur sur la première ligne et 0 sur les autres.

C'est une correction de bug qui doit être validée avant d'être effectuée. Mais, avec ce que tu m'as fourni, je devrais pouvoir m'en tirer. Je manque de pratique sur LinQ...
Pour le comparer, j'ai remplacé

Code:

if (_excludedColumnIndexes.Contains(i)) continue;

par

Code:

if (!_excludedColumnIndexes.Contains(i)) continue;

Cela devrait me donner afin de passer une liste de champs à comparer plutôt qu'une liste de champs à exclure (en passant la-dite liste)
24/01/2012, 17h39
tomlev

Citation:

Envoyé par kheironn

C'est une correction de bug qui doit être validée avant d'être effectuée. Mais, avec ce que tu m'as fourni, je devrais pouvoir m'en tirer. Je manque de pratique sur LinQ...
Pour le comparer, j'ai remplacé

Code:

if (_excludedColumnIndexes.Contains(i)) continue;

par

Code:

if (!_excludedColumnIndexes.Contains(i)) continue;

Cela devrait me donner afin de passer une liste de champs à comparer plutôt qu'une liste de champs à exclure (en passant la-dite liste)

Bah dans ce cas renomme excludedColumnIndexes en includedColumnIndexes, sinon quand tu vas revenir sur ce code dans quelques mois, tu vas rien comprendre ;)

Citation:

Envoyé par tomlev

Bah dans ce cas renomme excludedColumnIndexes en includedColumnIndexes, sinon quand tu vas revenir sur ce code dans quelques mois, tu vas rien comprendre ;)

Mauvais copier-coller ;)

la classe devient

Code:

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
internal class DataRowComparer : IEqualityComparer<DataRow>
    {
        private readonly int[] _sameColumnIndexes;
        /// <summary>
        /// Initialise une nouvelle instance de DataRowComparer à partir d'un tableau d'index de colonnes identiques.
        /// </summary>
        /// <param name="sameColumnIndexes">tableau d'index des colonnes identiques</param>
        public DataRowComparer(params int[] sameColumnIndexes)
        {
            _sameColumnIndexes = sameColumnIndexes;
        }
 
        public bool Equals(DataRow x, DataRow y)
        {
            for(int i = 0; i < x.Table.Columns.Count; i++)
            {
                if(!_sameColumnIndexes.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(!_sameColumnIndexes.Contains(i))
                        continue;
                    object fieldValue = row[i];
                    int fieldHash = fieldValue != null ? fieldValue.GetHashCode() : 0;
                    hash = hash * 23 + fieldHash;
                }
                return hash;
            }
        }
    }