Discussion :

[panthere noire]

Bonjours,

J'ai trois liste

Code :

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

1
2
3
4
 
            List<string> l_Strfile;
            List<int> l_intsize;
            List<float> l_floatoct;

si je doit les passer en paramètre a une méthode cela donne:

Code :

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

1
2
 
  public void MaMethode(ref List<string> l_Strfile, ref List<int> l_intsize, ref List<float> l_floatoct){}

Si j'ajoute encore des listes cela va devenir impossible à lire. de faire une méthode qui appelle une autre méthode
c'est pas la solution non plus.

Comment je peux passer des listes qui sont de type diffèrent (string,int,float ,etc) en un seul paramètre ?

[PixelJuice]

Bonjour,

Une solution évidente serait de passer ta méthode en générique :

Code :

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

public void MaMethode<T>(List<T> list){}

Et l'utilisation serait

Code :

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

MaMethode<string>(l_Strfile);

et que tu pourras même résumé à

Code :

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

MaMethode(l_Strfile);

Mais cela ne marche que si le traitement que tu souhaites faire à la liste le même quel que soit son type. Il me semble que ça ne soit pas le cas non ?

Si ce n'est pas le cas, alors il serait judicieux de créer une nouvelle classe qui possède tous les paramètres dont tu essayes de dresser une liste chacun (file, size, oct), et de résumer le tout à une seule et unique liste d'objets.

Petite question, pourquoi tu as mis des ref un peu partout sur tes paramètres ?

[panthere noire]

Merci beaucoup pour ta réponse:

j'ai tenter de placer le code proposer:

Code :

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

public void MaMethode<T>(List<T> list){}

l'erreur :

Code :

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

Le nom de type ou d'espace de noms 'List<>' est introuvable

j'ai donc pas pu tester pour comprendre ?!

Mais cela ne marche que si le traitement que tu souhaites faire à la liste le même quel que soit son type. Il me semble que ça ne soit pas le cas non ?

alors oui la ça ce complique... ces liste son passée a sqlite en insert et c'est un peux le bazars a cause des using a ce taper avant de faire quoi que ce sois.
elle ne son pas identique par leur type, le traitement est différent vu que la requête change le nombre de liste.

Petite question, pourquoi tu as mis des ref un peu partout sur tes paramètres ?

je passe les listes en référence dans le but de ne pas en faire une copie, la quantiter de donnée pouvant fortement augmenter. je confond peux être avec le c++ et & mai je suppose que c est identique.


Pour l'instant c est pas terrible, mai sa fonctionne, je cherche un moyen de faire cela plus correct...

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Data.SQLite;
using System.Data.Common;
 
using static QuantiqueTime.Collapseoftime;//affichage personnaliser, même fonction de base
 
namespace NSqlISharp
{
    public class SqlInsert
    {
        //constructeur
        class SqlDataInsert { }
        public void T_FileNormal(ref List<string> l_fullpath, ref List<long> l_sizefile, string pdb)
        {
            string sql = "INSERT INTO T_FichierNormal(fullpath,sizefile,sha256)" +
            "values(@fullpath,@sizefile,@sha256)";
            SQLiteParameter[] parameters = new SQLiteParameter[]{
                                            new SQLiteParameter("@fullpath"),
                                            new SQLiteParameter("@sizefile"),
                                            new SQLiteParameter("@sha256") };
            SqlInsert sqlI = new SqlInsert();
            QuantiqueTime.Collapseoftime T = new QuantiqueTime.Collapseoftime();
 
            T.TimeExcute(true);
 
            sqlI.ExecuteNonQuery(sql, parameters, pdb, ref l_fullpath, ref l_sizefile);
            T.TimeExcute(false);
        }
        private int ExecuteNonQuery(string sql, SQLiteParameter[] parameters, string pdb, ref List<string> l_fullpath, ref List<long> l_sizefile)
        {
            int affectedRows = 0;
            string Buffersha256 = "";
            Allfile.CFileSystem MeFile;
            MeFile = new Allfile.CFileSystem();
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(pdb))
                {
                    connection.Open();
                    using (DbTransaction transaction = connection.BeginTransaction())
                    {
                        using (SQLiteCommand command = new SQLiteCommand(connection))
                        {
                            command.CommandText = sql;
                            //boucler sur les liste ?
                            for (int i = 0; i < l_fullpath.Count(); i++)
                            {
 
                                Buffersha256 = MeFile.Ssha256sum(l_fullpath[i]);
                                if (Buffersha256 != "0")
                                {
                                    parameters[0].Value = l_fullpath[i];
                                    parameters[1].Value = l_sizefile[i];
                                    parameters[2].Value = Buffersha256;
                                    command.Parameters.AddRange(parameters);
                                    affectedRows = command.ExecuteNonQuery();
                                }
                                else
                                {
                                    Console.WriteLine("Erreur: " + l_fullpath[i] + " : " + Buffersha256); ;
                                }
                            }
 
                        }
                        transaction.Commit();
                    }
                    connection.Close();
                }
            }
            catch (SQLiteException sqle)
            {
                Sql_Printerror(ref pdb, ref sqle);
            }
            return affectedRows;
        }
 
        private void Sql_Printerror(ref string pdb, ref SQLiteException sqle)
        {
            Console.WriteLine("************************************************");
            Console.WriteLine("Erreur sur la base de donnée (insert) fichier Sqlinsert.cs");
            Console.WriteLine(pdb);
            Console.WriteLine(sqle);
            Console.WriteLine("************************************************");
 
            Sleep(20);
 
        }
    }
}

