Discussion :

[eagleleader]

Bonjour tout le monde,

Je me retrouve coincé par rapport aux List<string>:
J'ai créé une méthode qui me renvoie une List<List<string>>.
Dans cette méthode, c'était facile de créer X List<string> et ensuite de les ajouter dans une liste globale.

Maintenant je souhaiterais faire l'inverse mais je ne sais pas combien de listes il y a à l'intérieur de la liste globale.
Exemple:

Code :

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

1
2
3
4
public void Decoupage(ref List<List<string>> listeGlobale)
{
    // Comment récupérer les X List<string> dynamiquement ?
}

Je sais que l'on peut faire ceci :

Code :

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

1
2
3
4
foreach (List<string> liste in listeGlobale)
{
    // Mais comment récupérer cette liste dynamiquement ?
}

Je sais aussi qu'on peut faire un List.Count afin d'obtenir le nombre de liste mais alors comment créer X liste dynamiquement ?

D'avance merci pour votre lecture et votre aide.

[youtpout978]

Je ne comprends pas ce que tu cherches à faire et dans quel but.

[eagleleader]

Exemple:

Cette fonction me crée une liste de listes.
L'avantage à ce moment là c'est que je sais en combien de listes je dois répartir ma liste originale via le paramètre numberOfListToCreate.
Imaginons que ce paramètre vaut 3.
Je vais donc découper ma liste originale en 3 listes et tout regrouper dans une liste de listes.

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
 
public List<List<string>> SeparateThestringInDifferentLists(IEnumerable<string> listOfStringToSeparate, int numberOfListToCreate)
		{
			List<List<string>> listOfstringToReturn = new List<List<string>>();
			List<string> list = new List<string>(listOfStringToSeparate.ToList());
 
			for (int i = 0; i < numberOfListToCreate; i++)
			{
				List<string> newListOfstring = new List<string>();
 
				for (int j = i; j < list.Count; j += numberOfListToCreate)
				{
					newListOfstring.Add(list[j]);
				}
 
				listOfstringToReturn.Add(newListOfstring);
			}
 
			return listOfstringToReturn;
		}

Maintenant je suis dans une autre méthode (DECOUPAGE) qui elle ne connait pas le nombre de listes que contient la liste de listes.
Comment récupérer les 3 listes qui se trouvent dans ma liste de listes au sein de la fonction DECOUPAGE ?

[azstar]

bonjour;

tu peut utilise un séparateur (une valeur que ne va être jamais utilise comme valeur pour tes chaines string)

je dit n'importe quoi exemple ";"

Code :

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

1
2
3
4
5
6
7
 
 
foreach(strring str in list)
{
  if(str==";")
 //nouveau list 
}

[eagleleader]

Ce n'est pas cela que je recherche.
Imaginez un autre exemple, au lieu d'avoir des listes de strings, vous auriez des listes d'objets, il est impossible de pouvoir utiliser des caractères de séparation.

De plus on a une liste de listes donc les éléments sont bel et bien séparés
Ce que je cherche à faire c'est l'inverse de ma fonction de création.

Ma première méthode crée des listes et puis les ajoutent dans une liste globale.
Je souhaite donc prendre cette liste globale et récupérer les différentes listes qui sont dedans.

Et pour cela, je souhaiterais créer autant de listes qu'il y a dans cette liste globale. Ma contrainte est que je ne sais combien de sous-listes sont dans cette liste et comment créer ces X sous-listes.

[azstar]

si jai bien compris tu veux faire une déclaration de ce genre

Code :

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

1
2
3
4
5
6
 
List<string> list0=List[0];
List<string> list1=List[1];
List<string> list2=List[2];
List<string> list3=List[3];
........

dont list0,list1...... sont les listes inclus dans la liste globale??

[eagleleader]

Exact, et je ne sais comment les créer dynamiquement

[azstar]

je peut savoir pourquoi tu faire veux comme ça ;je peut savoir le problème principale

[eagleleader]

Ce que je souhaite c'est de balader des listes d'objets à travers mon application.
Le moyen pour le moment que j'ai trouvé c'est de mettre mes listes dans une liste globale.
Voilà pourquoi je suis partis sur une liste de listes.

Si tu as une autre idée je suis preneur.

[azstar]

je parle de la fonctionnalité source de ce que tu code ; comme ça si je comprend ce que tu veux faire par le balayage des listes des objets ;je peut peut être capable de trouver une autre idée simple à mettre en oeuvre

[youtpout978]

Le contraire de ta fonction de decoupage c'est de reconstitué cette liste en une seule liste et pas recrée autant de liste que tu en as dans ta liste globale:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
        public List<string> CreateSingleList(List<List<string>> listOfStringSeparate)
        {
            List<string> list = new List<string>();
 
            foreach (List<string> item in listOfStringSeparate)
            {
                list.AddRange(item);
            }
 
            return list;
        }

Tu dois quand même savoir à quoi va ressembler ton résultat, de là tu peux créer une classe qui contiendra tes différents objets et c'est cette classe que tu trimballeras dans ton application.

[sisqo60]

Bonjour,

