Passage de Java à C#

Bonjour à tous,
Je suis développeur Java, mais la boite dans laquelle je viens d'être embauché souhaite que je développe en C#. Je souhaitais donc savoir s'il existait sur ce forum un topic résumant les principales différences entre ces deux langages à la fois très proche syntaxiquement et qui pourtant amène des différences lors du développement. Si ce n'est pas le cas, est ce que quelqu'un connaissant un minimum C# pourrait me dire quelques mots sur les subtilités qu'il apporte par rapport à Java ? Les trucs en plus, les principales différences, les pièges dans lesquels on tombe au début... ? Je demande ça car si quelqu'un prend une demi heure pour m'expliquer ça, ça peut me faire économiser de nombreuses heures à chercher sur le web.
Pour commencer, existe-t-il l'équivalent en C# de notre serializable ?

Salut,

Avant de commencer à faire un comparaison longue, il faudrait nous indiquer quelle version du framework tu va utiliser, car entre 1.1, 2, 3, 3.5 et 4 il y a eut de nombreux changements (un peu comme si tu comparais java 1.4 à java 6).

La 4 n'est pas encore déployée de ce que j'ai compris, on est encore à la 3.5.
Sinon, je vais être amené à utiliser WPF, et j'ai trouvé notamment une "nouveauté", WPF Ribbon qui permet d'inclure facilement le bandeau des "nouvelles" suites microsoft dans l'interface graphique. Je dois aussi parser du XML, et j'ai cru comprendre que LinQ pourrait m'aider, même si je ne sais pas encore ce que c'est...

Donc c'est la 3.5

bon, sur les opérations 'simples' (if, switch, affectation), tout ce qui marche en java marche en .net, ou presque (pour moi il manque juste le throw de signature de méthode qui manque). A part ça je pense que tu trouveras toujours une soution 'propre' de faire l'équivalent en .net

Pour la partie ihm, tu as du microsoft donc c'est pour faire tu microsoft. Wpf se présentes sous la forme d'un fichier xaml de présentation et d'un fichier cs de code, (l'equivalent java serai le fichier jsp et sa servlet). Je ne peux pas t'en dire plus car je ne fait que du web.


Enfin pour Link, je ne crois qu'il existe pour l'instant d'équivalent en java, cela te permet en gros d'effectuer des filtres, des jointures, des aggrégations sur listes d'objets (donc en gros toutes les opérations simples de base de données) directment sur des objets, fichiers xml, bases de données, dans ton cas cela te permettrai de faire tes filtres sur tes fichiers xml.

Pour ton serializable, je ne sais plus ce que cela fait en java, en .net il y a l'interface iserializable qui te permet de serializer/deserialiser une classe:
http://tlevesque.developpez.com/dotn...serialization/

Voila, faire une comparaison exhaustive risquerai d'ètre tres long, je te suggères donc de poser directment les questions sur ton besoin.

Bonne chance.

D'accord, merci pour ton point de vue ;)

Pour le serialize, je m'en servais particulièrement pour enregistrer directement les objets dans des fichiers, pour faire une sauvegarde des données tout simplement. Cela permet, si tu as créé un objet voiture, de pouvoir enregistrer et donc récupérer directement ton objet voiture lorsque tu vas relancer l'application, sans enregistrer toutes les valeurs des attributs séparément.

Bienvenue dans le monde merveilleux de DotNet :)

Je pense que la meilleure manière d'appréhender ton passage sur dotnet est de commencer par des tutos de ce type, ainsi tu passeras en revue les features de base de c#.

