Partager des constantes entre C# et Javascript MVC, Razor

Je voudrais utiliser des constantes de chaîne sur les deux côtés, en C# sur le serveur et en Javascript sur le client.
Je encapsuler mon constantes en C# class

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 il a l'air bizarre pour moi:

@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) { ...

Est-il plus "élégant" de partage des constantes entre C# et Javascript?
(Ou au moins plus automatique, donc je n'ai pas à faire des changements dans les deux fichiers)

  • C'est le meilleur moyen que j'ai trouvé. Êtes-vous envie de quelque chose qui va gratter le votre .fichiers cs pour public const string et automatiquement recréer ces valeurs comme var dans le javascript pour vous? Je ne peux pas imaginer que ce serait intrinsèquement utile tout le temps.
  • Un addendum à mon dernier commentaire. Je n'ai pas réussi à préavis, les présentes ont été constantes. Que, d'autre part, est utile.
InformationsquelleAutor VikVik | 2011-06-02
  1. 77

    La façon dont vous utilisez, il est dangereux. Imaginez certaines de vos constantes contenues un devis, ou pire encore, certains des caractères => ce serait briser votre 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 de la mise en page de référence de ce script:

    <script type="text/javascript" src="@Url.Action("Constants")"></script>

    Maintenant, chaque fois que vous besoin d'une constante dans vos scripts, vous utilisez simplement par son nom:

    <script type="text/javascript">
    alert(constants.T_URL);
</script>
    • Le fichier javascript de mise en cache côté client?
    • Pour chaque fichier JS que j'ai à faire cela? Et si je veux séparer des Constantes pour chaque JS/View ?
    • depuis le js est mis en cache sur le client, pourquoi s'en faire? Suffit de mettre votre constantes dans un seul script.
    • Et puis-je avoir une ressource en fonction de la constante pour le Multi-Langue front-end comme ceci: public static string centerButtonTitle = HeelpResources.MapCenterButtonTitle; ? centerButtonTitle est le label d'une carte google map qui est mis en javascript.
    • oui, bien sûr que vous le pouvez.
    • Ok merci, je pensais que a c'est du côté serveur, la dynamique de la langue de la ressource n'a pas été en mesure d'actualiser la valeur de la constante à présent dans le côté client
    • Excellente solution, mais être prudent que vous n'allez pas créer un fichier javascript qui contient les constantes non destinés à la consommation générale.
    • belle astuce! est-ce de travailler avec MVC de minification? Puisque ce n'est pas un fichier js que l'on peut définir dans un bundle, et les constantes de ce qui peut être utilisé dans les fichiers js qui sont spécifiés dans un bundle, il y aura un nom de variable d'incompatibilité?

    InformationsquelleAutor Darin Dimitrov
  2. 4

    Vous pouvez utiliser un helper HTML pour la sortie du script nécessaire, et utiliser la réflexion pour saisir les champs et leurs valeurs, de sorte qu'il sera automatiquement mise à 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());
    }
    InformationsquelleAutor Jay
  3. 1

    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 cela, dans de Rasoir:

    @(HtmlHelpers.GetConstants<MyApp.Infrastructure.ApplicationConstants.SomeConstants>())
    InformationsquelleAutor bigbadmad
  4. 0

    Plutôt que de stocker vos données constantes dans la classe de C#, de la stocker dans un statique config/fichier de constantes.

    //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);

    Simplement l'enregistrer dans un fichier de format (json, xml, cvs, peu importe) puis de le charger à partir à la fois de la client & serveur.

    Cela signifie que votre compte soit de la création d'une classe en C# à la volée lors de l'exécution à l'aide de la magie noire réflexion ou tout simplement avoir une table de hachage /dictionnaire contenant votre constantes sous les touches.

    jQuery.getJSON, JsonReaderWriterFactor

    • de près, mais pas assez près. Il a besoin de quelque chose pour utiliser la réflexion (plus ou moins) sur le serveur pour générer les choses pour le client.
    • où les constantes sont est arbitraire si, dans une classe ou dans un fichier. Je préfère les garder dans un fichier.
    • mais vous auriez encore à dupliquer les efforts pour maintenir .cs, .en json .js dans la synchronisation.
    • le .cs & .js sont statiques écrire une fois que les fichiers. Le .json est dynamique
    • Attendez, quoi? Prendre à chat.
    • Pourriez-vous élaborer sur la magie noire s'il vous plaît? C'est exactement ce que je suis en train de faire.
    • ce que jamais vous faites c'est une mauvaise idée.
    • Je suis en train de mettre en place un format unifié pour les constantes qui pourraient être utilisés dans plusieurs langues pour stocker les codes d'erreur. Idéalement, j'aimerais les avoir fortement typé pour C#, y aurait moyen de l'analyse du fichier JSON (probablement) et la création d'une DLL qui pourrait être utilisé dans mon application. Est-ce une mauvaise idée? Ce qui est une solution de rechange?

    InformationsquelleAutor Raynos