Discussion :

[OminiuS]

Bonjour,

J'ai une classe qui contient des constantes qui sont en base de données (je les crées et place en BDD).
Je travaille avec WCF et j'aimerai utiliser ces constantes dans mon IHM SilverLight.

J'ai essayé de mettre [DataMember] sur mes attributs static mais ça ne fonctionne pas!
J'ai essayé via des properties, idem!
J'ai essayé en envoyant uniquement les ID, idem!
J'ai essayé pas mal de méthode, mais je suis toujours autant coincé!

Je ne vois pas comment envoyer mes constantes!

Une idée?
Merci d'avance.

Ci dessous, ma classe qui contient des constantes!

Code :

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
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
[DataContract]//Attribute
public sealed class EtatExercice
{
	// Membres statiques
	#region Membres statiques
	// Private
	private static Dictionary<string, EtatExercice> s_listEtatExercice = new Dictionary<string, EtatExercice>();
 
	// Internal
	[DataMember]
	public static readonly EtatExercice Created = new EtatExercice("Créé");
	[DataMember]
	public static readonly EtatExercice Prepared = new EtatExercice("Préparé");
	[DataMember]
	public static readonly EtatExercice DeployedStopped = new EtatExercice("Déployé Arrêté");
	[DataMember]
	public static readonly EtatExercice DeployedStarted = new EtatExercice("Déployé Démarré");
	[DataMember]
	public static readonly EtatExercice DeployedError = new EtatExercice("Déployé Arrêté - En erreur");
	[DataMember]
	public static readonly EtatExercice Archived = new EtatExercice("Archivé");
	#endregion
 
	// Membres
	#region Membres
	// Private
	private EtatBO m_objEtatExercice;
	#endregion
 
	// Properties
	#region Properties
 
	/// <summary>
	/// Propertie Nom de l'état
	/// </summary>
	[DataMember]
	public string Nom
	{
		get
		{
			return this.m_objEtatExercice.Nom;
		}
		private set
		{
 
		}
	}
 
	#endregion
 
	// Constructeurs
	#region Constructeurs
	// Private
	/// <summary>
	/// <c>EtatExercice</c>
	/// Un état d'exercice stocké dans la base de données.
	/// Cette objet permet de récupérer l'enregistrement en base de l'état
	/// d'un exercice. Si cet état n'existe pas il est inséré dans la base.
	/// </summary>
	/// <param name="in_sNomEtat">Le nom de l'état d'exercice.</param>
	private EtatExercice(string in_sNomEtat)
	{
		using (SCIPIOEntities l_objScipioEF = new SCIPIOEntities())
		{
			try
			{
				// Ouverture d'une nouvelle transaction
				l_objScipioEF.OpenTransaction();
 
				try
				{
					// Recherche de l'enregistrement dans EtatExercice
					m_objEtatExercice = EtatDAO.GetInstanceWithTransaction(l_objScipioEF).GetByNom(in_sNomEtat);
				}
				catch (ElementInexistantException)
				{
					// L'état d'exercice n'a pas été trouvé, on le créé
					m_objEtatExercice = EtatDAO.GetInstanceWithTransaction(l_objScipioEF).Create(in_sNomEtat);
				}
 
				// Commit la transaction
				l_objScipioEF.CommitTransaction();
			}
			catch
			{
				// Rollback de la transaction
				l_objScipioEF.RollbackTransaction();
			}
			finally
			{
				// Fermeture de la transaction
				l_objScipioEF.CloseConnectionTransaction();
			}
		}
 
		// Stockage de l'etat d'exerice dans la liste
		s_listEtatExercice.Add(m_objEtatExercice.Nom, this);
	}
	#endregion
 
