forcer l'utilisation d'une classe

Version imprimable

11/02/2008, 09h04
TheBlackReverand

forcer l'utilisation d'une classe

bonjour

j'ai une classe qui contient des fonctions static renvoyant des chaine string

j'ai d'autre fonction dans d'autre classe qui ont des parametre qui doive obligatoirement avoir pour origine le retour d'une des fonctions static de la 1er classe

comme quand on met "Addition(int ch1, int ch2)" on reclame obligatoirement 2 chiffre entier et bien moi je veut reclamer un retour de type string d'une de mes fonctions static de me classe

est ce possible??
11/02/2008, 09h22
_skip

Tu peux forcer un paramètre d'être d'un certain type, mais pas de provenir d'une origine précise.
Ou alors tu pourrais créer ta propre classe héritant d'une classe abstraite qui contient un string, que seul ta méthode serait capable de construire.

Mais ce genre de chose a pas forcément grand intérêt, c'est plutôt que tu es en train de faire une erreur de design.

se n'est pas dans un projet WinForms mais une DLL

enfait si je veut fair sa c'est que ma 1er classe va obtenir des infos qui devront etre presenter sous un certain format pour etre utiliser.

mais comme les verifications et mise en forme se ferons plusieurs fois et dans differente class je voulais crèè une classe pour la mise en forme.

