erreur de cast dans l'expression d'un foreach

Tu es sur que this.aListeArticle contient bien des objets de type Article ?

A+

-------------------
LEBRUN Thomas
http://morpheus.developpez.com
http://morpheus.developpez.com/blog/


"grome" a écrit :

Bonjour à tous,

Je comprend pas trop ce qui se passe avec le code ci dessous. J'ai une
erreur de cast sur le foreach de la méthode. Je n'ai pas posté tout le code
de la classe mais je voulais précisé que la classe article est dans le même
namespace que la classe catalogue. Elle sont toutes les deux indépendantes.

Erreur obtenue sur la ligne du foreach : Détails de l'exception:
System.InvalidCastException: Le cast spécifié n'est pas valide.

Est ce que quelqu'un pourrait m'en dire plus ?

Merci d'avance.

Jérôm qui débute en C#



public class Catalogue
{
public ArrayList aListeArticle= new ArrayList();

public MaClasse()

public void ParcourirCatalogue(string Pente)
{

foreach(MonNameSpace.Article MonArticle in this.aListeArticle)
{

//
// traitement

}

}
}

Et bien justement je viens de trouver mon erreur. Le aListeArticle ne
contenait pas d'objet article.
C'est corrigé J'ai mis dans mon ArrayList des objets article.

Je me retrouve confronté à un autre problème, le tri des articles dans le
arraylist sachant que je veux faire le tri sur une des propriété de l'objet.
D'après ce que je comprend il faut que je cherche du côté de iComparer...



"LEBRUN Thomas" <lebrun_thomas_at_hotmail.com> a écrit dans le message de
news: F8DEAA68-D91A-41DC-8F31-7B45B27B1E88@microsoft.com...

Tu es sur que this.aListeArticle contient bien des objets de type Article
?

A+

-------------------
LEBRUN Thomas
http://morpheus.developpez.com
http://morpheus.developpez.com/blog/


"grome" a écrit :

Il y a plusieurs façons de faire, mais le plus simple c'est que chaque objet
Article implémente IComparable

en gros (de tête, ca ne compile peut-être pas :-), et en supposant que la
propriété à utiliser soit elle même comparable (ce qui est fréquent):

class Article: IComparable
{
...
public CompareTo(object obj)
{
Article article = obj as Article;
if (article == null)
throw new ArgumentException();

return this.MyProperty.CompareTo(article.MyProperty);
}
...
}

Simon Mourier

"grome" <no@spam.fr> a écrit dans le message de news:
41c30a97$0$4662$626a14ce@news.free.fr...

Et bien justement je viens de trouver mon erreur. Le aListeArticle ne
contenait pas d'objet article.
C'est corrigé J'ai mis dans mon ArrayList des objets article.

Je me retrouve confronté à un autre problème, le tri des articles dans le
arraylist sachant que je veux faire le tri sur une des propriété de
l'objet.
D'après ce que je comprend il faut que je cherche du côté de iComparer...



"LEBRUN Thomas" <lebrun_thomas_at_hotmail.com> a écrit dans le message de
news: F8DEAA68-D91A-41DC-8F31-7B45B27B1E88@microsoft.com...

Tu es sur que this.aListeArticle contient bien des objets de type Article
?

A+

-------------------
LEBRUN Thomas
http://morpheus.developpez.com
http://morpheus.developpez.com/blog/


"grome" a écrit :

En fait il faut que j'utilise çà pour programmer le tri moi même. Est qu'il
pourrait exister une classe qui dispose d'une sort qui fasse cela.
La méthode sort de l'arraylist est surchargée mais je comprend pas comment
çà fonctionne.

une des surcharges est

sort(System.Collections.Comparer IComparer)



"Simon Mourier [MS]" <simonm@online.microsoft.com> a écrit dans le message
de news: ugG4o3e5EHA.992@TK2MSFTNGP12.phx.gbl...

Il y a plusieurs façons de faire, mais le plus simple c'est que chaque
objet Article implémente IComparable

en gros (de tête, ca ne compile peut-être pas :-), et en supposant que la
propriété à utiliser soit elle même comparable (ce qui est fréquent):

class Article: IComparable
{
...
public CompareTo(object obj)
{
Article article = obj as Article;
if (article == null)
throw new ArgumentException();

return this.MyProperty.CompareTo(article.MyProperty);
}
...
}

Simon Mourier

J'ai compris comment çà fonctionne, enfin à peu près.

J'ai trouvé des choses très interessante sur
http://www.c2i.fr/code.aspx?IDCodeU9

Merci encore