J'ai en effet commencé à le lire. Comme il est très long (457 pages quand même :P) et qu'effectivement les structures sont très proches de Java, j'ai tout de même posté ce topic, pour savoir s'il y avait des différences majeures sur certains points, ou des pièges classiques (pour l'instant, le coup des majuscules au début des méthodes :P).

Si la syntaxe ne te pose pas de problème, je pense dans ce cas qu'il faut que tu mettes les mains dans le framework pour commencer à te familiariser avec les classes qui le composent.

Je ne pourrais pas t'en dire plus sur les différences java/c#, je ne connais plus assez Java.

ce que j'aimerais savoir, c'est s'il y a des spécificités intéressantes souvent utilisées et qui n'existe pas ailleurs. J'ai entendu parlé de delegate par exemple, mais je n'ai pas bien compris ce que c'était.

Et sinon, c'est plus des questions de bonnes pratiques : comment bien gérer les namespace, à quel moment je dois en créer un autre par exemple ?

Re,

Pour les namespace, c'est la meme chose qu'en java (package je crois). Comment les gérer, rien de plus simple, ton namespace racine est défini, tu créé un dossier 'toto', et une classe 'titi' dedans, il te mettra automatiquement comme namespace : racine.'toto' (comme en java).

En termes de possibilités sympathiques qui n'existent pas forcément en java:
l'intelisense
construction d'une ihm via xaml
evenement de tes boutons liés à des méthodes
linq (qui reprend les delagate)
les propriété auto-implémentés
les méthodes d'extentions
les webservices rendus simples d'utilisations
les dataset typés
les enums si tu faisais du java 1.4
la réflexion
codedom (pour les maso)
etc


Pour en revenir à ta sérialisation, je te conseille de lire le lien que j'ai mis, pour serialiser/déserialiser un objet.

En termes de best practices différentes, je n'ai pas assez fait de java pour ètre pertinent.

Bonjour

Juste une petit mot sur mon expérience qui le contraire de la tienne ( passage du .net C# au java)

Mes plus gros problèmes ont été que le java n'a pas de type unsigned qui est critique pour le byte, donc dans le sens java -> c# pas de problème.

Ne pas avoir de delegate en java (pointer sur une fonction) qui peut se remplacer en java avec des classes interfaces et implémenter la fonction que l'on veut pointer.

la boucle switch java qui n'accepte pas les string donc obliger de faire des énumération pour s'en sortir.

A mon sens le passage Java -> C# me semble plus aisé.

Cordialement

Citation:

---

Envoyé par Flaburgan

ce que j'aimerais savoir, c'est s'il y a des spécificités intéressantes souvent utilisées et qui n'existe pas ailleurs. J'ai entendu parlé de delegate par exemple, mais je n'ai pas bien compris ce que c'était.

---

Pour faire simple, les delegate sont la version POO des pointeurs de fonctions du C. Je crois qu'il n'y a pas d'équivalent Java(du moins à ma connaissance, mais comme je ne fais plus de Java depuis .... de longues années, c'est à prendre avec des pincettes).

Citation:

---

Et sinon, c'est plus des questions de bonnes pratiques : comment bien gérer les namespace, à quel moment je dois en créer un autre par exemple ?

---

Il y a de ce coté une différence très importante entre les Namespace de C# et les package de Java : le C# n'impose aucun couplage entre les noms des fichiers de classe et les noms de classes , les noms des namespaces et l'organisation des répertoires; bref, il y a un découplage complet entre l'organisation logique de ton espace de noms et son organisaton physique En effet, même si l'IDE (Visual Studio) te propose par défaut un couplage entre organisation logique et organisation physique assez proche de celui de Java (nom de classe = nom du fichier de la classe), ce n'est en aucun cas une obligation ni du langage ni de l'environnement d'exécution.

• Tes Getter/Setter deviennent des propriétés, ça peut perturber un peu mais ça allège vite le code
• Les règles de présentation (majuscule/minuscule) varient un peu mais on s'y fait assez vite.
• Penche toi sur Linq, comme dit précédemment c'est un ensemble de fonctions de traitement de collections vraiment puissantes
• Pour le wpf, c'es-t vraiment un level au dessus, vois déjà pour une bonne connaissance des éléments de base du framework
• La gestion des threads est complètement différente en .Net. Pas d'interface à implémenter. Tu crées ton thread, tu pointes la méthode à exécuter et hop. Pour un traitement répétitif selon une fréquence X, regarde les timers.
• Prends le temps de découvrir le système de base

Ca fait déjà un petite base

Et y a-t-il un équivalent à la javadoc ? Des commentaires pour une documentation qui doivent suivre un coding style ? Doxygen peut être ?

Bonjour

Tu peux mettre en commande de compilation une demande de commentaire obligatoire pour chaque fonction et variable public.

pour mettre le commentaire avant la definition de la function ou variable tu ajout e /// et le prototype de commentaire xml apparait

par exemple

Code:

---

1 2 3 4 5 6 7

/// <summary> /// Method to control switch board through RS485 /// </summary> /// <param name="bSet">Set or clear relay</param> /// <param name="RelaisNumber">relais number to control (1 to 8) ; 9 for all</param> /// <param name="ResetAllBeforSet">if true clear all Relay befor set one.</param> public void SendSwitchCommand(bool bSet, byte RelaisNumber, bool ResetAllBeforSet)

---

il ne te reste plus qu'a entrer tes infos perso.
Ces infos seront dans l'EDI visual studio avec l'intellisence quand tu appel la fonction par contre il n y a pas de génération de fichier doc directement.
Des outils existent mais je n'ai pas trouvé de chose complètement automatique.

Codialement

Merci bien! Et puisqu'on en parle c'quoi ce IntelliSense ? Il me semblait que c'était simplement l'auto-complétion, mais ça a l'air d'englober plus de trucs que ça ?

(ya tant de choses à apprendre, je sautille de partout :p)

Citation:

---

Envoyé par Flaburgan

Merci bien! Et puisqu'on en parle c'quoi ce IntelliSense ? Il me semblait que c'était simplement l'auto-complétion, mais ça a l'air d'englober plus de trucs que ça ?

(ya tant de choses à apprendre, je sautille de partout :p)

---

Le mieux plutôt qu'une longue description est d'aller à la source :

http://msdn.microsoft.com/en-us/libr...v=VS.100).aspx

Et y'a même une (petite) page wiki sur le sujet :

http://en.wikipedia.org/wiki/IntelliSense

Salut et bienvenu dans le monde .NET ;)