Merci pour ta réponse.

[Pol63]

IEnumerable

[panthere noire]

IEnumerable

Merci pour l'information et ta réponse.

J'ai un peux de mal a comprendre, ce que cela peux changer .

je résume ce que je suppose avoirs compris. en fonction des informations que j'ai trouvé, comme toutes informations cela demande aussi une confirmation.

La liste est chargée en mémoire. IEnumerable ne le fait pas.
j'ai pas vérifier mai la liste est plus rapide que IEnumerable ?
IEnumerable permet l'utilisation de foreach. si GetEnumerator() est implémenter .

je peux donc implémenter avec IEnumerable un classe qui contiens des liste accessible par des méthode d'accès.
ensuite je passe plus par référence les liste, mai j'utilise IEnumerable qui me permet d'acceder aux méthode qui me permette d'avois accès aux liste?

ou je vire les liste et j'utilise que IEnumerable,mai j'ai un peux peur côter performance ?

ou j'ai rien compris ?

[Noxen]

je passe les listes en référence dans le but de ne pas en faire une copie, la quantiter de donnée pouvant fortement augmenter. je confond peux être avec le c++ et & mai je suppose que c est identique.

Là faut réviser les bases ; les listes sont des types références donc il n'y a pas de copie, quand tu utilises le mot-clé ref c'est la variable elle-même que tu passes en référence (en gros c'est un pointeur de pointeur, pour parler en C++).

J'ai l'impression que tu veux passer des listes de données coordonnées (chemin de fichier et taille de fichier), dans ce cas tu peux faire un objet qui contient toutes ces informations pour un fichier et ensuite faire une liste des ces objets. Ou éventuellement voir du côté de DataTable si tu n'es pas certain des données à passer à chaque fois.

[panthere noire]

Là faut réviser les bases ; les listes sont des types références donc il n'y a pas de copie, quand tu utilises le mot-clé ref c'est la variable elle-même que tu passes en référence (en gros c'est un pointeur de pointeur, pour parler en C++).

J'ai l'impression que tu veux passer des listes de données coordonnées (chemin de fichier et taille de fichier), dans ce cas tu peux faire un objet qui contient toutes ces informations pour un fichier et ensuite faire une liste des ces objets. Ou éventuellement voir du côté de DataTable si tu n'es pas certain des données à passer à chaque fois.

Oups il fallait savoir que les list sont déjà en/une référence, j'ai du passer a coter , merci pour cette précision.

DataTable j'avais vu un peux de documentation c'est pas encore nécessaire.

Je préfère déjà faire avec, comme tu la bien interpréter, des listes de données coordonnées.
Quand tu parles de faire un objet il me manquai si on peux dire l'outil (si on peux dire cela..) IEnumerable semble résoudre le problème. je me penche donc sur la question.

Merci pour ta réponse

[Pol63]

non quand je disais ienumerable c'est que tes 3 liste en héritent, donc si tu veux un type générique pour un paramètre ca pourrait convenir

Code :

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

public void method (ienumerable laliste)

après tu peux faire un foreach ou autre


par contre je rejoins Noxen, en c# on fait de la POO, ca simplifie la lecture et l'écriture du code

Code :

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

1
2
3
4
5
6
public class FileInformation 
{
  public string File {get;set;}
  public int Size {get;set;}
  public float oct {get;set;}
}

Code :

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

List<FileInformation> files

Code :

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

1
2
3
4
5
var fi = new FileInformation();
fi.File = "";
fi.Size = ...;
// ...
files.Add(fi);

ca simplifie aussi la modification du code
si tu dois ajouter une information plus tard avec ta méthode tu ajoutes une variable, puis tu modifies la signature (en ajoutant un paramètre) et le code de chaque méthode
avec une classe tu ajoutes une propriétés et dans les méthodes où tu dois écrire ou accéder à cette info elle est déjà dispo sur chaque instance contenu dans la collection

les datatables par contre c'est un peu trop old school, et ca n'apporte pas l'intellisense