Compiler dynamiquement une classe dans le Code App tout en pré-compilant le reste du Projet / Bibliothèque

Aperçu Des Problèmes

nous devons surmonter deux problèmes différents ici:

1. la première est d'avoir un fichier unique qui peut être compilé au moment de la compilation et aussi recompilé au moment de l'exécution.
2. la seconde est de résoudre les deux versions différentes de cette classe créée par la résolution du premier problème afin que nous puissions réellement les utiliser.

Problème 1-Compilation de Schrödinger

Le premier problème est essayer d'obtenir une classe qui est à la fois compilé et non pas compilé. Nous avons besoin de le compiler au moment de la conception afin que les autres sections de code soient au courant de son existence et puissent utiliser ses propriétés avec un fort typage. Mais normalement, le code compilé est retiré de la sortie de sorte qu'il n'y a pas plusieurs versions de la même classe provoquant des conflits de noms.

Dans tous les cas, nous besoin pour compiler la classe au départ, mais il y a deux options pour persister une re-compilable copie:

1. Ajouter le fichier à App_Code, qui est compilé à l'exécution par défaut, mais défini comme Build Action = Compiler donc, c'est au moment de la conception.
2. Ajouter une classe ordinaire de fichier, qui est compilé au moment de la conception par défaut, mais il Copier vers le Répertoire de Sortie = Copy, donc il y a une chance que nous puissions l'évaluer à l'exécution aussi bien.

problème 2 - DLL auto-imposée L'enfer

à tout le moins, c'est une tâche délicate à charger sur le compilateur. Tout code qui consomme une classe doit avoir une garantie qu'il existe au moment de la compilation. Tout ce qui est compilé dynamiquement, que ce soit via App_Code ou autrement, fera partie d'un assemblage entièrement différent. Donc, produire une classe identique est traité plus comme une image de cette classe. Le type sous-jacent pourrait être le même, mais ce n'est une pipe.

nous en avons deux options: utilisez une interface ou un passage entre les assemblages:

1. si nous utilisons un interface, nous pouvons le compiler avec la construction initiale et tous les types dynamiques peuvent implémenter cette même interface. De cette façon, nous comptons en toute sécurité sur quelque chose qui existe au moment de la compilation, et notre classe créée peut être échangée en toute sécurité comme propriété de sauvegarde.

2. Si nous types de coulée à travers les assemblages, c'est il est important de noter que toute utilisation existante dépend du type qui a été compilé à l'origine. Nous aurons donc besoin de saisir les valeurs du type dynamique et appliquer ces valeurs de propriété au type original.

Réponses Existantes

Par evk j'aime bien l'idée de l'interrogation AppDomain.CurrentDomain.GetAssemblies() au démarrage pour vérifier les nouvelles assemblées/classes. Je vais vous avouer que l'utilisation d'une interface est probablement une façon conseillée d'unifier les classes précompilées/compilées dynamiquement, mais j'aimerais idéalement avoir un seul fichier/classe qui puisse être simplement relu s'il change.

Par S. Deepika j'aime bien l'idée de compiler dynamiquement à partir d'un fichier, mais ne voulez pas avoir à déplacer les valeurs d'un projet distinct.

Décision App_Code

App_Code déverrouiller la possibilité de construire deux versions de la même classe, mais c'est effectivement dur de modifier soit un après publication comme nous le verrons. .cs le fichier situé dans ~ / App_Code / sera compilé dynamiquement lorsque l'application sera lancée. Ainsi, dans Visual Studio, nous pouvons construire la même classe deux fois en l'ajoutant à App_Code et en définissant le Action De ConstruireCompiler.

construisez Action et copiez Sortie:

quand nous déboguons localement, tout .les fichiers cs seront intégrés dans l'assemblage du projet et le fichier physique dans ~/App_Code sera également intégré.

Nous pouvons identifier deux types comme ceci:

// have to return as object (not T), because we have two different classes
public List<(Assembly asm, object instance, bool isDynamic)> FindLoadedTypes<T>()
{
    var matches = from asm in AppDomain.CurrentDomain.GetAssemblies()
                  from type in asm.GetTypes()
                  where type.FullName == typeof(T).FullName
                  select (asm,
                      instance: Activator.CreateInstance(type),
                      isDynamic: asm.GetCustomAttribute<GeneratedCodeAttribute>() != null);
    return matches.ToList();
}

var loadedTypes = FindLoadedTypes<Apple>();

types compilés et dynamiques:

C'est vraiment proche de la résolution le problème n ° 1. Nous avons accès aux deux types chaque fois que l'application fonctionne. Nous pouvons utiliser la version compilée au moment de la conception et tout changement au fichier lui-même sera automatiquement recompilé par IIS dans une version à laquelle nous pouvons accéder à l'exécution.

