Partager les énumérations entre C# et Javascript MVC, Razor

Une autre méthode que j'ai utilisé avant est d'utiliser des modèles t4 pour faire ce genre de travail. De la même manière que t4mvc fonctionne, qui peut être un outil très puissant si vous savez comment l'utiliser.

L'idée est dans l't4template vous ramper à travers votre projet et recherchez les énumérations, quand il en trouve un, vous aurez envie de modèle pour le transformer et de cracher un peu de javascript basé sur le code C#. La première fois j'ai travaillé avec T4Templates à travers, il a explosé de mon esprit, et il n'y a pas un grand nombre de ressources pour eux, mais ils peuvent être exceptionnel (voir t4mvc)

L'avantage de l'utilisation de modèles de plus de contrôleur de l'action utilisée dans l'autre question que vous avez lié, est-ce que le fichier généré par le t4 moteur de template est la sortie régulière d'un fichier js et peut être servi/minimisé comme n'importe quel autre fichier JavaScript, plutôt que d'exiger des frais indirects de la MVC pile de satisfaire la demande.

Je pourrais probablement creuser un exemple si vous êtes intéressé. Je n'ai probablement pas autour de la pose dans un référentiel somwhere.

Modifier

Alors j'ai creusé autour et a trouvé un exemple, j'ai édité un peu de sa forme initiale et en ne l'ai pas tester, mais vous devriez obtenir l'idée. C'est un peu long, donc j'ai fait une github gist. Mais je vais mettre en évidence certains des pans importants ici.

D'abord, Les modèles de T4 sont un moteur de template intégré de Visual Studio, les blocs de contrôle sont écrits en C# (ou VB si vous le souhaitez). Je ne suis pas d'imagination un expert, et ne prétends pas être un, mais je vais partager ce que je peux. Si ces fichiers, une fois dans un projet visual studio ressembler à d'autres "code-behind" types d'éléments, où vous pouvez étendre la .tt point et de voir le modèle généré fichier derrière elle.

Donc permet de creuser dans:

<#@ template language="C#v3.5" debug="true" hostspecific="true" #>

La première ligne définit la langue pour les blocs de contrôle. Comme vous pouvez le voir, je vais être à l'aide de C#.

<#@ output extension=".js" #>

Prochaine, je suis l'extension du fichier généré. Dans ce cas, je dis que je veux générer un .js fichier. Alors quand j'ai placer ce modèle dans une solution, permet comme enum.tt, quand je lance le modèle, il va créer un fichier appelé enum.js. Vous avez le contrôle sur le fichier (ou les fichiers) qui sont générés. Par exemple, t4mvc a la possibilité d'être en mesure de générer un tas de fichiers différents (un pour chaque contrôleur) ou de produire un seul t4mvc.cs fichier.

Ensuite, vous trouverez un tas de montages que j'ai besoin d'utiliser. Voici les plus intéressantes sont les suivantes:

<#@ assembly name="EnvDTE" #>
<#@ assembly name="EnvDTE80" #> 

Encore une fois, je ne suis pas un expert, mais vous pouvez trouver de la documentation sur le site msdn. Ceux ci fournissent des fonctionnalités de base pour être en mesure de manipuler la solution visual studio.

Ensuite, il ya assez inintéressant importations. Vous remarquerez que les blocs de contrôle sont délimités par des <# .. #> (pour être honnête, je n'ai pas vraiment souvenir de la signification de la prochaine caractère, son été un certain temps.) Tout ce qui n'est pas enveloppé dans un bloc de contrôle seront écrites directement sur le flux de sortie.

Qui nous amène au début du fichier sera écrit:

window.Enum = function() {
    this.__descriptions = [];
    this.__ids = []
    this.__last_value = 0;
}

window.Enum.prototype.add = function(name, val) {
    if(val == undefined) val = ++this.__last_value;
    this[name] = val;
    this[val] = name;
    this.__ids[val] = name;
    this.__descriptions[val] = name.replace(/ShowWithEllipses$/,"...").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^\s+/,"");
    return this;
}

window.Enum.prototype.describe = function(val) { return this.__descriptions[val] };

Ici, je suis juste une banale javascript Enum mise en œuvre. Ne demande pas à être le meilleur. Mais elle est ce qu'elle est. 🙂

<#
Prepare(this);
foreach(ProjectItem pi in FindProjectItemsIn(CurrentProject.ProjectItems.Item("Models"))) {
    DumpEnumerationsFrom(pi);
}
#>

Puis nous arrivons à la viande du modèle. Fondamentalement, il se regarde dans un dossier appelé Models. Et des fouilles autour et essaie de trouver tous les énumérations, il peut trouver. Quand il le fait, il appelle la méthode suivante:

void DumpEnumerationsFrom(ProjectItem file) {
    var enumerations = new List<CodeEnum>();
    FindEnum(file.FileCodeModel.CodeElements, enumerations);

    if(enumerations.Count > 0) TT.WriteLine("//{0}",file.Name);

    foreach(CodeEnum enumeration in enumerations) {
        TT.Write("window.Enum.{0}=(new Enum())", enumeration.Name);
        foreach(CodeElement ce in enumeration.Children) {
            var cv = ce as CodeVariable;
            if(cv == null) continue;
            TT.Write("\r\n\t.add(\"{0}\", {1})", cv.Name, cv.InitExpression ?? "undefined");
        }
        TT.WriteLine(";\r\n");
    }
}

où il va générer quelque chose qui ressemble à:

window.Enum.TheNameOfTheEnum = (new Enum()).add("Value1",1).add("Value2",2);

De sorte que le montant fichier JS est basé directement sur les énumérations dans votre projet c#.

Il y a certaines limites cependant. On l'énumération doit être dans un fichier qui se trouve dans votre projet (non référencé à la bibliothèque, au moins à l'aide de cette mise en œuvre, il pourrait y avoir un moyen plus malin à faire. Chaque fois que vous changez d'énumérations, vous devez exécuter de nouveau le modèle (clic-droit dessus et sélectionnez "Exécuter l'Outil Personnalisé").

Mais il ya certains avantages, comme je l'ai mentionné avant, le fichier résultant est juste un simple fichier js, donc peut être combiné et courir à travers minification. Parce que c'est juste un fichier, il peut être hébergé sur un CDN, et comme je l'ai mentionné avant ne nécessite pas un coup à la MVC pile de répondre à la requête.

De toute façon, je ne dis pas que c'est la meilleure idée pour toutes les fins, mais un sous-utilisés approche, à mon avis. J'espère que cela peut avoir contribué à faire la lumière et donner une direction en charge de l'enquête.

La conversion à Dictionary pour enum est juste un peu différente.

public ActionResult DayOfWeekEnum()
{
    var enumType = typeof(DayOfWeek);
    var enumDictionary = enumType
        .GetFields()
        .Where(x => x.IsLiteral)
        .ToDictionary(x => x.Name, x => (int)Enum.Parse(enumType, x.Name));
    var json = new JavaScriptSerializer().Serialize(enumDictionary);
    return JavaScript("var DayOfWeek = " + json + ";");
}

Vous pourriez prendre un peu plus loin et passer dans l'espace de noms de la enum et utiliser la réflexion pour trouver le type. Cela permettrait d'être plus générique de la méthode d'action.

ActionResult Enum(string enumType)