"Simon Mourier [MS]" <simonm@online.microsoft.com> a écrit dans le message
de news: ugG4o3e5EHA.992@TK2MSFTNGP12.phx.gbl...

Il y a plusieurs façons de faire, mais le plus simple c'est que chaque
objet Article implémente IComparable

en gros (de tête, ca ne compile peut-être pas :-), et en supposant que la
propriété à utiliser soit elle même comparable (ce qui est fréquent):

class Article: IComparable
{
...
public CompareTo(object obj)
{
Article article = obj as Article;
if (article == null)
throw new ArgumentException();

return this.MyProperty.CompareTo(article.MyProperty);
}
...
}

Simon Mourier

"grome" <no@spam.fr> a écrit dans le message de news:
41c30a97$0$4662$626a14ce@news.free.fr...

Et bien justement je viens de trouver mon erreur. Le aListeArticle ne
contenait pas d'objet article.
C'est corrigé J'ai mis dans mon ArrayList des objets article.

Je me retrouve confronté à un autre problème, le tri des articles dans le
arraylist sachant que je veux faire le tri sur une des propriété de
l'objet.
D'après ce que je comprend il faut que je cherche du côté de iComparer...



"LEBRUN Thomas" <lebrun_thomas_at_hotmail.com> a écrit dans le message de
news: F8DEAA68-D91A-41DC-8F31-7B45B27B1E88@microsoft.com...

Tu es sur que this.aListeArticle contient bien des objets de type
Article ?

A+

-------------------
LEBRUN Thomas
http://morpheus.developpez.com
http://morpheus.developpez.com/blog/


"grome" a écrit :

La méthode Sort() sans paramètre utilise implicitement l'interarface
IComparable de chaque objet dans la liste. Pas besoin justement dans ce cas
d'utiliser des comparers spécifiques ou d'en créer.

Simon.

"grome" <no@spam.fr> a écrit dans le message de news:
O2dUTSn5EHA.2568@TK2MSFTNGP11.phx.gbl...

En fait il faut que j'utilise çà pour programmer le tri moi même. Est
qu'il pourrait exister une classe qui dispose d'une sort qui fasse cela.
La méthode sort de l'arraylist est surchargée mais je comprend pas comment
çà fonctionne.

une des surcharges est

sort(System.Collections.Comparer IComparer)



"Simon Mourier [MS]" <simonm@online.microsoft.com> a écrit dans le message
de news: ugG4o3e5EHA.992@TK2MSFTNGP12.phx.gbl...

Il y a plusieurs façons de faire, mais le plus simple c'est que chaque
objet Article implémente IComparable

en gros (de tête, ca ne compile peut-être pas :-), et en supposant que la
propriété à utiliser soit elle même comparable (ce qui est fréquent):

class Article: IComparable
{
...
public CompareTo(object obj)
{
Article article = obj as Article;
if (article == null)
throw new ArgumentException();

return this.MyProperty.CompareTo(article.MyProperty);
}
...
}

Simon Mourier

Voilà ce que j'ai écrit comme classe (ci dessous) c'est peut être pas très
propre étant donné que je débute en dot net et donc en C#.
Les objets fermettes sont souvent utilisés dans des arraylist. Ce son ces
derniers que je tri. Pour cela trois fàcon de faire.

1 - J'utilise ceci :
MonArrayList.Sort() qui tri sur la référence (si j'ai bien compris le code
que j'ai mis en oeuvre c'est grace au compareto de la classe ci dessous)

2 - J'utilise une surcharge de sort :
MonArrayList.Sort(new Fermette.PenteComparer()) qui tri sur une autre
propriété (ici la pente)

3 - Ou bien encore :
MonArrayList.Sort(new Fermette.LongueurComparer()) qui tri sur une autre
propriété (ici la longueur)

Voilà j'espère que çà peut servir à quelqu'un.
Sinon j'ai trouvé tout ceci sur les deux liens ci dessous très interessants.

Qu'en pensez vous ?

http://www.c2i.fr/code.aspx?IDCodeU9
http://www.c2i.fr/code.aspx?IDCodeV1

Une remarque je reste bluffé par la puissance des arraylist et leur rapidité
dans les traitements que j'ai mis en oeuvre. Pour manipuler des objets, des
données de toute sorte c'est vraiment un super outil.


/// <summary>
/// Classe Fermette
/// Le comparateur par defaut de la classe fermette est la propriété
p_reference
/// </summary>

