Gestion des erreurs C#

[didier]

Coucou

 

ma question est le message #3

merci

[(gile)]

try
{
   mise en page
}
catch(pourrie)
{
   je reviens bientôt
}
finally
{
   je poste
]

[didier]

Coucou

 

j'arrête avec la présentation de mes messages, le site n'est pas à la hauteur de mon art (hihi, j'espère que Cadmin a de l'humour)

 

Toujours en C#, ma question porte sur la conversion d'une string en double

j'arrive à en faire une string en en retirant les caractères alpha

par exemple :

string de départ :"cet article vaut 32.88 euros"

string d'arrivée : "32.88"

jusqu'ici tout va bien

je peux aussi la transformer en double (converttodouble)

 

mais je suis vicieux et je fais exprès une erreur dans la string initiale en mettant deux points décimaux (genre faute de frappe)

et quand je convertis "32..88" en double une erreur est provoquée

 

Question :

comment prendre en compte cette erreur pour arrêter le programme

j'ai essayé le try catch, le try catch finally, le if et le switch sans trouver

 

je pense à quelque chose qui tient du "exit" ou du "quit" mais je n'en sais pas assez et ça ne fonctionne pas

des idées ?

 

Merci

[(gile)]

Salut,

 

Pour la conversion des chaînes en nombre (ou en certains autres types), il y a la méthode TryParse() qui englobe un test de validité et qui retourne un Booléen (true ou false).

 

double price;
if (double.TryParse("32.88", out price))
{
   // la conversion a réussi price vaut 32.88
}
else
{
   // la conversion a échoué price vaut 0.0(valeur par défaut)
}

 

Ce qui est à peu près équivalent à :

double price;
bool isValid = true;
try
{
   Convert.ToDouble("32.88");
}
catch
{
   isValid = false;
}
if (isvalid)
{
   // la conversion a réussi price vaut 32.88
}
else
{
   // la conversion a échoué price vaut 0.0(valeur par défaut)
}

 

 

Après, il y a l'utilisation des expressions régulières (Regex), puissant mais parfois obscur*.

Avec les expressions régulières, tu peux, dans le même temps récupérer la valeur exprimant un nombre au sein d'un chaîne en testant sa validité.

 

double price;
Match match = Regex.Match("cet article vaut 32.88 euros", @"\d+\.\d+");
if (match.Success)
{
   // la chaîne contient un nombre valide qu'on peut convertir
   price = double.Parse(match.Value);
}
else
{
   // la chaîne ne contient pas de nombre valide
}

Quelques explications:

 

Le modèle (pattern) de l'expression régulière :

@"\d+\.\d+"

signifie : 1 ou plusieurs chiffres, suivi(s) d'un un point, suivi de 1 plusieurs chiffres.

 

Regex.Match() cherche une correspondance avec le modèle dans la chaîne et retourne une instance de Match.

L'instance de Match retournée aura sa propriété Success à true si une correspondance est trouvée, à false sinon.

Si la propriété Success vaut true, La propriété Value aura comme valeur la chaîne correspondant au modèle.

 

 

* Certaines personnes, quand elles sont confrontées à un problème pensent : "Je sais, je vais utiliser les expressions régulières."

Maintenant, elles ont deux problèmes.

[Olivier Eckmann]

Bonjour,

 

double dValeur = -1;
if (!double.TryParse("mon texte", out dValue))
{
 MessageBox.Show("Ca c'est mal passé, il faut faire quelque chose");
 // Faire le nécessaire

}

// Ca s'est bien passé, on peut continuer avec la valeur dValue

 

Edit : grillé

 

Olivier

[(gile)]

je pense à quelque chose qui tient du "exit" ou du "quit" mais je n'en sais pas assez et ça ne fonctionne pas

des idées ?

 

Avec C#, on peut faire plus propre que les (exit) ou (quit) du LISP qui provoquent une erreur LISP.

 

le mot clé return permet de sortir d'une méthode.

Si la méthode n'a pas de valeur de retour (void), on appelle return tout simplement.

Si la méthode a une valeur de retour de type référence, on peut retourner null.

Si la méthode a une valeur de retour de type valeur (non nullable), on peut retourner une valeur remarquable, mais c'est plus ambigu.

 

PS: on peut aussi utiliser break pour sortir prématurément d'une boucle (for, foreach, while)

[(gile)]