	// Opérateurs statiques
	#region Opérateurs statiques
	// Public
	/// <summary>
	/// <c>implicit operator long</c>
	/// Permet de convertir un EtatExercice en long en utilisant son ID.
	/// </summary>
	/// <param name="in_objEtatExercice">L'état d'exercice à convertir</param>
	/// <returns></returns>
	public static implicit operator long(EtatExercice in_objEtatExercice)
	{
		// Si l'état d'exercice est valide on renvoi son ID sinon on renvoie -1
		if (in_objEtatExercice != null && in_objEtatExercice.m_objEtatExercice != null)
			return in_objEtatExercice.m_objEtatExercice.Id;
		else
			return -1;
	}
 
	/// <summary>
	/// <c>implicit operator EtatBO</c>
	/// Permet de convertir un EtatExercice en EtatBO.
	/// </summary>
	/// <param name="in_objEtatExercice">L'état d'exercice à convertir</param>
	/// <returns></returns>
	public static implicit operator EtatBO(EtatExercice in_objEtatExercice)
	{
		// Si l'état d'exercice est valide on renvoi son ID sinon on renvoie -1
		if (in_objEtatExercice != null && in_objEtatExercice.m_objEtatExercice != null)
			return in_objEtatExercice.m_objEtatExercice;
		else
			return null;
	}
	#endregion
 
	// Méthodes statiques
	#region Méthodes statiques
	// Internal
	/// <summary>
	/// <c>GetEtatExerciceByBO</c>
	/// Permet de retrouver un objet EtatExercice par le nom contenu
	/// dans un Business Object.
	/// </summary>
	/// <param name="in_objEtatBO">
	/// Le Business Object contenant le nom de l'état d'exercice à
	/// retrouver.
	/// </param>
	/// <returns>
	/// L'objet objet EtatExercice par le nom contenu dans un Business
	/// Object.
	/// </returns>
	public static EtatExercice GetEtatExerciceByBO(EtatBO in_objEtatBO)
	{
		// valeur de retour de la méthode
		EtatExercice l_objEtatExercice = null;
 
		// Récupération de l'état d'exercice par le nom stocké dans le BO
		if (in_objEtatBO != null)
			l_objEtatExercice = GetEtatExerciceByString(in_objEtatBO.Nom);
 
		// Retour de la méthode
		return l_objEtatExercice;
	}
 
	/// <summary>
	/// <c>GetEtatMachineByString</c>
	/// Permet de retrouver un objet EtatExercice par son nom.
	/// </summary>
	/// <param name="in_sNomEtat">
	/// Le nom de l'état</param>
	/// <returns></returns>
	public static EtatExercice GetEtatExerciceByString(string in_sNomEtat)
	{
		// Valeur de retour de la méthode
		EtatExercice l_objEtatExercice = null;
 
		// Récupération de l'état d'exercice à partir de son nom
		if (!string.IsNullOrEmpty(in_sNomEtat))
			s_listEtatExercice.TryGetValue(in_sNomEtat, out l_objEtatExercice);
 
		// Retour de la méthode
		return l_objEtatExercice;
	}
	#endregion
}

[Skyounet]

On ne peut pas faire passer de champs static à travers WCF.

Ont-ils vraiment besoin d'être static readonly ?

Pourquoi tu fais pas simplement une méthode dans ton WCF qui retourne tes constantes ?

Du genre

Code c# :

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

1
2
3
4
public EtatExercice GetCreated()
{
   return EtatExercice.Created;
}

Ou bien renvoyer toutes tes constantes d'un coup dans un Dictionary<string, EtatExercice> avec string qui vaudrait "Created", "Prepared"...

[OminiuS]

Je voulais les charger une fois pour toute une seule fois pour limiter les appels WCF!

[Skyounet]

Je voulais les charger une fois pour toute une seule fois pour limiter les appels WCF!

Et bien fais une méthodes GetConstantes qui retourne un Dictionary<string, EtatExercice>

Code c# :

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

1
2
3
4
5
6
7
8
public Dictionary<string, EtatExercice> GetConstantes()
{
   var dictionary = new Dictionary<string, EtatExercice>();
   dictionary.Add("Created", EtatExercice.Created);
   dictionary.Add("Prepared". EtatExercice.Prepared);
   ...
   return dictionary;
}

[OminiuS]

Je crois que c'est ce que je vais retenir!

Merci