Constantes de partage entre C# et Javascript dans MVC Razor
j'aimerais utiliser les constantes de chaîne des deux côtés, en C# sur le serveur et en Javascript sur le client. Je encapsuler mon constantes dans la classe de C#
namespace MyModel
{
public static class Constants
{
public const string T_URL = "url";
public const string T_TEXT = "text";
. . .
}
}
j'ai trouvé un moyen d'utiliser ces constantes en Javascript en utilisant la syntaxe Razor, mais ça me semble bizarre:
@using MyModel
<script type="text/javascript">
var T_URL = '@Constants.T_URL';
var T_TEXT = '@Constants.T_TEXT';
. . .
var selValue = $('select#idTagType').val();
if (selValue == T_TEXT) { ...
y a-t-il une autre façon "élégante" de partager les constantes entre C# et Javascript? (Ou du moins plus automatique, donc je n'ai pas à faire de changements dans deux fichiers)
4 réponses
la façon dont vous l'utilisez est dangereuse. Imaginez que certaines de vos constantes contiennent une citation, ou pire encore certains autres caractères dangereux => qui briseraient vos javascripts.
je vous recommande la rédaction d'un contrôleur d'action qui servira à toutes les constantes comme javascript:
public ActionResult Constants()
{
var constants = typeof(Constants)
.GetFields()
.ToDictionary(x => x.Name, x => x.GetValue(null));
var json = new JavaScriptSerializer().Serialize(constants);
return JavaScript("var constants = " + json + ";");
}
puis, dans votre mise en page de référence de ce script:
<script type="text/javascript" src="@Url.Action("Constants")"></script>
maintenant, chaque fois que vous avez besoin d'une constante dans vos scripts, utilisez-la simplement par son nom:
<script type="text/javascript">
alert(constants.T_URL);
</script>
Vous pouvez utiliser un helper HTML pour afficher le script nécessaire, et utiliser la réflexion pour saisir les champs et leurs valeurs afin qu'il soit automatiquement mis à jour.
public static HtmlString GetConstants(this HtmlHelper helper)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.AppendLine("<script type=\"text/javascript\">");
foreach (var prop in typeof(Constants).GetFields())
{
sb.AppendLine(string.Format(" var {0} = '{1}'", prop.Name, prop.GetValue(null).ToString()));
}
sb.AppendLine("</script>");
return new HtmlString(sb.ToString());
}
Ma version pour créer un espace de noms d'objet javascript à partir de mon C# constantes qui est immuable:
public static HtmlString GetConstants<T>()
{
StringBuilder jsConstant = new StringBuilder();
jsConstant.Append("myApp." + typeof(T).Name + " = Object.freeze({");
foreach(var item in typeof(T).GetFields())
{
jsConstant.Append(string.Format("{0}:'{1}'",item.Name,item.GetValue(null).ToString()) + ",");
}
jsConstant.Remove(jsConstant.Length - 1, 1);
jsConstant.Append("})");
return new HtmlString(jsConstant.ToString());
}
Utilisé comme ceci dans Razor:
@(HtmlHelpers.GetConstants<MyApp.Infrastructure.ApplicationConstants.SomeConstants>())
plutôt que de stocker vos données constantes dans une Classe C#, stockez-les dans un fichier de configuration/constantes statique.
// Constants.json
{
"T_URL": "url",
"T_TEXT": "text"
}
// Constants.cs
// load the json from a file stream into a constants object
// Constants.js
window.Constants = $.getJSON(url);
il suffit de le stocker dans un format de fichier (json, xml, cvs, etc.) puis de le charger à partir du client et du serveur.
cela signifie soit que vous créez une classe dans le C# à la volée à l'exécution en utilisant la réflexion de la magie noire ou tout simplement avoir un hashtable / dictionnaire contenant vos constantes sous les clés.