Une petite application console pour illustrer ça.

 

        static void Main()
       {
           double val, res = 0.0;
           string str;
           var lst = new List<string>();

           while (true)
           {
               Console.WriteLine("Entrez un nombre ou '=':");
               str = Console.ReadLine();
               if (str == "=")
               {
                   break; // <- on sort de la boucle
               }
               if (!double.TryParse(str, out val))
               {
                   Console.WriteLine("Nombre non valide.");
                   return; // <- on quitte la méthode
               }
               lst.Add(str);
               res += val;
           }
           Console.WriteLine("{0} = {1}", string.Join(" + ", lst), res);
       }

[didier]

Coucou

 

Merci Gilles et Olivier, je vous remercie de vos efforts.

 

Je continue à avoir des erreurs, je pense que je manque encore beaucoup de "théorie"

En fait je ne sais pas encore comment "envoyer" ou du moins rendre lisible une variable (et sa valeur) d'une class dans une autre et c'est là que le bât blesse j'en suis certain.

public, static, static string, private je me mélange

La "partie théorie" que j'ai trouvé sur le net fait quasiment toujours appel à des prérequis dont je ne dispose pas.

 

Je continue, je m'obstine, et en dernier recours je reviens vers vous.

 

Merci

[(gile)]

Salut,

 

Je ne vais pas décrire par le menu tous les concepts de la POO (Programmation Orientée Objet), j'en serais incapable et ça demanderait un livre entier. D'autres l'ont fait, et certains plutôt bien. Je ne saurais trop recommander l'investissement dans ce genre de support papier plus pratique à consulter que des pages web, autant comme moyen de découverte que comme aide mémoire*.

 

Donc en essayant d'être à la fois clair et concis.

 

La POO repose sur le concept de classe.

Une classe décrit un type au moyen de ses fonctionnalités à travers la définition de ce qu'on appelle communément les membres de la classe

Excepté pour les classes statiques (on verra ça plus loin), on utilise les classes en créant des instances de ces classes, c'est ce qu'on appelle les "objets" : un "objet string" est une instance de la classe String.

De plus des relations d'héritage permettent de réutiliser les fonctionnalités d'un type en le "spécialisant" (le type Line est une spécialisation du type Curve dont il dérive qui est lui même une spécialisation du type Entity, etc.), mais je ne m'attarderais pas là dessus dans ce message.

 

Des modificateurs d'accès permettent de contrôler le niveau d'accessibilité d'un type ou de ses membres.

L'encapsulation, un des fondements de la POO, veut qu'une classe cache les mécanismes internes et n'expose à l'extérieur que ce qui est utile à la manipulation des instances de cette classe.

• public on peut accéder à la classe depuis le projet dans lequel elle est définie ou depuis n'importe quel autre projet
  
• internal on ne peut accéder à la classe que depuis le projet dans lequel elle est définie
  
• private on ne peut accéder à la classe que depuis la classe dans laquelle elle est définie (classe imbriquée)
  
• protected comme private, mais la classe sera accessible depuis les classes qui héritent de la classe dans laquelle elle est définie.
  

L'accès aux membres d'une classe est aussi contrôlé par les mêmes modificateurs.

Typiquement :

• les champs (variables locales à la classe) sont généralement private ou protected
  
• les propriétés servent généralement à exposer des valeurs à l'extérieur et sont donc généralement public ou internal
  
• les méthodes seules le méthodes nécessaires à la manipulation d'une instance devraient être public ou internal, les autres devraient être private ou protected
  
• les événements sont généralement public ou internal
  