Pas mal de choses ont été dites dans le topic, je vais en reprendre quelques unes et t'en donner un échantillon.

Pour ce qui est des accesseurs et des mutateurs, en Java par convention on préfixe une méthode par Get ou Set:

Code:

---

1 2 3 4 5 6 7 8 9

// Accesseurs et mutateurs public int GetIdClient() { return this.idClient; }   public void SetIdClient(int id){ this.idClient = id; }

---

En C# tu peux faire la même chose ou définir des propriétés. En fait les getter et setter ont été standardisé:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

// Accesseurs et mutateurs public string IdClient { get { return this.idClient; } set { this.IdClient = value; } }   // En utilisation ça donne: Client unClient = new Client();   int id = unClient.IdClient; // Appel la propriété get unClient.IdClient = 5; // Appel la propriété set

---

Tu retrouveras également des indexeurs, ils te permettront de parcourir un attribut de ta classe de type Collection ou Tableau:

Code:

---

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

// On suppose qu'il existe un attribut lesCommandes dans la classe Client   // Indexeur par l'index public Commande this[int poste] { get { Commande commandeCourante = this.lesCommandes[poste] as Commande; return commandeCourante; }   // Indexeur par le nom public Commande this[string nom] { get { int valRetour = -1; Commande commandeCourante = null;   for (int i = 0; i < Colonnes.Count; i++) { commandeCourante = this.lesCommandes[i] as Commande;   if (commandeCourante.Nom == Nom) { valRetour = i; } }   return valRetour; } }   // Utilisation public SqlDbType RecupererTypeSql(string nom) { int i = 0; SqlDbType leType = SqlDbType.Int;   for (i = 0; i < this.lesCommandes.Count; i++) { if (this[i].Nom == nom) { leType = this[i].TypeSQL; } }   return leType; } }

---

Pour ce qui est de LINQ, comme il a été mentionné plus haut, c'est un langage qui permet de requêter un grand nombre de source de données.
Il existe: LINQ To SQL, LINQ To Objects, LINQ To XML, LINQ To Entity, LINQ To Sharepoint

Je trouve LINQ très puissant, en effet avec LINQ To Objects on peut interroger tous les types d'objets implémentant IEnumerable. De plus la syntaxe est inspirée de SQL.

Code:

---

1 2 3 4 5

var query = from Commande cmd in lesCommandes where cmd.Total > 5000 order by cmd.Nom select cmd;

---

Par itération cela aurait pris beaucoup plus de lignes de code.
Je te conseille de faire des recherches sur le mot clé "var", il est très intéressant ;) .

Je t'ai décrit une partie très infime de ce que peut offrir le C#, il te reste encore énormément de choses à découvrir, et c'est encore le cas pour moi aussi ;)

