C# et Array non dimensionné ?

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : C# et Array non dimensionné ?

Arjuna

Aircraft Ident.: F-MBSD

Salut, je suis en train d'écrire une classe "Node" me permettant de modéliser un graph.

Alors...

Une node comporte deux propriétés A et B
Une node peut être liée à d'autres nodes

J'ai donc commencé à écrire le code suivant :

Code :

public class Node
{
public int A, B;
private Node[] linkedNodes = new Node[];
Node(int a, int b)
{
this.A = a;
this.B = b;
}
public void LinkToNode(ref Node node)
{
LinkToNode(ref node, true);
}
protected void LinkToNode(ref Node node, bool canCallback)
{
if (node == this)
{
System.Exception exp = new System.Exception("Can't link a node to itself!" );
}
for (int i = 0; i < linkedNodes.Length; i++)
{
if (linkedNodes[i] == node)
{
return;
}
}
linkedNodes[linkedNodes.Length] = node;
if (canCallback)
{
Node nodeRef = this;
node.LinkToNode(ref nodeRef, false);
}
}
}

Sauf qu'évidement, il n'aime pas "Node[] linkedNodes = new Node[];".
Si je ne fais pas de "new", alors il n'aime pas plus, il m'indique que pour pouvoir utiliser mon array, je dois l'avoir instancié avec un new.
Comment faire ?