Le modificateur static est utilisé avec les membres qui sont sont relatifs à la classe (ils ne dépendent pas d'une instance). On les appelle donc directement sur le nom du type.

Les méthodes et propriétés statiques ne peuvent donc utiliser que des champs statiques.

Une classe qualifiée de static n'a que des membres static.

 

La classe System.Math n'a, à ma connaissance que des membres static :

Math.PI : propriété statique

Math.Sin(double) : méthode statique

 

La classe System.String a des membres statiques :

string.Empty : propriété statique

string.IsNullOrEmpty(string) : méthode statique

et des membres d'instance :

str.Length : propriété d'instance

str.ToUpper() : méthode d'instance

 

 

* J'ai un exemplaire de "C# - Developpez avec Visual Studio 2008" de Thierry Groussard chez Eni dont les pages se décollent à force d'avoir été consulté. La description des concepts de la POO y sont plutôt bien décrits et il existe une version à jour : "C# 6 - Développez des applications Windows avec Visual Studio 2015".

J'ai aussi "C# et .NET - Versions 1 à 4" de Gérard Leblanc chez Eyrolles, plus gros (presque 900 pages), plus complet, plus détaillé, plus cher aussi, mais là, pas de mise à jour à ma connaissance.

[(gile)]

Suite autour d'un exemple.

 

Concernant le passage de données d'une classe à une autre, tu peux voir l'exemple de boite de dialogue modale dans le tutoriel sur les interfaces utilisateur.

 

Dans la classe Commands

On utilise des champs privés (doc, radius et layer).

Ce sont des champs d'instance (non static) dont la valeur est donc liée à une instance spécifique de la classe.

Si on ne "voit" nulle part où et quand sont créées les instances de cette classe c'est parce que c'est AutoCAD qui s'en charge, une seule fois par document, la première fois qu'une commande est lancée (c'est la "magie" de l'attribut CommandMethod).

Il y a donc une instance de Commands par document ce qui permet de stocker dans ces champs un pointeur vers le document en question et des valeurs par défaut utilisées par le programme.

Le fait que ces champs soient private garanti que seules les méthodes de la classe pourront modifier leur valeur.

 

La classe Commands définit aussi un constructeur, il s'agit d'une méthode un peu spéciale en ce sens qu'elle ne retourne pas de valeur mais sert généralement à initialiser la nouvelle instance en initialisant les valeurs des champs.

 

La classe définit aussi une méthode public : la commande, et deux autres méthodes qualifiée de private parce que les programmes qui utilisent des instances de cette classe (AutoCAD en l'occurence) n'a pas à avoir accès à ces méthodes.

 

Dans la méthode ModalDialogCmd() on crée une nouvelle instance de la classe ModalDialog (la boite de dialogue qu'on veut afficher) à laquelle il est nécessaire de communiquer la liste des calques (layers, variable locale de la méthode) et les valeurs par défaut pour le calque sélectionné et le rayon (layer et radius, champs privés).

Pour ce faire, on passe simplement ces valeurs comme arguments de la méthode particulière qu'est le constructeur de la classe ModalDialog.

La méthode ModalDialogCmd() a aussi besoin de récupérer les valeurs entrées dans la boite dialogue pour mettre à jour les valeurs par défaut dans les champs et les passer en arguments à la méthode DrawCircle() (j'aurais pu éviter ça, la méthode DrawCircle ayant accès à ces champs).

Pour que ces valeurs soient accessibles depuis la classe ModalDialogCmd() on les expose comme propriétés public dans la classe ModalDialog.

 

Dans la classe ModalDialogCmd()

On trouve un champ d'instance privé : radius dont la valeur est mise à chaque fois que le texte change dans la boite de dialogue.

On voit ensuite deux propriétés qualifiées public, en lecture seule depuis l'extérieur de la classe, qui exposent, respectivement la valeur du champ privé radius et le nom de calque sélectionné dans la liste déroulante.

Le constructeur par défaut de la classe a été modifié pour accepter 3 arguments : les données provenant de la méthode appelante ModalDialogCmd() de la classe Commands. Il utilise ces données pour initialiser les contrôles de la boite de dialogue.

On trouve enfin les gestionnaires d'événements de certains contrôles. Ces méthodes sont qualifiées private puisqu'il s'agit de la cuisine interne à la classe ModalDialog.

 

J'ai essayé de choisir et d'implémenter ce petit exemple de code (et les suivants) en partie pour illustrer le genre de questions que tu te poses sur : "comment "envoyer" ou du moins rendre lisible une variable (et sa valeur) d'une classe dans une autre".

J'espère que ça répond, au moins en partie, à tes interrogations.

[Olivier Eckmann]

Salut Didier,

 

en fouillant un peu je suis tombé la dessus, c'est un peu ancien, mais ça a l'air pas mal :

 

http://rmdiscala.dev...rs2/Chap2.1.htm

 

Il y a aussi un document de 540 pages en français installé avec VisualStudio 2015 dans le dossier :

C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC#\Specifications\1036\CSharp Language Specification.docx

 

Olivier

[didier]

Coucou

 

Merci Gilles, merci Olivier

 

Vous êtes tous les deux des pointes sèches de compas, en rétrécissant l'écart entre les branches on se rapproche de votre piquant mais sans jamais pouvoir annuler l'écart fût-il infime !

J'en suis encore dans les "grands rayons" ...

 

Merci des conseils et je vais sans doute "investir" dans le papier.

 

Je n'ai pas pu travailler aujourd'hui mais je ne lâche pas l'affaire, je suis sur le logiciel comme une puce sur le dos d'un chien, il peut s'ébrouer et vouloir me chasser je me régale toujours mais je ne pique pas, je suis un parasite positivement positif (hihi)

 

Amicalement

[(gile)]

Merci Olivier.

Je ne connaissais pas ce document. Il semble exister pour chaque version de Visual Studio.