Discussion :

[miltone]

Salut à tous,

Débutant la programmation objet, j'ai fini ma phase d'apprentissage des théories pour commencer à rentrer dans le code (enter the matrix).

Et là c'est la catastrophe. A la lecture des règles théoriques ont ce dit qu'on a compris, parfois avec de la difficulté même, et que y'a plus qu'a, mais là en l’occurrence dans ma situation c'est le drame

Histoire de bien me faire comprendre et d'avoir une aide de qualité je vais m'appliquer dans mon explication....

------------------------------------------------

Mon problème est que j'aimerais pouvoir utiliser un objet par l'intermédiaire d'un autre. Je sais donc qu'il existe 2 méthodes à savoir : l'association et la dépendance. Mais lorsque j'essaie d'effectuer ces principes je me retrouve dans tous les cas avec des erreurs.

Voici le minuscule diagrammes UML de classes de mon projet :



Ainsi j'aimerais pouvoir, à travers mon objet client, lancer une connexion vers ma base de données afin de pouvoir effectuer une fonction de ma classe Client. Je précise que je possède déjà un objet de la classe Myconnexion qui à déjà été initialisé pour ma base de données. Je voudrais donc me servir de cette objet pour lancer la méthode "lancerequete" (c'est du lourd je vous l'avais dit!) de l'objet déjà existant et paramétré pour ma base.

------------------------------------

J'essaie donc par l'intermédiaire de l'association. Voici le code :

Dans la classe program j'ai ces 2 lignes dès le lancement :

Code :

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

1
2
MyConnexion ConnexionClient = new MyConnexion();
ConnexionClient.InitialisationMysql();

Puis dans ma classe client j'ai mis un attribut de type Myconnexion :

Code :

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

MyConnexion ConnexionClient;

puis dans une méthode de la classe je fait :

Code :

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

dtClient = ConnexionClient.LanceRequete(SuperDiscountClient);

Et la VS2010 me signal aucunes erreur en perspective mais lorsque je lance mon appli j'ai :

La référence d'objet n'est pas définie à une instance d'un objet.

---------------------

J'essaie donc la méthode non persistante à savoir la dépendance. Je passe en argument de ma fonction dans la classe client cela :

Code :

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

public string[] IntegriteCodeClient(string NomDatabase, MyConnexion ConnexionClient)

Cette fonction est appelé à la suite d'un event sur un bouton dans mon GUI et appel donc la fonction de la manière suivante :

Code :

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

client.IntegriteCodeClient("monClient", ConnexionClient).CopyTo(t, 0);

Mais maintenant le problème c'est que ma Form1 (GUI) ne connais pas cette objet ConnexionClient. Si je met en attribut un objet MyConnexion dans ma class Form1 alors ma GUI deviens persistante face à ma classe de connexion à la base.

-------------

Voilà mon problème, je suis un peu bloqué. J'aimerai pouvoir faire communiqué mes objets entre eux mais il y a certains principe qu’apparemment je ne pas encore bien compris concrètement dans la pratique. J'aimerai pouvoir développer dans une philosophie professionnel et donc obtenir le moins de persistance possible et surtout avoir une bonne séparation de couche.

Pourriez-vous donc m'épauler pour comprendre un obtenir un code qui puisse marché de façon efficace face à mes 4 pauvres classes.




THX a lot for all helping

[Er3van]

A mon avis, ta première solution fonctionne, reste à voir si c'est la bonne, mais il te manque juste l'initialisation de ton objet ConnexionClient.

Tu peux utiliser une propriété comme suit dans ta classe client :

Code C# :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
MyConnexion ConnexionClient {
     get { 
             if (_connexionClient == null) {
                 _connexionClient = new MyConnection();
             }
             return _connexionClient;
     set { // pas sûr que tu en aies besoin 
             _connexionClient = value ;
     }
}
MyConnexion _connexionClient;

[chrisdot]

En gros tu voudrais utiliser ton objet de "connexion" de partout ?

[Er3van]

A titre personnel, j'aurai plutôt eu quelque chose comme ça :

IClientManager : interface qui définit les méthodes possibles de gestion du client
ClientManager : classe qui implémente IClientManager

ClientManager utiliserait MyConnexion (d'ailleurs le nom n'est pas explicite, il faudrait le changer) pour les opérations en base.

J'utiliserai par exemple ainsi :

Code c# :

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

1
2
3
4
5
 
Client myClient = IClientManager.GetClientByID(myClient.CustomerID);
myClient.firstName = "George" ;
IClientManager.UpdateClient(myClient);
IClientManager.GetAllOrders(myClient);

[miltone]

Tu reporte sur une interface l'association que tu fait de Myconnexion avec client.Pourquoi pas mais quel est l'intérèt.

Je devrais donc faire des interfaces pour tous les objets métier dont je me sert.
Ainsi a chaque fois que j'appelerai une méthode qui doit travailler avec la base, je devrais créer un objet connexion et l'initialiser à chaque fois.

Si il faut faire de la sorte je me plierai au règles mais je pensais pouvoir factoriser mon initialisation de connexion et voir même n'utilise qu'un seul objet connexion déjà paramétré à chaque fois.

[chrisdot]

C'est pour cela que je posais ma question. Il y a un design pattern qui s'appelle singleton et qui pourrait t'aider.

[Er3van]

Ok, reprenons.

Je devrais donc faire des interfaces pour tous les objets métier dont je me sert.

Oui, c'est beaucoup plus propre à mes yeux de découper le métier de cette façon.
NB : Ce n'est pas la seule façon.

Ainsi a chaque fois que j'appelerai une méthode qui doit travailler avec la base, je devrais créer un objet connexion et l'initialiser à chaque fois.

Pas nécessairement.

Tu peux imaginer quelquechose de la sorte.
Mettons que tu aies deux classes métiers, client et vendeur :

Code c# :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
MyConnexion ConnexionClient {
     get { 
             if (_connexionClient == null) {
                 _connexionClient = MyConnexion.Connexion;
             }
             return _connexionClient;
     set { // pas sûr que tu en aies besoin 
             _connexionClient = value ;
     }
}
MyConnexion _connexionClient;
 
MyConnexion ConnexionVendeur {
     get { 
             if (_connexionVendeur == null) {
                 _connexionVendeur= MyConnexion.Connexion;
             }
             return _connexionVendeur;
     set { // pas sûr que tu en aies besoin 
             _connexionVendeur= value ;
     }
}
MyConnexion _connexionVendeur;

Et dans ta classe MyConnexion :

Code c# :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
public class MyConnexion{
     public static MyConnexion Connexion{
            get { 
                  if (_connexion== null) {
                       _connexion= new MyConnexion();
                  }
                  return _connexion;
            }
            set { // pas sûr que tu en aies besoin 
                  _connexion= value ;
            }
     }
     private static _connexion;
 
     private MyConnexion() { } ; // constructeur privé
}

[miltone]

Ayant du mal à bien cerner le contexte global du code que je souhaite produire et mon problème, j'ai décidé de revoir le système de développement en couche.Que je puise vraiment savoir ce que je fait.

Tout en restant dans ce sujet de dialogue objet entre ma classe client et ma base de données, j'aimerais vous proposer une série de questions :

- Dois-je créer une classe DAO(Data Access Layer) pour chaque DO(Data Object) dans ma solution ?
- Quel sont les avantages à pouvoir déclarer un attribut du type de la classe elle-même ?
- Je n'ai pas bien cerné avec qui dialoguait les classes DO (Data Object)