Deplus, plutôt que me trimballer des "ref" un peu partout, j'aurais préféré utiliser des pointeurs. C'est quoi la différence d'ailleurs entre un "ref" et un pointeur ? Un "ref", ça correspond bien à un "*variable" ou si ça n'a rien à voir ? (si c'est le cas, alors ça devrait aller)

M'enfin mon vrai problème pour le moment, c'est ce array.

Ca m'ennuie de le dimensionner à l'avance, car non seulement je vais me retrouver avec une limitation en nombre de nodes liées à une node, mais en plus, et surtout, je sais pas trop ce que je vais mettre dedans ! Des valeurs "null" ?

Message édité par Arjuna le 26-08-2005 à 22:38:57

Publicité

Arjuna

Aircraft Ident.: F-MBSD

En tout cas, le "ref" fait pas ce que je veux...

Code :

public class Node
{
public int A, B;
private Node[] linkedNodes = new Node[10];
public Node(int a, int b)
{
this.A = a;
this.B = b;
}
public void LinkToNode(ref Node node)
{
LinkToNode(ref node, true);
}
protected void LinkToNode(ref Node node, bool canCallback)
{
if (node == this)
{
System.Exception exp = new System.Exception("Can't link a node to itself!" );
}
for (int i = 0; i < linkedNodes.Length; i++)
{
if (linkedNodes[i] == node)
{
return;
}
}
linkedNodes[0] = node;
if (canCallback)
{
Node refNode = this;
node.LinkToNode(ref refNode, false);
}
}
public override string ToString()
{
string ret = "";
for (int i = 0; i < linkedNodes.Length; i++)
if (linkedNodes[i] != null)
ret += linkedNodes[i].A + ", ";
return ret;
}
}

Si le lance :

Code :

Node a = new Node(0,0);
a.LinkToNode(ref a);
MessageBox.Show(a.ToString());

Ben ça affiche "0, " donc il n'a pas levé l'exception là où il aurait dû

Arjuna

Aircraft Ident.: F-MBSD

quel con, si, ça marche, c'est juste que je suis un gros blaireau

faut faire un throw de l'exception

chagarou

Pourquoi ne pas utiliser un ArrayList? :??:
La classe est prevue justement pour ce genre de chose.

Arjuna

Aircraft Ident.: F-MBSD

Bon, il ne me reste plus qu'à trouver comment faire un Array redimensionnable pour éviter de raiser l'exception exp3...

Code :

public class Node
{
public int A, B;
private Node[] linkedNodes = new Node[10];
public Node(int a, int b)
{
this.A = a;
this.B = b;
}
public void LinkToNode(ref Node node)
{
LinkToNode(ref node, true);
}
protected void LinkToNode(ref Node node, bool canCallback)
{
System.Exception exp = new System.Exception("Can't link a node to itself!" );
System.Exception exp2 = new System.Exception("Already linked!" );
System.Exception exp3 = new System.Exception("Linking array is full!" );
if (node == this)
{
throw exp;
}
for (int i = 0; i < linkedNodes.Length; i++)
{
if (linkedNodes[i] == node)
{
throw exp2;
}
}
for (int i = 0; i < linkedNodes.Length; i++)
{
if (linkedNodes[i] == null)
{
linkedNodes[0] = node;
if (canCallback)
{
Node refNode = this;
node.LinkToNode(ref refNode, false);
}
return;
}
}
throw exp3;
}
public override string ToString()
{
string ret = "(" + this.A.ToString() + ", " + this.B.ToString() + " ) is lined to :\n";
for (int i = 0; i < linkedNodes.Length; i++)
if (linkedNodes[i] != null)
ret += " (" + linkedNodes[i].A.ToString() + ", " + linkedNodes[i].B.ToString() + " )\n";
return ret;
}
}

chagarou

Arjuna a écrit :

Bon, il ne me reste plus qu'à trouver comment faire un Array redimensionnable pour éviter de raiser l'exception exp3...

T'aime pas les ArrayList ou l'équivalent en generics?
Dans system collection il a pas mal de structure de données toutes prêtes, pourquoi s'en passé [:core 666]
La tu va refaire la gestion d'un tableau de taille dynamique alors que le framework a deja ce qu'il te faut [:figti]

Message édité par chagarou le 26-08-2005 à 23:59:35

Arjuna

Aircraft Ident.: F-MBSD

ben c'est parceque je sais pas ce que c'est

je regarde ça
merci !

Arjuna

Aircraft Ident.: F-MBSD

Yes !

Merci, ça marche super bien :bounce:

Sinon, ma gestion d'erreurs, elle est pas trop pourrie ?

Code :

using System;
using System.Collections;
using System.Windows.Forms;
namespace MagicTrain.gameClass
{
public class Exceptions
{
#region CustomException
public class ExceptionRecursiveLink : System.ArgumentException
{
public ExceptionRecursiveLink(string message) : base (message) {}
}
public class ExceptionAlreadyLinked : System.ArgumentException
{
public ExceptionAlreadyLinked(string message) : base (message) {}
}
public class ExceptionLinkArrayFull : System.ArgumentException
{
public ExceptionLinkArrayFull(string message) : base (message) {}
}
#endregion
}
public class Node
{
public int A, B;
private ArrayList linkedNodes = new ArrayList();
// private Node[] linkedNodes = new Node[10];
public Node(int a, int b)
{
this.A = a;
this.B = b;
}
public void LinkToNode(ref Node node)
{
LinkToNode(ref node, true);
}
protected void LinkToNode(ref Node node, bool canCallback)
{
if (node == this)
{
throw new Exceptions.ExceptionRecursiveLink("A node can't be linked to itself!" );
}
for (int i = 0; i < linkedNodes.Count; i++)
{
if (((Node) linkedNodes[i]) == node)
{
throw new Exceptions.ExceptionAlreadyLinked("This link already exists!" );
}
}
try
{
linkedNodes.Add(node);
if (canCallback)
{
Node refNode = this;
node.LinkToNode(ref refNode, false);
}
}
catch (Exception e)
{
throw new Exceptions.ExceptionLinkArrayFull("Linking array is full!" );
}
}
public override string ToString()
{
string ret = "(" + this.A.ToString() + ", " + this.B.ToString() + " ) is lined to :\n";
for (int i = 0; i < linkedNodes.Count; i++)
if (((Node) linkedNodes[i]) != null)
ret += " (" + ((Node) linkedNodes[i]).A.ToString() + ", " + ((Node) linkedNodes[i]).B.ToString() + " )\n";
return ret;
}
}
}

Code :

static void Main()
{
MagicTrain.gameClass.Node a = new MagicTrain.gameClass.Node(0,0);
MagicTrain.gameClass.Node b = new MagicTrain.gameClass.Node(0,1);
MagicTrain.gameClass.Node c = new MagicTrain.gameClass.Node(1,0);
MagicTrain.gameClass.Node d = new MagicTrain.gameClass.Node(1,1);
MagicTrain.gameClass.Node e = new MagicTrain.gameClass.Node(2,0);
MagicTrain.gameClass.Node f = new MagicTrain.gameClass.Node(2,1);
MagicTrain.gameClass.Node g = new MagicTrain.gameClass.Node(3,0);
MagicTrain.gameClass.Node h = new MagicTrain.gameClass.Node(3,1);
MagicTrain.gameClass.Node i = new MagicTrain.gameClass.Node(4,0);
MagicTrain.gameClass.Node j = new MagicTrain.gameClass.Node(4,1);
MagicTrain.gameClass.Node k = new MagicTrain.gameClass.Node(5,0);
MagicTrain.gameClass.Node l = new MagicTrain.gameClass.Node(5,1);
try
{
a.LinkToNode(ref a);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
a.LinkToNode(ref b);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
a.LinkToNode(ref c);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
a.LinkToNode(ref d);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
a.LinkToNode(ref e);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
b.LinkToNode(ref f);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
b.LinkToNode(ref g);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
b.LinkToNode(ref h);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
b.LinkToNode(ref i);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
b.LinkToNode(ref j);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
b.LinkToNode(ref k);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
b.LinkToNode(ref l);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
try
{
b.LinkToNode(ref a);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
MessageBox.Show(a.ToString());
MessageBox.Show(b.ToString());
MessageBox.Show(c.ToString());
MessageBox.Show(d.ToString());
MessageBox.Show(e.ToString());
MessageBox.Show(f.ToString());
MessageBox.Show(g.ToString());
MessageBox.Show(h.ToString());
MessageBox.Show(i.ToString());
MessageBox.Show(j.ToString());
MessageBox.Show(k.ToString());
MessageBox.Show(l.ToString());
}

Taz

bisounours-codeur

# Node a = new Node(0,0);
# a.LinkToNode(ref a);

c'est le truc le plus stupide que j'ai jamais vu ...

chagarou

Arjuna a écrit :

Deplus, plutôt que me trimballer des "ref" un peu partout, j'aurais préféré utiliser des pointeurs. C'est quoi la différence d'ailleurs entre un "ref" et un pointeur ? Un "ref", ça correspond bien à un "*variable" ou si ça n'a rien à voir ? (si c'est le cas, alors ça devrait aller)

Bon j'ai un peu de temps pour repondre a cette question, il existe deux types de type( [:ddr555] ) en csharp les types passés par référence, et ceux passés par valeur.
Les classes sont des types passés par référence, tu n'as donc pas besoin de te trainer des ref partout dans ton code.

Des petit bout de l'aide de csharp a ce sujet(comme toujours je te conseille fortement d'aller y mettre le nez dedans :whistle: ):

Citation :

class

A reference type that encapsulates data (constants and fields) and behavior (methods, properties, indexers, events, operators, instance constructors, static constructors, and destructors), and can contain nested types. Class types support inheritance, a mechanism whereby a derived class can extend and specialize a base class. See also: encapsulation, indexer, property, reference type.

reference type

A data type that is represented by a reference (similar to a pointer) to the type's actual value. If a reference type is assigned to a variable, that variable references (or "points to" ) the original value. No copy is made. Reference types comprise classes, interfaces, delegates, and boxed value types. See also: value type.

value type

A data type that is represented by the type's actual value. If a value type is assigned to a variable, that variable is given a fresh copy of the value. (This is in contrast to a reference type, where assignment does not create a copy.) Value types are usually created on a method's stack frame, rather than in the garbage-collected heap. A value type can be boxed, which is a process that creates a corresponding reference type. See also: boxing, reference type, unboxing.

Message édité par chagarou le 27-08-2005 à 19:06:00

Publicité

oliv5

Pourquoi ? Parce que !

Taz a écrit :

# Node a = new Node(0,0);
# a.LinkToNode(ref a);

c'est le truc le plus stupide que j'ai jamais vu ...

Ouais, Arjuna, c'est pas glop ta 2eme ligne (pkoi lier un node à lui meme ? tu risque de faire des boucle infinies en parcourant ton arbre. Pi, inutile de passer une ref).

chagarou

oliv5 a écrit :

Ouais, Arjuna, c'est pas glop ta 2eme ligne (pkoi lier un node à lui meme ? tu risque de faire des boucle infinies en parcourant ton arbre. Pi, inutile de passer une ref).

Peut être pour tester ce si ce code marche bien?

Code :

if (node == this)
{
throw new Exceptions.ExceptionRecursiveLink("A node can't be linked to itself!" );
}

masklinn

í dag viðrar vel til loftárása

chagarou a écrit :

Peut être pour tester ce si ce code marche bien?

Code :

if (node == this)
{
throw new Exceptions.ExceptionRecursiveLink("A node can't be linked to itself!" );
}

C'est à ça que servent les tests unitaires normalement [:pingouino]

---------------
I mean, true, a cancer will probably destroy its host organism. But what about the cells whose mutations allow them to think outside the box by throwing away the limits imposed by overbearing genetic regulations? Isn't that a good thing?

Arjuna

Aircraft Ident.: F-MBSD

Taz a écrit :

# Node a = new Node(0,0);
# a.LinkToNode(ref a);

c'est le truc le plus stupide que j'ai jamais vu ...

C'est pas stupide, c'est un test.
Quand j'aurai mon prog terminé, je ne suis pas à l'abrit d'une tentative d'une telle référence.

Je veux coder un jeu où une personne va construire une voie ferrée. Je ne suis pas à l'abri qu'un blaireau tente de créer un point dans sa ligne, puis tenter de faire un rail qui tourne sur lui-même pour revenir à ce point, sans passer par un autre point. :spamafote:

Arjuna

Aircraft Ident.: F-MBSD

Sinon, pour le coup du ref et pas ref, y'a un truc qui me choque quand même.

Bon, déjà, je viens du VB, et en VB, une class aussi est passée par référence. Mais si on stipule explicitement ByVal ou ByRef, alors le comportement est différent, même si le ByVal reste de la référence.

Explication :

ByRef sur une class, ca veut dire que si je modifie les attributs de mon objets via le lien (ou pointeur) passé ByRef, alors ça modifie l'objet.
Si je tue l'objet (= Nothing) alors je détruis l'objet.

ByVal, ça marche pareil, sauf que si j'affecte à Nothing, je ne fait que détruire le pointeur, l'objet original reste actif. Y'a une autre différence, mais je ne sais plus laquelle (en tout cas, y'a pas de recopie, dans aucun des deux cas).

Vu qu'en C#, à partir du moment où on tente de passer un objet sans mettre ref alors qu'il est déclaré ref dans la méthode, il plante à la compilation. J'en déduis que lui aussi doit avoir un mécanisme qui diffère si on passe ByRef ou non.

Ceci dit, en écrivant ces lignes, je m'apperçois que c'est plutôt le comportement VB "ByVal" que je veux : je dois pouvoir déduire un lien entre deux nodes sans détruire la node liée... Donc mes ref semble erronés. En tout cas, je suis presque certain que le comportement diffère, ou alors y'a un souci dans le compilo.

Message édité par Arjuna le 29-08-2005 à 00:21:19

Arjuna

Aircraft Ident.: F-MBSD

masklinn a écrit :

C'est à ça que servent les tests unitaires normalement [:pingouino]

Bah oui, je voulais juste vérifier que l'exception se levait bien en cas d'erreur.

Arjuna

Aircraft Ident.: F-MBSD

Ah, oui, la différence entre ByVal et ByRef sur un objet en VB, c'est qu'on peut réaffecter un pointeur passé ByVal, mais pas un pointeur passé ByRef
Si je réaffecte un nouvel objet à une variable ByRef, alors je tue l'objet initial, et je le recrée avec sa nouvelle déclaration (scope global).
Si je réaffecte un nouvell objet à une variable ByVal, le lien se brise, l'objet original reste, et je crée un nouvel objet de scope local.

En y repensant, je suis sûr que ça fait pareil en C#, j'essaierai demain :

public class toto
{
public string val;
public toto(string val)
{
this.val = val
}

public string testequitue(ref toto link, string newVal)
{
link = new toto(newVal);
return link.val;
}
}

toto v1 = new toto("v1" );
Console.Write(toto.testquitue(ref toto, "v2" ));
Console.Write(toto.val);

=> Normalement, il affiche "v2v2"

Si je vire les "ref", alors normalement, à la sortie, "v2v1" devrait s'afficher.

par contre, dans les deux cas, qui le "testquitue" fait avant le new

link.val = newVal;

=> à la sortie, l'objet toto sera dans les deux cas modifié

Message édité par Arjuna le 29-08-2005 à 00:31:50

masklinn

í dag viðrar vel til loftárása

Arjuna a écrit :

Bah oui, je voulais juste vérifier que l'exception se levait bien en cas d'erreur.

Et c'est le rôle des tests unitaires bordel [:pingouino]

0x90

→

( jme fais tapper si je dis que c'est quand même vachement plus simple la notation pointeurs/* ? )

---------------
Me: Django Localization, Yogo Puzzle, Chrome Grapher, C++ Signals, Brainf*ck.

Arjuna

Aircraft Ident.: F-MBSD

masklinn a écrit :

Et c'est le rôle des tests unitaires bordel [:pingouino]

Et c'est quoi ça justement ?.

Arjuna

Aircraft Ident.: F-MBSD

0x90 a écrit :

( jme fais tapper si je dis que c'est quand même vachement plus simple la notation pointeurs/* ? )

Justement, ça marche pas, et si je ne m'abuse, c'est ma question initiale...

(mais comme d'hab, les gens préfèrent critiquer la façon de coder plutôt que répondre à la question... c'est pas toujours inintéressant, mais ça sert pas toujours à grand chose si on n'a pas de réponse à sa question initiale...)

masklinn

í dag viðrar vel til loftárása

Arjuna a écrit :

Et c'est quoi ça justement ?.

Grosso merdo, ce sont les tests de validité d'une fonction, d'une classe, d'un objet, ...

Le principe, c'est qu'avant de créer un élément tu connais ses entrées/sorties et les réactions que sont censées avoir ses méthodes aux différents évènements (que ce soient des réussites, des algos ou des erreurs/exceptions).

Donc tu crées des ensembles de tests pour vérifier si l'objet réagit bien comme il le doit (lance des erreurs quand il devrait planter et sort ce qu'il devrait sortir).

T'es censé faire ça pour tous tes objets, et pour tous les cas d'utilisation (tu peux en oublier, naturellement, et quand tu t'en rends compte tu crées de nouveaux tests pour vérifier ce que tu avais oublié).

Ca permet d'être sûr que tes objets se comportement correctement quelles que soient les modifications que tu y apportes.

Dans les méthodologies agiles, et XP en particulier, les tests unitaires doivent même être écrits avant les objets testés (ou en parallèle): ils sont à la vois le carcan, le guide et la documentation de l'objet.

http://www.sdmagazine.com/columnists/martin/
pour une introduction romancée à la chose
http://butunclebob.com/ArticleS.UncleBob
pour un peu plus d'infos

Arjuna

Aircraft Ident.: F-MBSD

Je te demande pas ce qu'est un test unitaire, j'en fais suffisament comme ça pour savoir exactement ce que c'est

Quand j'ai une fonction qui ne contiens rien que des trucs censés faires planter ma class, ou exploiter ce qu'elle fait, le tout codé à la fois en dur et avec des noms de variables bidons, je te demande justement à quoi ça te fait penser

Arjuna

Aircraft Ident.: F-MBSD

Arjuna a écrit :

Si le lance :

Code :

Node a = new Node(0,0);
a.LinkToNode(ref a);
MessageBox.Show(a.ToString());

Ben ça affiche "0, " donc il n'a pas levé l'exception là où il aurait dû

=> C'est pourtant suffisament explicite ! Je cherchais bien a faire planter ma classe et vérifiant que l'exception à propos des liens en boucles...

Arjuna

Aircraft Ident.: F-MBSD

Au fait, dans un catch, je me rends compte que l'exception levée n'est pas bloquante, je peux faire un résume du code dans le try ou pas ?

Comme le "continue" après un break si mes souvenirs sont bons.

En VB, c'est "Resume Next"

Parceque faire des try {} catch {} à chaque instruction, c'est un peu lourd...

Message édité par Arjuna le 29-08-2005 à 12:31:09

masklinn

í dag viðrar vel til loftárása

Arjuna a écrit :

Je te demande pas ce qu'est un test unitaire, j'en fais suffisament comme ça pour savoir exactement ce que c'est

T'as qu'à être clair dans tes réponses, et aprendre à faire des quotes et des multiquotes

Citation :

Quand j'ai une fonction qui ne contiens rien que des trucs censés faires planter ma class, ou exploiter ce qu'elle fait, le tout codé à la fois en dur et avec des noms de variables bidons, je te demande justement à quoi ça te fait penser

À une émulation d'un vrai framework de tests unitaire qui fonctionne [:gratgrat]

Arjuna

Aircraft Ident.: F-MBSD

1) C'est pas à moi de répéter 25 fois ce que je viens de dire. Depuis mes deux premiers posts, je pense avoir été suffisament explicite quant à mes tests. Ca se voit à 20 kilomètres que je fais des tests sur ma class.

2) Généralement, moi c'est comme ça que je bosse : je cherche pas à faire la class d'un coup, j'avance points par point et je rempli une fonction de tests au fur et à mesure que j'ajoute des cas. Donc il est impossible que mon truc ait une tête de framework avant même qu'il soit écrit. Je rappelle aussi que je débute en C#, mais aussi niveau algo : le cheminement dans un graph, j'ai vu ça en maths à l'IUT, et j'ai non seulement jamais mis en pratique, mais en plus j'ai tout oublié. Par conséquent, j'aurai du mal à faire un code nickel chrome comme ça...

Là, ma class node est très loin d'être terminée, d'autant plus qu'afin d'optimiser le finding path computing, je veux que chaque node indique en interne quelles nodes suivre pour aller vers une node précise, ainsi que la distance. Rien que pour ça, j'ai réfléchis des heures dessus, et je n'ai aucune idée de comment faire... L'initialisation, c'est chaud, mais surtout, quand je supprime une node, ou que j'en ajoute une au milieu d'un lien existant, il faut impacter ces valeurs sans recalculer tout l'arbre.

En effet, ce que je veux modéliser dans ce graph, c'est un réseau ferroviaire. Vu qu'il y aura virtuellement des centaines de train, et certainement plusieur dizaines de milliers de nodes, je dois impérativement optimiser au maximum la recherche du plus court chemin disponible pour me rendre d'une gare à une autre : c'est à dire que je ne dois pas me contenter de suivre le plus court chemin, si un train plus lent est déjà engagé sur la voie, ou vient en sens inverse, je dois tenter de trouver une alternative... Rechercher le chemin dans un tel graph à chaque passage à une node (parceque les trains ça bouge, donc le meilleur chemin peut évoluer dans le temps), c'est la mort, ça n'avancera pas.
Mais si au contraire je fais une usine à gaz lors de la création de chaque node, c'est le contraire, le joueur ne pourra pas modéliser ses voies dans de bonnes conditions.

Bref, la tannée

Sans compter que si une node A est liée à une node B, et que cette dernière est liée à une node C, le chemin pour aller de A à C n'existe pas forcément, à cause du sens d'embranchement des voies. Encore un truc que je dois résoudre, et là c'est pas gagné

Message édité par Arjuna le 29-08-2005 à 14:27:29

masklinn

í dag viðrar vel til loftárása

Arjuna a écrit :

Et pourtant, marrant, personne a l'air d'avoir compris ça [:pingouino]

Citation :

2) Généralement, moi c'est comme ça que je bosse : je cherche pas à faire la class d'un coup, j'avance points par point et je rempli une fonction de tests au fur et à mesure que j'ajoute des cas. Donc il est impossible que mon truc ait une tête de framework avant même qu'il soit écrit.

Et alors?
Je vois pas en quoi ça empêche d'utiliser les frameworks de tests unitaires existants (NUnit ou CSUnit en C#) [:pingouino]

Ni même d'écrire les tests avant d'avoir implémenté les actions dans la classe

edit: tu devrais aller voir les liens que je t'ai filés, quand même

Message édité par masklinn le 29-08-2005 à 14:35:31

Arjuna

Aircraft Ident.: F-MBSD

Ben voilà, au lieu de me parler de tests unitaire, donne l'info complète. Il s'agit donc d'une fonction de VS. C'est peut-être ça le plus intéressant dans ton post non ?

Ceci dit, franchement, je ne vois pas l'intérêt d'utiliser ces trucs, m'enfin si ça peut te faire plaisir, je peux toujours aller voir à quoi ça ressemble.

Sinon, là je suis au boulot. Je suis allé vite fait suivre tes liens et euh... Nan, pas moyen, je me coltine pas les 25 articles qu'il y a sur chaque page pour trouver lequel est intéressant... Si t'avais un lien direct vers l'utilisation de ces trucs, ça m'arrangerait un peu.

J'en chie déjà assez avec l'algo pour pas m'emmerder à passer la soirée à chaque fois que je veux me documenter sur un truc.

masklinn

í dag viðrar vel til loftárása

Arjuna a écrit :

Ben voilà, au lieu de me parler de tests unitaire, donne l'info complète. Il s'agit donc d'une fonction de VS. C'est peut-être ça le plus intéressant dans ton post non ?

C'est pas une fonction de Visual Studio [:pingouino]

Ptin, tu me dis que tu connais les tests unitaires mais tu ne sais même pas qu'existent des frameworks de test [:petrus dei]

Citation :

Ceci dit, franchement, je ne vois pas l'intérêt d'utiliser ces trucs, m'enfin si ça peut te faire plaisir, je peux toujours aller voir à quoi ça ressemble.

À automatiser et systémiser les tests unitaires et à disposer d'un ensemble de fonctions d'assertions standard [:petrus75]

Citation :

Sinon, là je suis au boulot. Je suis allé vite fait suivre tes liens et euh... Nan, pas moyen, je me coltine pas les 25 articles qu'il y a sur chaque page pour trouver lequel est intéressant... Si t'avais un lien direct vers l'utilisation de ces trucs, ça m'arrangerait un peu.

Ce ne sont pas des tutoriels, ce sont des présentations "en cas réel" sur la méthodologie XP, vu que tu ne sembles pas savoir comment ça fonctionne [:jagstang]

Citation :

J'en chie déjà assez avec l'algo pour pas m'emmerder à passer la soirée à chaque fois que je veux me documenter sur un truc.

[:petrus75]

Arjuna

Aircraft Ident.: F-MBSD

Bon, ben écoute. Désolé de te décevoir, mais je ne vois pas à quoi ça pourrait me servir ton truc si c'est juste encapsuler mes tests dans une classe spécifique.

Je suis pas en train de faire un FrameWork, je fais juste une classe qui va me servir pour mon programme. J'ai rien à redistribuer, et une fois mes tests validés, je n'ai aucune utilité de les garder dans un coin.

On a chacun notre méthode pour faire les tests unitaires, et visiblement c'est pas la même. Moi, je bosse tout seul, alors faire un truc super découpé dans tous les sens et super architecturé, ça me servira à rien mise à part me faire perdre mon temps. L'important dans un jeu de test, c'est qu'il soit réfléchit et éxécuté avec succès. Point :spamafote:

masklinn

í dag viðrar vel til loftárása

Arjuna a écrit :

Bon, ben écoute. Désolé de te décevoir, mais je ne vois pas à quoi ça pourrait me servir ton truc si c'est juste encapsuler mes tests dans une classe spécifique.

C'est justement le but, une architecture de test stable, avec des helpers pour facilement mettre en place les tests [:klem3i1]

Ce qui permet entre autre de lancer une suite de 500 ou 600 tests en une seule commande

Citation :

une fois mes tests validés, je n'ai aucune utilité de les garder dans un coin.

Bien sûr que si, tu vas construire des structures sur tes structures existantes, tu vas résoudre des bugs, tu vas modifier des classes... conserver et activer fréquement ses tests unitaires permet d'être sûr qu'on ne "casse" pas un module, et permet de savoir aisément ce qui a cassé.

De plus tout bug ou problème détecté résulte en la génération de tests unitaires (afin de vérifier, après patch, que le problème a bien été résolu) qui jouent simultanément le rôle de tests de non régression [:spamafote]

Citation :

c'est qu'il soit réfléchit et éxécuté avec succès

Et qu'il reste exécuté avec succès [:spamafote]

ixemul

Nan mais sans blague ! ⚡

Arjuna a écrit :

Le probleme fondamentale, c'est que C# n'est pas VB (..,4,5,6) et qu'il permet de faire des choses bien plus puissantes et propres, il ne faut pas raisonner de la meme maniere entre les 2 langage et prendre au moins les bases du C# (concernant les passage par reference ou par valeur... -> MSDN)

D'ailleur, si VB.Net tranche radicalement des précédentes version de VB, c'est qu'il est calqué sur le fonctionnement du C# (même s'il reste toujours possible de faire des choses tordues à la sauce VB)

Le Resume next etait une horreur du VB, à bannir autant que les GOTO... s'il y a exception, il faut la gerer et basta, ou alors c'est que le code est mal pensé...

dans toutes fonction on devrait retrouver une structure

Code :

try
{
[...]
}
catch(SpecificException exp_spec)
{
[...]
}
catch(Exception exp_generale)
{
[...]
}
finally
{
[...]
}

C'est pas plus compliqué, et ça evite bien des erreurs

Arjuna

Aircraft Ident.: F-MBSD

Le seul souci avec ton système, c'est que je veux gérer les "warning" comme des exceptions.

Par exemple, si l'utilisateur tente de faire une action interdite, je veux que dans mon code ça gère une exception, afin de traîter l'action proprement, et sans mettre des tests à toutes les sauces.

Hors, dans le cas d'un warning, moi je veux pas planter l'éxécution du code, et encore moins foutre des erreur handlers toutes les lignes, si le Resume Next utilisé à mauvais escient ("On Error Resume Next" ) il s'avère à la fois très propre et sûre quand on l'utilise correctement dans l'EventHandler.
Et je suis parfaîtement sûr qu'il existe un équivalent en C#, tout comme le "continue" dans un Break (qui pourtant est autrement plus pourri !)

Arjuna

Aircraft Ident.: F-MBSD

Bon, histoire de faire plaisir à Masklinn, j'ai fait une classe de tests, sinon il va bouder dans son coin et va plus m'aider

Sauf que là, y'a un léger souci ! Ca fait total n'importe quoi !

Il lance des bouts de code dans tous les sens n'importe comment !!!
C'est quoi ce délire ?

Voici le code de ma class "Node" et des exceptions qui vont avec :

Code :

/// <summary>
/// This class contains Exceptions that can be raised from this namespace
/// </summary>
public class Exceptions
{
#region CustomException
public class ExceptionRecursiveLink : System.ArgumentException
{
public ExceptionRecursiveLink(string message) : base (message) {}
}
public class ExceptionAlreadyLinked : System.ArgumentException
{
public ExceptionAlreadyLinked(string message) : base (message) {}
}
public class ExceptionLinkArrayFull : System.ArgumentException
{
public ExceptionLinkArrayFull(string message) : base (message) {}
}
#endregion
}
/// <summary>
/// This class represents a node that can be linked to other nodes
/// </summary>
public class Node
{
public string name;
private ArrayList linkedNodes = new ArrayList();
/// <summary>
/// Creates a node
/// </summary>
/// <param name="Name">Node's name</param>
public Node(string Name)
{
this.name = Name;
}
/// <summary>
/// Link to another node
/// </summary>
/// <exception cref="Exceptions.ExceptionRecursiveLink">
/// Raised if the link tries to link itself
/// </exception>
/// <exception cref="Exceptions.ExceptionAlreadyLinked">
/// Raised if the two nodes are already linked together
/// </exception>
/// <exception cref="Exceptions.ExceptionLinkArrayFull">
/// Raised if the linking table is full
/// </exception>
/// <remarks>
/// A node can't be linked to itself.
/// If a link already exists, a exception will be raised.
/// </remarks>
/// <param name="node">
/// Node to link with
/// </param>
public void LinkToNode(Node node)
{
LinkToNode(node, true);
}
/// <summary>
/// Same as previous declaration, but for internal use only
/// </summary>
/// <param name="node">Node to link with</param>
/// <param name="canCallback">If true, then the linked node is allowed to link itself to this node</param>
protected void LinkToNode(Node node, bool canCallback)
{
if (node == this)
{
throw new Exceptions.ExceptionRecursiveLink("A node can't be linked to itself!" );
}
for (int i = 0; i < linkedNodes.Count; i++)
{
if (((Node) linkedNodes[i]) == node)
{
throw new Exceptions.ExceptionAlreadyLinked("This link already exists!" );
}
}
try
{
if (canCallback)
{
node.LinkToNode(this, false);
}
linkedNodes.Add(node);
}
catch (StackOverflowException e)
{
throw new Exceptions.ExceptionLinkArrayFull("Linking array is full!" );
}
}
/// <summary>
/// Unlink two nodes
/// </summary>
/// <param name="node">Linked node to remove</param>
public void UnLinkNode(Node node)
{
this.UnLinkNode(node, true);
}
/// <summary>
/// Same as previous declaration, but for internal use only
/// </summary>
/// <param name="node">Linked node to remove</param>
/// <param name="canCallback">If true, the the unlinked node is allowed to unlink itself from this node</param>
protected void UnLinkNode(Node node, bool canCallback)
{
// This method can't raise error
if (canCallback)
{
node.UnLinkNode(node, false);
}
linkedNodes.Remove((object) node);
}
/// <summary>
/// Displays this node in string format
/// </summary>
/// <returns>User-friendly representation of the node</returns>
public override string ToString()
{
string ret = this.name + " is lined to :\n";
for (int i = 0; i < linkedNodes.Count; i++)
if (((Node) linkedNodes[i]) != null)
ret += " " + ((Node) linkedNodes[i]).name + "\n";
return ret;
}
}

La class de test (et va pas dire que c'est pas ce qu'il faut faire sinon je t'étripe et je te noie dans ton sang )

Code :

/// <summary>
/// Test class contains unit tests to help validating the program components work.
/// </summary>
public class test
{
/// <summary>
/// Global test method : use it to test all the components.
/// </summary>
public test()
{
}
/// <summary>
/// Launchs all tests and returns true is all tests are OK
/// </summary>
/// <returns>
/// True : Everyting is OK
/// False : A test was not validated
/// </returns>
public bool runTests()
{
bool everythingIsOk = true;
Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
Debug.AutoFlush = true;
Debug.WriteLine("Launch global test battery" );
worldTest wTest = new worldTest();
everythingIsOk &= wTest.testRecursiveLink();
everythingIsOk &= wTest.testAlredayLinked();
everythingIsOk &= wTest.testLinkArrayFull();
wTest.terminate();
Debug.WriteLine("Finish global test battery" );
wTest = null;
Debug.Close();
return everythingIsOk;
}
}
public class worldTest
{
Node[] arrNodes = new Node[5];
/// <summary>
/// Create the worldTest environment
/// </summary>
public worldTest()
{
Debug.Indent();
Debug.WriteLine("Create worldTest environment" );
Debug.WriteLine("Create " + arrNodes.Length.ToString() + " nodes" );
for (int i = 0; i < arrNodes.Length; i++)
{
arrNodes[i] = new Node("Automatic node generated numuber " + i.ToString());
}
Debug.WriteLine("worldText environment created successfully" );
}
/// <summary>
/// Write in debug console test is over
/// </summary>
public void terminate()
{
for (int i = 0; i < arrNodes.Length; i++)
{
arrNodes[i] = null;
}
Debug.WriteLine("Destroying worldTest environment" );
Debug.Unindent();
}
/// <summary>
/// Check if RecursiveLink exception can be raised
/// </summary>
/// <returns>
/// True : exception correclty raised
/// False : exception was not raised
/// </returns>
public bool testRecursiveLink()
{
bool exceptionRaised = false;
Debug.Indent();
Debug.WriteLine("Launch testRecursiveLink test" );
Debug.Indent();
try
{
arrNodes[0].LinkToNode(arrNodes[0]);
Debug.WriteLine("(E) ExceptionRecursiveLink exception was not raised !" );
arrNodes[0].UnLinkNode(arrNodes[0]);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionRecursiveLink e)
{
exceptionRaised = true;
Debug.WriteLine("(I) ExceptionRecursiveLink exception correctly raised" );
}
catch (Exception e)
{
Debug.WriteLine("(E) Unexpected exception was raised !" );
Debug.WriteLine("==> " + e.ToString() + " : " + e.Message);
}
Debug.Unindent();
Debug.WriteLine("Finish testRecursiveLink test" );
Debug.Unindent();
return exceptionRaised;
}
/// <summary>
/// Check if AlredayLinked exception can be raised
/// </summary>
/// <returns>
/// True : exception correclty raised
/// False : exception was not raised
/// </returns>
public bool testAlredayLinked()
{
bool exceptionRaised = false;
Debug.Indent();
Debug.WriteLine("Launch testAlredayLinked test" );
Debug.Indent();
try
{
arrNodes[0].LinkToNode(arrNodes[1]);
arrNodes[0].LinkToNode(arrNodes[1]);
Debug.WriteLine("(E) ExceptionAlreadyLinked exception was not raised !" );
arrNodes[0].UnLinkNode(arrNodes[1]);
}
catch (MagicTrain.gameClass.Exceptions.ExceptionAlreadyLinked e)
{
exceptionRaised = true;
arrNodes[0].UnLinkNode(arrNodes[1]);
Debug.WriteLine("(I) ExceptionAlreadyLinked exception correctly raised" );
}
catch (Exception e)
{
Debug.WriteLine("(E) Unexpected exception was raised !" );
Debug.WriteLine("==> " + e.ToString() + " : " + e.Message);
}
Debug.Unindent();
Debug.WriteLine("Finish testAlredayLinked test" );
Debug.Unindent();
return exceptionRaised;
}
/// <summary>
/// Check if LinkArrayFull exception can be raised (not mandatory test)
/// </summary>
/// <returns>Always true</returns>
public bool testLinkArrayFull()
{
bool exceptionRaised = false;
Debug.Indent();
Debug.WriteLine("Launch testLinkArrayFull test" );
Debug.Indent();
try
{
for (int i = 0; i < arrNodes.Length; i++)
{
for (int j = i + 1; j < arrNodes.Length; j++)
{
arrNodes[i].LinkToNode(arrNodes[j]);
Debug.WriteLine(i.ToString() + " <->" + j.ToString());
}
}
Debug.WriteLine("(E) ExceptionLinkArrayFull exception was not raised !" );
// This exception should never occurs, so we don't bother it is raised or not
exceptionRaised = true;
for (int i = 0; i < arrNodes.Length; i++)
{
for (int j = i + 1; j < arrNodes.Length; j++)
{
arrNodes[i].UnLinkNode(arrNodes[j]);
}
}
}
catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull e)
{
exceptionRaised = true;
for (int i = 0; i < arrNodes.Length; i++)
{
for (int j = i + 1; j < arrNodes.Length; j++)
{
arrNodes[i].UnLinkNode(arrNodes[j]);
}
}
Debug.WriteLine("(I) ExceptionLinkArrayFull exception correctly raised" );
}
catch (Exception e)
{
for (int i = 0; i < arrNodes.Length; i++)
{
for (int j = i + 1; j < arrNodes.Length; j++)
{
arrNodes[i].UnLinkNode(arrNodes[j]);
}
}
Debug.WriteLine("(E) Unexpected exception was raised !" );
Debug.WriteLine("==> " + e.ToString() + " : " + e.Message);
}
Debug.Unindent();
Debug.WriteLine("Finish testLinkArrayFull test" );
Debug.Unindent();
return exceptionRaised;
}
}

Et enfin, le lancement des tests dans le Main de mon projet :

Code :

/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main()
{
MagicTrain.testClass.test unitTests = new MagicTrain.testClass.test();
if (unitTests.runTests())
{
MessageBox.Show("All classes tested successfully !" );
}
else
{
MessageBox.Show("One or more tests were not working correctly !" );
}
}

Sortie DEBUG :

Code :

'DefaultDomain': Loaded 'g:\windows\microsoft.net\framework\v1.1.4322\mscorlib.dll', No symbols loaded.
'MagicTrain': Loaded 'G:\Documents and Settings\MagicBuzz\Mes documents\Visual Studio Projects\MagicTrain\MagicTrain\bin\Debug\MagicTrain.exe', Symbols loaded.
'MagicTrain.exe': Loaded 'g:\windows\assembly\gac\system.windows.forms\1.0.5000.0__b77a5c561934e089\system.windows.forms.dll', No symbols loaded.
'MagicTrain.exe': Loaded 'g:\windows\assembly\gac\system\1.0.5000.0__b77a5c561934e089\system.dll', No symbols loaded.
'MagicTrain.exe': Loaded 'g:\windows\assembly\gac\system.xml\1.0.5000.0__b77a5c561934e089\system.xml.dll', No symbols loaded.
Launch global test battery
Create worldTest environment
Create 5 nodes
worldText environment created successfully
Launch testRecursiveLink test
Launch global test battery
Create worldTest environment
Create 5 nodes
worldText environment created successfully
Launch testRecursiveLink test
(I) ExceptionRecursiveLink exception correctly raised
Finish testRecursiveLink test
Launch testAlredayLinked test
(I) ExceptionRecursiveLink exception correctly raised
Finish testRecursiveLink test
Launch testAlredayLinked test
(I) ExceptionAlreadyLinked exception correctly raised
Finish testAlredayLinked test
Launch testLinkArrayFull test
(E) Unexpected exception was raised !
(I) ExceptionAlreadyLinked exception correctly raised
Finish testAlredayLinked test
Launch testLinkArrayFull test
(E) Unexpected exception was raised !
==> ExceptionAlreadyLinked: This link already exists!
at MagicTrain.gameClass.Node.LinkToNode(Node node, Boolean canCallback) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 96
at MagicTrain.gameClass.Node.LinkToNode(Node node, Boolean canCallback) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 104
at MagicTrain.gameClass.Node.LinkToNode(Node node) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 77
at MagicTrain.testClass.worldTest.testLinkArrayFull() in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\test.cs:line 168 : This link already exists!
Finish testLinkArrayFull test
Destroying worldTest environment
Finish global test battery
==> ExceptionAlreadyLinked: This link already exists!
at MagicTrain.gameClass.Node.LinkToNode(Node node, Boolean canCallback) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 96
at MagicTrain.gameClass.Node.LinkToNode(Node node, Boolean canCallback) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 104
at MagicTrain.gameClass.Node.LinkToNode(Node node) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 77
at MagicTrain.testClass.worldTest.testLinkArrayFull() in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\test.cs:line 168 : This link already exists!
Finish testLinkArrayFull test
Destroying worldTest environment
Finish global test battery
The program '[2388] MagicTrain.exe' has exited with code 0 (0x0).

C'est quoi ce délire ? Dès le début, pourquoi il passe deux fois dans mon contructeur ?
Puis fait tous les tests en double !
Et ensuite, pourquoi est-ce que pendant le "testAlreadyLinked" il écrit un débug normalement écrit dans la "testRecursiveLink" ?

Du coup, ça déconne à plein tube et à la fin il raise une erreur qui ne devrait pas se déclencher, parceque je m'escrime à faire du nettoyage dans à la fin de mes tests et normalement les nodes devraient toujours être dans un état vide à la fin de chaque test...

Message édité par Arjuna le 29-08-2005 à 20:53:54

Arjuna

Aircraft Ident.: F-MBSD

Ca y est, je les ai tous fait fuir :sweat:

Arjuna

Aircraft Ident.: F-MBSD

Problème ci-dessus résolu.

Nouvelle question à propos des Array : Est-ce qu'on peut passer outre la limitation de 2^15 - 1 lignes pour un tableau "simple" ? Ou si je dois passer par un objet ArrayList ?

Pourtant, y'a une propriété .LongLength, j'en déduit que l'index peut être un long :??:

Publicité

FORUM HardWare.fr

Programmation

C#/.NET managed

C# et Array non dimensionné ?

Sujets relatifs
[Java] [JMF] lire une vidéo sous forme de byte array?	Problème de tableau array
array associatif avec valeurs dynamiques. ça passe pas.	array array array :) [Resolu]
question sur les array()	requete avec array et mysql
requete SQL -> Array : perfectionnement du code !!	Insérer un array dans une Bdd via python
Récupérer l'index d'un item d'un array constant	include dans un array [resolu]
Plus de sujets relatifs à : C# et Array non dimensionné ?

Page générée en 0.203 secondes