le problème est apparent cependant une fois que nous sortons du mode de débogage et essayons de publier le projet. Cette solution repose sur la construction par IIS de la App_Code.xxxx montage dynamique, et qui repose sur le .fichier cs se trouvant dans le dossier racine App_Code. Toutefois, lorsqu'un .cs le fichier est compilé, il est automatiquement retiré du projet publié, pour éviter le scénario exact que nous essayons de créer (et gérer délicatement). Si le fichier était laissé en place, il produirait deux classes identiques, ce qui créerait des conflits de noms chaque fois que l'une ou l'autre serait utilisée.

nous pouvons essayer de forcer sa main en compilant le fichier dans l'assemblage du projet et aussi en copiant le fichier dans le répertoire de sortie. Mais App_Code ne fonctionne pas tout ce qui est magique à l'intérieur de ~ / bin/App_Code/. Il ne fonctionnera qu'au niveau de la racine ~ / App_Code/

App_Code Compilation Source:

avec chaque publication, Nous pourrions couper et coller manuellement le dossier App_Code généré à partir de la corbeille et le replacer au niveau de la racine, mais c'est au mieux précaire. Peut-être pourrions-nous automatiser cela pour construire des événements, mais nous essaierons quelque chose autre...

Solution

compiler + (Copier vers la sortie et compiler manuellement le fichier)

évitons le dossier App_Code car il ajoutera des conséquences involontaires.

il suffit de créer un nouveau dossier nommé Config et ajouter une classe qui stockera les valeurs que nous voulons pouvoir modifier dynamiquement:

~/Config/AppleValues.cs:

public class Apple
{
    public string StemColor { get; set; } = "Brown";
    public string LeafColor { get; set; } = "Green";
    public string BodyColor { get; set; } = "Red";
}

encore une fois, nous voulons aller aux propriétés du fichier ( F4) et configuré pour compiler et copie à la sortie. Cela nous donnera une deuxième version du fichier que nous pourrons utiliser plus tard.

nous consommerons cette classe en l'utilisant dans une classe statique qui expose les valeurs de n'importe où. Cela permet de séparer les préoccupations, en particulier entre la nécessité de compiler dynamiquement et statiquement accès.

~/Config/GlobalConfig.cs:

public static class Global
{
    // static constructor
    static Global()
    {
        // sub out static property value
        // TODO magic happens here - read in file, compile, and assign new values
        Apple = new Apple();
    }

    public static Apple Apple { get; set; }
}

et nous pouvons l'utiliser comme ceci:

var x = Global.Apple.BodyColor;

ce que nous tenterons de faire à l'intérieur du constructeur statique, c'est seed Apple avec les valeurs de notre classe dynamique. Cette méthode sera appelée une fois chaque fois que l'application est redémarrée, et toute modification au dossier bin déclenche automatiquement le recyclage du pool d'applications.

En bref, voici ce que nous voulons accomplir à l'intérieur de l'constructeur:

string fileName = HostingEnvironment.MapPath("~/bin/Config/AppleValues.cs");
var dynamicAsm = Utilities.BuildFileIntoAssembly(fileName);
var dynamicApple = Utilities.GetTypeFromAssembly(dynamicAsm, typeof(Apple).FullName);
var precompApple = new Apple();
var updatedApple = Utilities.CopyProperties(dynamicApple, precompApple);

// set static property
Apple = updatedApple;

fileName - le chemin du fichier peut être spécifique à l'endroit où vous comme pour la déployer, mais note qu'à l'intérieur d'une méthode statique, vous devez utiliser HostingEnvironment.MapPath au lieu de Server.MapPath

BuildFileIntoAssembly - en termes de chargement de l'assemblage à partir d'un fichier, j'ai adapté le code des docs sur CSharpCodeProvider et cette question sur Comment charger une classe à partir d'une .fichier cs. Aussi, plutôt que de combattre les dépendances, j'ai juste donné le accès du compilateur à tous les assemblages qui se trouvaient actuellement dans le domaine de L'application, comme sur la compilation originale. Il y a probablement un moyen de le faire avec moins de frais généraux, mais c'est un coût unique qui s'en soucie.

CopyProperties - pour mapper les nouvelles propriétés sur l'ancien objet, j'ai adapté la méthode dans cette question sur comment appliquer automatiquement des valeurs de propriétés d'un objet à un autre du même type? qui utilise la réflexion pour décomposer les deux objets et itérer sur chaque propriété.

Utilitaires.cs

voici le code source complet pour les méthodes Utility d'en haut

public static class Utilities
{