J'ai essayé de comprendre la finalité de cette fonction mais sans succès
Mais l'exercice m'a intéressé, donc voici une ébauche de ce que j'ai compris que tu souhaitais faire :

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
        private List<List<string>> Decouper(List<string> liste, int pNombreDeListes)
        {
            if (pNombreDeListes <= 0)
                throw new ArgumentException("le nombre de liste doit être au moins égal à 1.", "pNombreDeListes");
            List<List<string>> retour = new List<List<string>>(pNombreDeListes);
            int nbElementsParListe = liste.Count / pNombreDeListes + 1;
            //Création des listes
            for (int i = 0; i < pNombreDeListes; i++)
            {
                retour.Add(new List<string>(nbElementsParListe));
            }
            //On remplit toutes les listes à l'aide de la liste passée en paramètre.
            for (int i = 0; i < liste.Count; i++)
            {
                retour[i % pNombreDeListes].Add(liste[i]);
            }
 
            return retour;
        }

Bon dév.

[eagleleader]

Merci pour vos réponses.

C'est vrai que je n'explique pas forcément bien.
Voici donc ce que je voudrais faire

Code :

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

1
2
3
4
5
6
7
8
9
void Decoupage(ref List<List<objet>> listeADecouper)
{
// Je sais qu'avec une boucle ça ne marche pas mais c'est un exemple
foreach(List<objet> liste in listeADecouper)
{
// Ici je récupère une liste -> C'est ce que je veux
List<objet> newList = liste
}
}

Le problème c'est que là je sais les parcourir mais une par une uniquement.
Or moi je voudrais avoir les X listes d'un coup.
Deuxième problème, une fois sortis de cette boucle je ne saurai plus accéder à mes X listes.

Code :

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

1
2
3
4
// Exemple: 1ère itération de la boucle
List<objet> list1 = liste
// 2ème itération: avoir une deuxième liste
List<objet> list2 = liste

Le but est de manipuler les X listes par la suite et non regrouper mes listes dans une autre liste globale -> cela ne me servirait à rien.

J'ai cherché un exemple concret et j'en ai trouvé un:
Imaginez que vous avec au départ 12 livres, que 3 clients viennent et prennent chacun 4 livres.
chaque client a donc une pile de livres.
Le but de ma première méthode est de créer ces 3 listes d'objets (qui représentent chacune une pile de livres pour un client).
La méthode renvoie une liste globale qui contient donc 3 listes.

Dans une autre méthode, je souhaite par exemple examiner chaque livres des 3 piles en les comparants entre eux.
Pour par exemple, regarder le 1er livre de chaque pile ou que sais-je encore.

Donc je vais devoir créer une méthode qui reçoit en paramètre une liste globale. De cette liste globale il faut que je détermine combien de piles de livres (combien de Listes) se trouvent à l'intérieur.
Ensuite je dois créer autant de piles que j'en ai trouvé.
Donc je récupère les 3 piles de livres.

Mon but n'est pas de rassembler les 3 piles en une seule car je veux pouvoir utiliser ces piles (List<objet>) les unes par rapport aux autres par la suite dans mon code.

[youtpout978]

Je pense que tu t'y prends mal, dans ce cas là je créerai une classe Livre qui contiendrait les différentes informations sur le livre, une classe client qui contiendra les informations sur le client et cette même classe client contient une propriété List<Livre> pour les livres qu'il a emprunté.
Et de là tu peux récupérer pour chaque client la liste des livres qu'il a emprunté.

[azstar]

alors tu a un problème de conception non pas de réalisation ;il faut essayer le maximum de penser en orienté objet afin rester dans la possibilité de réaliser ce que tu a met dans ta conception .

simple et rapide exemple

dans la classe Livre tu peut mettre L'identifiant de l'utilisateur qui la le livre sinon tu peut mettre -1.

alors tu aura une liste ou tu a toutes tes livres mais bien sûr avec son état prêtée o non par un utilisateur.

et tu pourra avoir 1000 façons de résoudre ton problème mais il faut rester en orienté objet .

[eagleleader]

Ici j'ai choisi un exemple pour vous expliquer mais il n'y a aucun client donc je ne sais lier un client à une pile.
Je dois garder le concept de me balader avec ces piles et les traiter.

[azstar]

je pense pas que c'est faisable l’extrême à faire c'est d'utiliser la réflexion

[youtpout978]

C'est pas parce que ta liste est comprise dans une autre liste que tu ne peux pas travaillé avec mais je vois pas pourquoi tu veux faire ça:

Code :

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

1
2
3
4
5
6
 
List<string> list0=List[0];
List<string> list1=List[1];
List<string> list2=List[2];
List<string> list3=List[3];
........

alors que tu parcourir chaque liste avec un foreach ou un for et faire le traitement que tu veux, ou peut être tu devrais utiliser un dictionnaire avec comme clé un élément qui permet de savoir sur quel liste tu travail et en valeur la liste en question: Dictionary

[morgand]

Bonjour à tous,

Je pense que globalement tu as la réponse à pratiquement toutes tes questions mais tu n'as pas eu une réponse autour l'exploitation de tes listes d'un seul coup ?

Alors je vais nommer les List juste puor savoir ce que nous faisons :

List<List<string>> => MaListPrincipale : List<.(de liste).>
UneDeMesListesSecondaires : List<string>

Alors tu as deux solutions, la première est :

Code :

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

1
2
3
4
5
6
 
foreach(UneDeMesListesSecondaires item in MaListPrincipale)
{
      Thread thread = new Thread(new ThreadParameters( TAMETHOD ));
      thread.Start(item);
}

Tu vas créer un Thread pour chaque List que tu as pour exécuter TAMETHOD avec en paramètre un object que tu devras caster en List<string>

Seconde solution, je te conseil de regarde ici

J'espère avoir répondu à une partie de ton problème