public class Fermette : IComparable
{
//
// ici il y a les propriétés et les attributs
//

public Fermette()
{
//
// TODO : ajoutez ici la logique du constructeur
//
}


/// <summary>
/// La méthode de tri ci dessous permet de trier sur la reference un
arraylist
/// qui contiendrait des objets Fermette. Pour utiliser cette
fonctionnalité
/// Il suffit d'ecrire aList.sort() et l'arraylist se retrouvera trier sur
la refernce.
/// Il existe cependant une autre méthode qui consiste à définir un classe
à l'interieur de
/// la classe fermette. Cette classe implemente le iComparer. Voir les
deux classes ci
/// dessous. LongueurComparer et PenteComparer
/// </summary>
/// <param name="obj">Le paramètre est un de type object</param>
/// <returns>La valeur de retour est de type int</returns>

public int CompareTo(object obj)
{
if (obj.GetType() != typeof(Fermette))
throw new ArgumentException("Impossible de comparer deux objets de type
différent");
return this.p_reference.CompareTo(((Fermette) obj).p_reference );
}


/// <summary>
/// Classe Comparer pour le tri sur la Pente.
/// pour l'utiliser il faut faire :
/// aList.Sort(new Fermette.PenteComparer());
/// </summary>

public class PenteComparer : IComparer
{
public int Compare(object obj1, object obj2)
{
if (obj1.GetType() != typeof(Fermette) || obj2.GetType() !=
typeof(Fermette))
throw new ArgumentException("Impossible de comparer deux objets de type
différent.");
return ((Fermette) obj1).p_pente.CompareTo(((Fermette) obj2).p_pente);
}
}

/// <summary>
/// Classe Comparer pour le tri sur la longueur.
/// pour l'utiliser il faut faire :
/// aList.Sort(new Fermette.LongueurComparer());
/// </summary>

public class LongueurComparer : IComparer
{
public int Compare(object obj1, object obj2)
{
if (obj1.GetType() != typeof(Fermette) || obj2.GetType() !=
typeof(Fermette))
throw new ArgumentException("Impossible de comparer les choux et les
carottes");
return ((Fermette) obj1).p_longueur.CompareTo(((Fermette)
obj2).p_longueur);
}
}

}

J'oubliais ...

Merci encore.


"Simon Mourier [MS]" <simonm@online.microsoft.com> a écrit dans le message
de news: uJKEMlz5EHA.2512@TK2MSFTNGP09.phx.gbl...

La méthode Sort() sans paramètre utilise implicitement l'interarface
IComparable de chaque objet dans la liste. Pas besoin justement dans ce
cas d'utiliser des comparers spécifiques ou d'en créer.

Simon.

"grome" <no@spam.fr> a écrit dans le message de news:
O2dUTSn5EHA.2568@TK2MSFTNGP11.phx.gbl...

En fait il faut que j'utilise çà pour programmer le tri moi même. Est
qu'il pourrait exister une classe qui dispose d'une sort qui fasse cela.
La méthode sort de l'arraylist est surchargée mais je comprend pas
comment çà fonctionne.

une des surcharges est

sort(System.Collections.Comparer IComparer)



"Simon Mourier [MS]" <simonm@online.microsoft.com> a écrit dans le
message de news: ugG4o3e5EHA.992@TK2MSFTNGP12.phx.gbl...

Il y a plusieurs façons de faire, mais le plus simple c'est que chaque
objet Article implémente IComparable

en gros (de tête, ca ne compile peut-être pas :-), et en supposant que
la propriété à utiliser soit elle même comparable (ce qui est fréquent):

class Article: IComparable
{
...
public CompareTo(object obj)
{
Article article = obj as Article;
if (article == null)
throw new ArgumentException();

return this.MyProperty.CompareTo(article.MyProperty);
}
...
}

Simon Mourier

Chipotons un peu... :-)

Le fait d'utiliser les comparers est un choix qui se tient puisque vous avez
deux modes de comparaison. En revanche l'implémentation peut être considérée
comme incorrecte (il fallait réutiliser ma proposition :-):
En effet, si je crée un objet, disons "SuperFermette" qui dérive de Fermette

class SuperFermette: Fermette
{
.. blabla ..
}

alors, je ne peux plus utiliser mes comparers!
public int CompareTo(object obj)
{
if (obj.GetType() != typeof(Fermette))
throw new ArgumentException("Impossible de comparer deux objets de type
différent");
return this.p_reference.CompareTo(((Fermette) obj).p_reference );
}

car il utilise le type exact de l'objet passé.

Il faut faire:

public int CompareTo(object obj)
{
Fermette fermette = obj as Fermette;
if (fermette != null)
throw new ArgumentException("obj n'est pas de type Fermette ou
dérivé"); // si vous voulez donner de l'aide, faites le complètement :-)
return this.p_reference.CompareTo(fermette.p_reference ); // on
n'utilise qu'un seul cast en tout, et le code est plus lisible
}

Simon.

"grome" <no@spam.fr> wrote in message
news:41c928b6$0$6541$626a14ce@news.free.fr...

Voilà ce que j'ai écrit comme classe (ci dessous) c'est peut être pas très
propre étant donné que je débute en dot net et donc en C#.
Les objets fermettes sont souvent utilisés dans des arraylist. Ce son ces
derniers que je tri. Pour cela trois fàcon de faire.

1 - J'utilise ceci :
MonArrayList.Sort() qui tri sur la référence (si j'ai bien compris le code
que j'ai mis en oeuvre c'est grace au compareto de la classe ci dessous)

2 - J'utilise une surcharge de sort :
MonArrayList.Sort(new Fermette.PenteComparer()) qui tri sur une autre
propriété (ici la pente)

3 - Ou bien encore :
MonArrayList.Sort(new Fermette.LongueurComparer()) qui tri sur une autre
propriété (ici la longueur)

Voilà j'espère que çà peut servir à quelqu'un.
Sinon j'ai trouvé tout ceci sur les deux liens ci dessous très

interessants.

Qu'en pensez vous ?

http://www.c2i.fr/code.aspx?IDCodeU9
http://www.c2i.fr/code.aspx?IDCodeV1

Une remarque je reste bluffé par la puissance des arraylist et leur

rapidité

dans les traitements que j'ai mis en oeuvre. Pour manipuler des objets,

des

données de toute sorte c'est vraiment un super outil.


/// <summary>
/// Classe Fermette
/// Le comparateur par defaut de la classe fermette est la propriété
p_reference
/// </summary>

public class Fermette : IComparable
{
//
// ici il y a les propriétés et les attributs
//

public Fermette()
{
//
// TODO : ajoutez ici la logique du constructeur
//
}


/// <summary>
/// La méthode de tri ci dessous permet de trier sur la reference un
arraylist
/// qui contiendrait des objets Fermette. Pour utiliser cette
fonctionnalité
/// Il suffit d'ecrire aList.sort() et l'arraylist se retrouvera trier

sur

la refernce.
/// Il existe cependant une autre méthode qui consiste à définir un

classe

à l'interieur de
/// la classe fermette. Cette classe implemente le iComparer. Voir les
deux classes ci
/// dessous. LongueurComparer et PenteComparer
/// </summary>
/// <param name="obj">Le paramètre est un de type object</param>
/// <returns>La valeur de retour est de type int</returns>

public int CompareTo(object obj)
{
if (obj.GetType() != typeof(Fermette))
throw new ArgumentException("Impossible de comparer deux objets de

type

différent");
return this.p_reference.CompareTo(((Fermette) obj).p_reference );
}


/// <summary>
/// Classe Comparer pour le tri sur la Pente.
/// pour l'utiliser il faut faire :
/// aList.Sort(new Fermette.PenteComparer());
/// </summary>

public class PenteComparer : IComparer
{
public int Compare(object obj1, object obj2)
{
if (obj1.GetType() != typeof(Fermette) || obj2.GetType() ! > typeof(Fermette))
throw new ArgumentException("Impossible de comparer deux objets de

type

différent.");
return ((Fermette) obj1).p_pente.CompareTo(((Fermette) obj2).p_pente);
}
}

/// <summary>
/// Classe Comparer pour le tri sur la longueur.
/// pour l'utiliser il faut faire :
/// aList.Sort(new Fermette.LongueurComparer());
/// </summary>

public class LongueurComparer : IComparer
{
public int Compare(object obj1, object obj2)
{
if (obj1.GetType() != typeof(Fermette) || obj2.GetType() ! > typeof(Fermette))
throw new ArgumentException("Impossible de comparer les choux et les
carottes");
return ((Fermette) obj1).p_longueur.CompareTo(((Fermette)
obj2).p_longueur);
}
}

}

C'est vrai jamais pas pensé à çà... j'en prend bonne note...
merci encore

Le fait d'utiliser les comparers est un choix qui se tient puisque vous
avez
deux modes de comparaison. En revanche l'implémentation peut être
considérée
comme incorrecte (il fallait réutiliser ma proposition :-):
En effet, si je crée un objet, disons "SuperFermette" qui dérive de
Fermette

class SuperFermette: Fermette
{
.. blabla ..
}

alors, je ne peux plus utiliser mes comparers!
public int CompareTo(object obj)
{
if (obj.GetType() != typeof(Fermette))
throw new ArgumentException("Impossible de comparer deux objets de type
différent");
return this.p_reference.CompareTo(((Fermette) obj).p_reference );
}

car il utilise le type exact de l'objet passé.