    /// <summary>
    /// Build File Into Assembly
    /// </summary>
    /// <param name="sourceName"></param>
    /// <returns>https://msdn.microsoft.com/en-us/library/microsoft.csharp.csharpcodeprovider.aspx</returns>
    public static Assembly BuildFileIntoAssembly(String fileName)
    {
        if (!File.Exists(fileName))
            throw new FileNotFoundException($"File '{fileName}' does not exist");

        // Select the code provider based on the input file extension
        FileInfo sourceFile = new FileInfo(fileName);
        string providerName = sourceFile.Extension.ToUpper() == ".CS" ? "CSharp" :
                              sourceFile.Extension.ToUpper() == ".VB" ? "VisualBasic" : "";

        if (providerName == "")
            throw new ArgumentException("Source file must have a .cs or .vb extension");

        CodeDomProvider provider = CodeDomProvider.CreateProvider(providerName);

        CompilerParameters cp = new CompilerParameters();

        // just add every currently loaded assembly:
        // https://stackoverflow.com/a/1020547/1366033
        var assemblies = from asm in AppDomain.CurrentDomain.GetAssemblies()
                         where !asm.IsDynamic
                         select asm.Location;
        cp.ReferencedAssemblies.AddRange(assemblies.ToArray());

        cp.GenerateExecutable = false; // Generate a class library
        cp.GenerateInMemory = true; // Don't Save the assembly as a physical file.
        cp.TreatWarningsAsErrors = false; // Set whether to treat all warnings as errors.

        // Invoke compilation of the source file.
        CompilerResults cr = provider.CompileAssemblyFromFile(cp, fileName);

        if (cr.Errors.Count > 0)
            throw new Exception("Errors compiling {0}. " +
                string.Join(";", cr.Errors.Cast<CompilerError>().Select(x => x.ToString())));

        return cr.CompiledAssembly;
    }

    // have to use FullName not full equality because different classes that look the same
    public static object GetTypeFromAssembly(Assembly asm, String typeName)
    {
        var inst = from type in asm.GetTypes()
                   where type.FullName == typeName
                   select Activator.CreateInstance(type);
        return inst.First();
    }


    /// <summary>
    /// Extension for 'Object' that copies the properties to a destination object.
    /// </summary>
    /// <param name="source">The source</param>
    /// <param name="target">The target</param>
    /// <remarks>
    /// https://stackoverflow.com/q/930433/1366033
    /// </remarks>
    public static T2 CopyProperties<T1, T2>(T1 source, T2 target)
    {
        // If any this null throw an exception
        if (source == null || target == null)
            throw new ArgumentNullException("Source or/and Destination Objects are null");

        // Getting the Types of the objects
        Type typeTar = target.GetType();
        Type typeSrc = source.GetType();

        // Collect all the valid properties to map
        var results = from srcProp in typeSrc.GetProperties()
                      let targetProperty = typeTar.GetProperty(srcProp.Name)
                      where srcProp.CanRead
                         && targetProperty != null
                         && (targetProperty.GetSetMethod(true) != null && !targetProperty.GetSetMethod(true).IsPrivate)
                         && (targetProperty.GetSetMethod().Attributes & MethodAttributes.Static) == 0
                         && targetProperty.PropertyType.IsAssignableFrom(srcProp.PropertyType)
                      select (sourceProperty: srcProp, targetProperty: targetProperty);

        //map the properties
        foreach (var props in results)
        {
            props.targetProperty.SetValue(target, props.sourceProperty.GetValue(source, null), null);
        }

        return target;
    }

}

Mais Pourquoi Donc?

D'accord, il y a donc d'autres façons plus conventionnelles d'atteindre le même objectif. Idéalement,on tirerait pour la Configuration de la Convention. Mais cela fournit le moyen le plus facile, le plus flexible, fortement dactylographié pour stocker les valeurs de configuration que j'ai jamais vu.

normalement les valeurs de configuration sont lues via un XML dans un processus tout aussi étrange qui repose sur des chaînes magiques et une faible Dactylographie. Nous devons appeler MapPath pour accéder à la mémoire de valeur et ensuite faire le mappage relationnel objet de XML à C#. Au lieu de cela, nous avons le type final à partir du début, et nous pouvons automatiser tout le travail ORM entre des classes identiques qui se trouvent juste être compilées contre différentes assemblées.

dans les deux cas, la sortie de rêve de ce processus est d'être capable d'écrire et de consommer C# directement. Dans ce cas, si je voulez ajouter un supplément, entièrement paramétrables, des biens, c'est aussi simple que l'ajout d'une propriété à la classe. Fait!

il sera disponible immédiatement et se recompilera automatiquement si cette valeur change sans avoir besoin de publier une nouvelle version de l'application.

L'Évolution Dynamique De La Classe Demo:

voici le code source complet du projet:

Configuration Compilée - Github Source Code/

Download Link