Pour ce qui est de la documentation, la MSDN est la référence.
Tu y trouveras la description d'absolument tout le Framework .NET dans toutes ses versions, avec des exemples de code dans differents langages .NET, des articles, des livres blanc etc... le tout traduit en plusieurs dizaines de langues.
Par contre la fonction recherche de la MSDN n'est pas terrible. Ce que je te conseille c'est de taper sur Google "msdn" suivie de ce que tu recherches.

Enfin, apprend à utiliser Visual Studio, pour moi il est l'un des IDE les plus puissant. Son mode débuggage est une pure merveille.
J'ai eu l'occasion de tester Code::Blocks, Eclispe et Netbeans (certes pas aussi longtemps que Visual Studio) et je n'ai pas retrouvé les sensations éprouvées sur Visual Studio.

Bonjour à vous deux, et merci.
J'ai en effet trouvé le site msdn dans le temps écoulé depuis mon précédent message. Une mine d'information. Je regrette qu'il n'y ait pas l'équivalent en français pour Java !

Concernant les propriétés, je pense avoir saisi. Pour linQ, j'ai pu observer quelques exemples dans MSDN, je vais pour l'instant m'en servir de parser XML, on verra bien si je m'en sors quand je m'y mettrais, je fais de la spécif pour l'instant.

J'ai un peu plus de mal avec les indexeurs (orthographe ?o_O), deux choses me gène : La déclaration : public Commande this[int poste]
Pourquoi ce nom de this, si je veux faire un autre indexeur dans la classe client mais sur les adresses par exemple, puis-je écrire public Adresse this[int i] ? Ou bien le type retourné ne suffit pas pour définir une nouvelle signature ? Comment les distinguer après coup dans le code ?

et je ne comprends pas cette ligne dans l'utilisation : SqlDbType leType = SqlDbType.Int;


Autre chose, j'ai croisé des paramètres out en C#, je connais à peu près le concept car j'ai fait de l'ADA, l'implémentation est la même en C# ? Un paramètre sans rien d'indiqué par défaut est de type in ? ou in out ?

Citation:

---

Envoyé par Flaburgan

J'ai un peu plus de mal avec les indexeurs (orthographe ?o_O), deux choses me gène : La déclaration : public Commande this[int poste]
Pourquoi ce nom de this, si je veux faire un autre indexeur dans la classe client mais sur les adresses par exemple, puis-je écrire public Adresse this[int i] ? Ou bien le type retourné ne suffit pas pour définir une nouvelle signature ? Comment les distinguer après coup dans le code ?

---

Effectivement tu ne peux définir qu'un indexeur par classe. Le mot clé "this" comme en Java représente l'objet courant.
La chose que tu peux faire, comme je l'ai fais dans l'exemple, c'est de surchargé ton indexeur, mais ca concerne la même collection.

Toutefois ! Il existe une ruse pour avoir plusieurs indexeurs par classe pointant sur des collections différentes.
Je te renvoie à un article d'un membre du club pour découvrir l'astuce ;) :
- http://blog.developpez.com/index.php...s_une_classe_c

Citation:

---

Envoyé par Flaburgan

et je ne comprends pas cette ligne dans l'utilisation : SqlDbType leType = SqlDbType.Int;

---

Ici je fais appel à un Enumerateur de System.Data.SqlDbType.
En C# tu peux définir tes propres énumérateurs:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public enum Couleur { Rouge, Vert, Bleu, Indigo, Cyan, }   // Utilisation Couleur.Bleu;

---

Citation:

---

Envoyé par Flaburgan

Autre chose, j'ai croisé des paramètres out en C#, je connais à peu près le concept car j'ai fait de l'ADA, l'implémentation est la même en C# ? Un paramètre sans rien d'indiqué par défaut est de type in ? ou in out ?

---

Le mot clé "out" te permet de passer des paramétres à une fonction par référence, ça ressemble aux pointeurs en C. De cette manière ta fonction peut "renvoyer" plusieurs valeurs. Un exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