voila une vision schematique(d'autre element vienne complexifier la chose mais bon sa n'as pas d'importance ici)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class MiseEnForme() { public string Premiere(....) {.....} public string Deuxieme(....) {.....} public string Troisieme(....) {.....} } public void Action(MiseEnForme.Premiere(parametre1, parametre2....)) { ... ... }

11/02/2008, 11h24
_skip

Tu voudrais pouvoir t'assurer que ces string proviennent pas d'ailleurs que de la classe MiseEnForme, mais ce n'est pas vraiment possible de forcer cela. Sauf en faisant en sorte que tes méthodes de mise en forme retournent non pas des strings mais des objets à toi qui encapsulent un string.
11/02/2008, 11h27
SoBaKa

Si j'ai bien compris, tu veux pouvoir à partir de ta dll utiliser une de tes classes qui appelle d'autres méthodes d'une classe qui elle se trouve aussi dans ta dll ?

si c'est ça, tu n'a qu'a mettre ta classe en internal...
11/02/2008, 11h31
TheBlackReverand

l'access entre les classe n'est pas un soucis

mais c'est d'etre sur que les parametres que je donne a mes fonctions sont des string provenant de ma classe personnelle.

_skip -> oui je vais surment devoir travailler avec une structure privè

Encapsules tous les appelles des méthodes de tes classes dans une autre méthodes ? :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MiseEnForme()
{
   public string Premiere(....) {.....}
   public string Deuxieme(....) {.....}
   public string Troisieme(....) {.....}
 
   public void Action (parametre1, parametre2....)
   {
      Action(MiseEnForme.Premiere(parametre1, parametre2....));
   }
}
 
protected void Action(MiseEnForme.Premiere(parametre1, parametre2....))
{
   ...
   ...
}

euh.....je comprend pas vraiment.....

entre temps on m'as proposer d'utiliser:

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
public class MiseEnForme()
{
   public MiseEnForme(param1, param2....)
   {
      ...
      _stringFormater = _resultatMiseEnForme;
   }
 
   private string _stringFormater;
   public string StringFormater()
   {
      get{ return _stringFormater; }
   }
}
 
public class Action()
{
   public void Action(MiseEnForme _maMiseEnForme)
   {
      // j'utilise _maMiseEnForme.StringFormater pour avoir ma valeur
      _maMiseEnForme.Dispose();
   }
}
 
 
// pour utiliser ma fonction Action
Action(new MiseEnForme(p1, p2....);

en prenant en compte que le constructeur de MiseEnForme serais surcharger

personnellement je pencherais plus pour la methode de skip

Je reprends mon code et j'explique :
Tu veux controler les paramètres que tu fournis aux méthodes de plusieurs classes, voir potentiellement tu veux controler le retour de c'est classe, une des méthodes (à adapter si besoin) est de faire une classe contenaire de ces instances de classes.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public class Conteneur() { //Les instances des classes de ta dll : UneClasse Objet1 = new UneClasse(); //ou autre, le tout étant de récupérer l'instance de la classe ou de la créer. //Les méthode de modif de tes strings. private string Premiere(....) {.....} private string Deuxieme(....) {.....} private string Troisieme(....) {.....} //Les méthodes à controler public void Action (parametre1, parametre2....) { Objet1.Action(Premiere(parametre1, parametre2....)); } }

Et pourquoi pas faire

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
class MiseEnForme()
{
   private string p1;
   private string p2;
   private string p3;
 
   public MiseEnForme(string param1, string param2, string param3){
       p1 = param1;
       p2 = param2;
       p3 = param3;  
   }
 
   public string Premiere() {.....}
   public string Deuxieme() {.....}
   public string Troisieme() {.....}
}
 
public void Action(MiseEnForme maMiseEnForme)
{
   maMiseEnForme.Premiere();
   ...
}
 
// et quand tu appelles action
 
Action(new MiseEnForme("parametre1","parametre2,"parametre3"));

j'ai compris ton resonnement ced mais voila la solution que j'ai choisis de mettre en place

objet principale: represente une connection a un serveur

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
51
52
public class Connection
{
	private IDbConnection _connection;
 
	private Connection() { }
	public Connection(TypeConnection TypeConnection)
	{
		this._typeConnection = TypeConnection;
 
		switch (this._typeConnection)
		{
			case TypeConnection.SQL:
				_connection = new SqlConnection();
				break;
 
			case TypeConnection.MySQL:
				_connection = new MySqlConnection();
				break;
 
			case TypeConnection.Access:
				_connection = new OleDbConnection();
				break;
		}
	}
 
	private TypeConnection _typeConnection;
	public TypeConnection TypeConnection
	{
		get { return _typeConnection; }
		set { _typeConnection = value; }
	}
 
	private ConnectionString _connectionString;
	public ConnectionString ConnectionString
	{
		get { return _connectionString; }
		set { _connectionString = value; }
	}
 
	public bool Open(ConnectionString _connectionString)
	{
		_connection.ConnectionString = _connectionString.ChaineDeConnection;
 
		if (_connection.ConnectionString != string.Empty)
			_connection.Open();
 
		if (_connection.State == ConnectionState.Open)
			return true;
		else
			return false;
	}
}

objet representant la chaine de connection et permettant de ne pas inseret de chaine de connection manuellement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ConnectionString
{
	private string _chaineDeConnection;
	public string ChaineDeConnection
	{
		get { return _chaineDeConnection; }
		set { _chaineDeConnection = value; }
	}
 
	private TypeConnection _typeConnection;
	public TypeConnection TypeConnection
	{
		get { return _typeConnection; }
		set { _typeConnection = value; }
	}
}

classe qui genere un ConnectionString a partir de certaine infos

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class GenererConnectionString
{
	private GenererConnectionString() { }
 
	public static ConnectionString MySQL(string Serveur, string UserName, string Password)
	{
		ConnectionString _newConnString = new ConnectionString();
 
		_newConnString.TypeConnection = TypeConnection.MySQL;
		_newConnString.ChaineDeConnection = String.Format("Server={0}; UserID={1}; Password={2}; Connection TimeOut = 5",
					Serveur,
					UserName,
					Password);
 
		return _newConnString;
	}
}

pour crèè une connexion

Code:

1
2
Connection _MaConn = new Connection(TypeConnection.MySQL);
_MaConn.Open(GenererConnectionString.MySQL("localhost", "root", ""));