static void Main(string[] args) { ...   int leChiffre = 5;   Console.WriteLine(leChiffre); // Le chiffre vaut 5   bool estModifie = unClient.ModifierChiffre(out unChiffre);   Console.WriteLine(leChiffre); // Le chiffre vaut 20   ... }   public bool ModifierChiffre(out int unChiffre) { unChiffre = 20;   return true; }

---

Il existe également le mot clé "ref" qui fait exactement la même chose sauf que tu dois au préalable initialiser ta variable. Avec "out" tu n'es pas obligé de le faire.

Citation:

---

Envoyé par Flaburgan

et je ne comprends pas cette ligne dans l'utilisation : SqlDbType leType = SqlDbType.Int;

---

Il s'agit d'une énumération (enum).

Il existe l'équivalent en Java depuis java 5.0.

Citation:

---

Envoyé par Flaburgan

Autre chose, j'ai croisé des paramètres out en C#, je connais à peu près le concept car j'ai fait de l'ADA, l'implémentation est la même en C# ? Un paramètre sans rien d'indiqué par défaut est de type in ? ou in out ?

---

Le mieux est de lire la doc: http://msdn.microsoft.com/fr-fr/libr...(v=VS.90).aspx

J'ai compris ce qu'étaient les délégués, et je commence à assimiler l'utilisation de Linq. Merci à tous.
Des dizaines de questions se précipitent cependant à chaque nouvelle manipulation ^^^^
J'applique RTFM régulièrement, mais pas forcément facile de se retrouver dans le site MSDN
Deux petites pour ce coup-ci donc :
Est-il possible d'importer d'un seul coup plusieurs namespace ?
en java, on peut faire par exemple

Code:

---

import java.util.*

---

pour avoir toutes les classes de java util. Là, j'ai un début de programme qui ressemble déjà à ça

Code:

---

1 2 3 4 5 6 7 8 9 10

using System; using System.Text; using System.Collections.Generic; using System.Linq; using System.Xml.Linq;   using modelisation;   namespace parseur {

---

Alors que je n'ai pratiquement rien écrit. Je n'ose imaginer d'ici quelques semaines le résultat...

En fait, y a-t-il un moyen de régler IntelliSense ou je ne sais quoi pour qu'il nous fasse les imports qu'il faut ??! Je ne supporte plus ce "The type or namespace name 'blablabla' could not be found (are you missing a using directive or an assembly reference?)" argh ! Mais importe le moi ce fichier dont tu as besoin !



Deuxième question, quand on travaille sur des fichiers, où ceux-ci doivent-ils être placés ? Dans le dossier du projet, de la solution... ?
Edit, j'ai trouvé, dans bin puis débug...

Pas d'import en large comme java de type System.*, mais ce n'est guère gênant. Si tu écris un élément non identifié, raccourci alt+maj+F10 sous VS ou cliquer sur le nom de l'objet inconnu permettra de référencer vite fait le namespace, faut pas avoir peur quoi... Les using ça va assez vite au début, mais on ne dépasse pas la douzaine, ou alors la classe fait vraiment fourre-tout... Exception pour ce qui est Winform/WPF, ou tu dépasse assez vite les 20 using, mais ça grossit pas plus que ça. A la longue les using tu n'y feras plus gaffe...

En général dans le projet pour les documents, ça peut être dans des sous-répertoires attachés au projet, tout dépend de comment tu t'organises :)
Tu peux dire que tel fichier peut être intégré dans la dll ou copié vers le répertoire de compilation...

Merci bien!!
Et on continue avec les petites questions, déjà, gros doute, y a-t-il des destructeurs ? Ou un garbage collector, comme en java ? Comment tout cela fonctionne-t-il ?

Ensuite, je suis tombé dans la doc sur des trucs du genre "accepte int, int?, long, long?". Kesecé que ces noms de type avec un ? derrière ? hein ? hein ? hein ?

(curieuuuuuuuux!)

On a le garbage collector, il est possible de créer des destructeurs (technique peu usitée). Par contre les objets devant être nettoyés par le développeur implémente IDisposable (Comme les classes de Stream par exemple), il faut donc appeler Dispose quand tu n'as plus besoin de l'objet (ou le déclarer dans un blog using(){} qui appelle Dispose automatiquement, à ne pas confondre avec le using qui importe un namespace).

Une des principales fuites de mémoire en .net, c'est abonner une méthode à un événement, que l'objet soit détruit sans retirer l'abonnement (donc pour chaque Add(+=), programme de suite le remove (-=)

un ? signifie que la valeur peut être nulle, cela correspond à la classe Nullable<T>. On manipule ces membres avec les propriétés HasValue et Value. Cela ne s'applique aux types valeurs et non aux types références (définies comme étant un struct et non une classe. Exemple : bool, int, double, DateTime...)

Et on retrouve nos deux questions quotidiennes.

Niveau bonnes pratiques, est-ce que déclarer une classe en dehors d'un namespace est quel que chose de mal vue ou normale ?
Dans quel namespace déclarez vous la classe "Application", celle qui contient le main ?

Et niveau sauvegarde, comment sauvegarder vous le contexte d'utilisation du programme lors de sa fermeture ? Quelles sont les méthodes les plus rapides pour une solution du type sérialisation des objets et écriture dans un fichier ?

Je te conseille de regarder les vidéos faites par Pascal Belaud (Microsoft): http://www.microsoft.com/france/visi...lt.aspx?chap=1

Et de revenir avec des questions après. Sinon dans 3 ans on y est encore :mrgreen:

Déclarer une classe en dehors d'un espace de nom, ouai c'est mal vu :aie:
Pour la classe Application, je ne sais pas si beaucoup de gens modifient le namespace créé par défaut quand on crée un nouveau projet avec Visual Studio.

Pour la sauvegarde du contexte, ça dépend. Si c'est des données du type, préférences de l'utilisateur concernant l'application (les options en gros). Tu peux utiliser les settings (une des vidéos précédentes en explique le fonctionnement).
S'il s'agit plus de données métiers, cela peut être une base de données ou un fichier XML par exemple.

Euh, merci pour ton lien, mais quand je clique dessus, il me demande mon nom d'utilisateur et mon mot de passe... ??

Edit : quand je l'ouvre dans un nouvel onglet, je peux quand même y accéder.

Salut à tous,
Tout d'abord, bonne année :)

Ensuite, et bien, j'ai déjà parcouru beaucoup de chemin depuis que j'ai créé ce topic :p

J'ai découvert le MVVM et j'ai ainsi la joie de réussir à structurer mon appli pratiquement comme j'avais l'habitude de le faire en MVC tout en étant compatible WPF (et mine de rien, c'était pas une mince affaire, à la base).

Seulement, d'après MVVM, il ne faut pas de code dans le code-behind. C'est aussi ce qui me semble le plus propre, mais je suis heurté à un problème, comment gérer les clics des utilisateurs facilement ?
Avant, quand j'avais

Code:

---

<MenuItem Header="Quitter" Click="fileExitMenuItem_Click"/>

---

Il me suffisait d'écrire dans le code behind une méthode

Code:

---

1 2	void fileExitMenuItem_Click(object sender, RoutedEventArgs e) {

---

Mais si je veux déplacer cette méthode dans le ViewModel, oulala catastrophe, refus obstiné du compilateur...

Il faut utiliser le concept de commandes (implémentation du pattern Command inclus dans WPF). Dans la classe MenuItem tu as une propriété Command que tu lie (bind) à une priopriété de type ICommand sur le ViewModel.

On en parle ici: http://japf.developpez.com/tutoriels...stables/#LVI-D et sur le net (recherche sur Bing).

Merci beaucoup ! Je ne suis pas encore très à l'aise avec les lambdas utilisés dans l'exemple, mais j'ai compris comment cela fonctionnait.

Autre question, où traiter les erreurs de manière propre ? Par exemple, dans l'équivalent de mon controleur, j'ai une FileNotFoundException. Je fais une messagebox directement dedans, ou bien dois-je faire remonter cela jusqu'à la vue ? Ou bien créer une classe static spécifiquement pour ce genre de cas, avec une message box pour les erreurs, une pour les avertissements, une pour les aides...

Et une dernière pour la route, j'aime poser mes questions par paire, j'ai vu qu'il était facile d'utiliser ObservableCollection<valeur>, mais j'aurais aimé avec une collection sous forme de dictionnaire, donc avec <clé,valeur>, je n'ai pas trouvé l'équivalent sur le msdn, quelqu'un sait si ça existe ou s'il faut que je réimplémente une collection de dictionnaire qui hériterait de INotifyCollectionChanged, INotifyPropertyChanged...
(j'ai regardé ObservableCollection et aucune méthode n'a de corps, s'il suffit de rajouter les events et l'héritage, ce serait plus rapide que de parcourir le web à la recherche du graal..)

Edit : J'ai trouvé quelqu'un qui avait déjà fait le boulot à ma place, et qui balance la source de son ObservableDictionnary, je vais tester ça.

Citation:

---

Envoyé par Flaburgan

Merci beaucoup ! Je ne suis pas encore très à l'aise avec les lambdas utilisés dans l'exemple, mais j'ai compris comment cela fonctionnait.

Autre question, où traiter les erreurs de manière propre ? Par exemple, dans l'équivalent de mon controleur, j'ai une FileNotFoundException. Je fais une messagebox directement dedans, ou bien dois-je faire remonter cela jusqu'à la vue ? Ou bien créer une classe static spécifiquement pour ce genre de cas, avec une message box pour les erreurs, une pour les avertissements, une pour les aides...

Et une dernière pour la route, j'aime poser mes questions par paire, j'ai vu qu'il était facile d'utiliser ObservableCollection<valeur>, mais j'aurais aimé avec une collection sous forme de dictionnaire, donc avec <clé,valeur>, je n'ai pas trouvé l'équivalent sur le msdn, quelqu'un sait si ça existe ou s'il faut que je réimplémente une collection de dictionnaire qui hériterait de INotifyCollectionChanged, INotifyPropertyChanged...
(j'ai regardé ObservableCollection et aucune méthode n'a de corps, s'il suffit de rajouter les events et l'héritage, ce serait plus rapide que de parcourir le web à la recherche du graal..)

Edit : J'ai trouvé quelqu'un qui avait déjà fait le boulot à ma place, et qui balance la source de son ObservableDictionnary, je vais tester ça.

---

Tu peux utiliser sinon le ObservableCollection<Tuple<T1,T2>>, sauf qu'il n'y a pas unicité des clefs.

J'ai pris la classe créée ObservableDictionnary.
Le problème est que quand je l'affiche dans ma treeview, je me retrouve avec des couples clés valeurs sous cette forme : [maClé.ToString(), value.ToString()], c'est aussi ce que je récupére (enfin je crois, vu que je suis obligé de faire un toString) quand je fais SelectItem sur ma treeview. Or moi je voudrais juste récupérer (et afficher) value. Je suppose donc que mon ObservableDictionary ne sert à rien, et que je n'ai qu'à avoir un dictionnaire en interne que je convertis (je ne sais comment) en ObservableCollection, et c'est elle que je donne à la treeview ?

Citation:

---

Envoyé par Flaburgan

J'ai pris la classe créée ObservableDictionnary.
Le problème est que quand je l'affiche dans ma treeview, je me retrouve avec des couples clés valeurs sous cette forme : [maClé.ToString(), value.ToString()], c'est aussi ce que je récupére (enfin je crois, vu que je suis obligé de faire un toString) quand je fais SelectItem sur ma treeview. Or moi je voudrais juste récupérer (et afficher) value. Je suppose donc que mon ObservableDictionary ne sert à rien, et que je n'ai qu'à avoir un dictionnaire en interne que je convertis (je ne sais comment) en ObservableCollection, et c'est elle que je donne à la treeview ?

---

Il faut plutot modifier le ItemTemplate du treeview pour qu'il affiche le bon champs!

Je ne sais pas faire ça :? Je vais essayer de regarder

Edit : Du coup, j'ai fait une liste simple, enfin j'me suis débrouillé quoi ^^
Et pour les messages d'erreur alors ?

J'ajouterai un petit truc sur les using si la place qu'ils prennent te gène :

Code:

---

1 2 3 4 5 6 7

#region Références using System; using System.Data; using System.Data.SqlClient; .... #endregion

---

Ca construit une région repliable histoire d'organiser un peu plus ton code.

C'est une syntaxe proche du préprocesseur de C/C++ (mais attention, c'est pas parce que ca y ressemble qu'il s'agit vraiment d'un préprocesseur C/C++).

Il faut savoir que le .Net et le C# en particulier sont fortement liés à Visual Studio.
Le code que tu tapes peut influer directement sur l'IDE.

Par exemple, tu peux poser des attributs sur tes classes et propriétés :

Code:

---

1 2 3 4 5 6 7 8

public class MonControl : System.Windows.Forms.UserControl { public string UnePropriete { get; set;}   [Browsable(false)] public string UneAutrePropriete { get; set; } }

---

Avec ce code, la propriété "UnePropriete" sera visible et affectable dans le Designer de Visual Studio.
Par contre, la propriété "UneAutrePropriete" n'apparaitra pas dans la grille de propriétés du Designer. Son comportement en terme de programmation reste inchangé.

je n'avais pas pensé à enfermer les using dans une région effectivement ! Merci bien !