Comment pouvez-C++ pour windows dll être fusionnées dans une application C# exe?

Assemblée unique de Déploiement de la gestion et du Code non managé
Dimanche 4 Février 2007

.NET les développeurs aiment le déploiement XCOPY. Et ils l'amour seul l'assemblage des composants. Au moins je me sens toujours un peu mal à l'aise, si je dois utiliser certains composant et ont besoin de se rappeler une liste de fichiers à inclure avec les principaux de l'assemblée de la composante. Alors, quand j'ai récemment eu à développer un code géré composant et a dû augmenter avec un peu de code non géré à partir d'une DLL C (merci à Marcus Heege pour m'aider avec ça!), J'ai pensé à la façon de le rendre plus facile à déployer les deux Dll. Si c'était juste deux assemblées, je pourrais avoir utilisé ILmerge de les emballer dans un seul fichier. Mais cela ne fonctionne pas pour les composants de code avec la gestion ainsi que des Dll non managées.

Heres ce que j'ai trouvé une solution:

Je comprendre ce que les Dll je veux déployer mes composants principaux de l'assemblée en tant que ressources intégrées.
Puis-je configurer un constructeur de classe pour extraire ces Dll comme ci-dessous. La classe ctor est appelé qu'une fois à l'intérieur de chaque domaine d'application de sorte que son une négligeable des frais généraux, je pense.

namespace MyLib
{
    public class MyClass
    {
        static MyClass()
        {
            ResourceExtractor.ExtractResourceToFile("MyLib.ManagedService.dll", "managedservice.dll");
            ResourceExtractor.ExtractResourceToFile("MyLib.UnmanagedService.dll", "unmanagedservice.dll");
        }

        ...

Dans cet exemple, j'ai inclus deux Dll en tant que ressources, l'un étant un code non managé DLL, et l'une étant une DLL de code managé (juste pour les besoins de la démonstration), afin de montrer, comment cette technique fonctionne pour les deux types de code.

Le code pour extraire les Dll dans des fichiers de leur propre est simple:

public static class ResourceExtractor
{
    public static void ExtractResourceToFile(string resourceName, string filename)
    {
        if (!System.IO.File.Exists(filename))
            using (System.IO.Stream s = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName))
                using (System.IO.FileStream fs = new System.IO.FileStream(filename, System.IO.FileMode.Create))
                {
                    byte[] b = new byte[s.Length];
                    s.Read(b, 0, b.Length);
                    fs.Write(b, 0, b.Length);
                }
    }
}

De travail avec un code géré assemblée, comme c'est la même que d'habitude - ou presque. Que vous y faites référence (ici: ManagedService.dll) dans vos composants principaux du projet (ici: MyLib), mais la Copie Locale de la propriété à false. En outre, vous lien dans l'assemblée comme un Élément Existant et de définir l'Action de Construire Ressource Incorporée.

Pour le code non managé (ici: UnmanagedService.dll) vous venez de lien dans le DLL comme un Élément Existant et de définir l'Action de Construire Ressource Incorporée. Pour avoir accès à ses fonctions d'utiliser l'attribut DllImport comme d'habitude, par exemple

[DllImport("unmanagedservice.dll")] public extern static int Add(int a, int b);

C'est tout! Dès que vous créez la première instance de la classe avec la statique ctor l'embedded Dll obtenir extrait dans des fichiers qui leur est propre et sont prêts à utiliser que si vous avez déployé sous forme de fichiers séparés. Aussi longtemps que vous avez les droits d'écriture pour le dossier d'exécution du présent devrait bien fonctionner pour vous. Au moins pour le prototype de code je pense que cette façon de l'assemblée unique de déploiement est très pratique.

Profitez-en!

http://weblogs.asp.net/ralfw/archive/2007/02/04/single-assembly-deployment-of-managed-and-unmanaged-code.aspx

Utilisation Fody.Costura nuget

1. Ouvrir votre solution -> Projet -> Gérer les Packages Nuget
2. De recherche pour Fody.Costura
3. Compiler votre projet.

Que c'est !

Source:
http://www.manuelmeyer.net/2016/01/net-power-tip-10-merging-assemblies/

Avez-vous essayé ILMerge? http://research.microsoft.com/~mbarnett/ILMerge.aspx

ILMerge est un utilitaire qui peut être utilisé pour fusionner plusieurs .NET assemblées en une seule assemblée. Il est disponible gratuitement pour une utilisation de l'Outils & Utilitaires de la page sur le Microsoft .NET Framework Developer Center.

Si vous êtes la construction de la DLL C++ avec la /clr drapeau (en tout ou en partie C++/CLI), alors il devrait fonctionner:

ilmerge /out:Composite.exe MyMainApp.exe Utility.dll

Il ne fonctionnera pas avec un ordinaire (native) DLL de Windows cependant.

Smart Assemblée pouvez faire cela et plus encore. Si votre fichier dll a du code non managé, il ne vous laissera pas fusionner les dll à une assemblée unique, mais au contraire de les intégrer les dépendances nécessaires comme des ressources pour votre programme principal. Son flip-côté, ce n'est pas gratuit.

Vous pouvez le faire manuellement en intégrant dll à vos ressources et ensuite, en s'appuyant sur le domaine d'application de l'Assemblée ResolveHandler. Quand il s'agit de mode mixte dll, j'ai trouvé beaucoup de variantes et de saveurs de ResolveHandler approche ne fonctionne pas pour moi (tous qui lisez dll octets de la mémoire et de lire). Ils ont tous travaillé pour géré dll. Voici ce qui a fonctionné pour moi:

static void Main()
{
    AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
    {
        string assemblyName = new AssemblyName(args.Name).Name;
        if (assemblyName.EndsWith(".resources"))
            return null;

        string dllName = assemblyName + ".dll";
        string dllFullPath = Path.Combine(GetMyApplicationSpecificPath(), dllName);

        using (Stream s = Assembly.GetEntryAssembly().GetManifestResourceStream(typeof(Program).Namespace + ".Resources." + dllName))
        {
            byte[] data = new byte[stream.Length];
            s.Read(data, 0, data.Length);

            //or just byte[] data = new BinaryReader(s).ReadBytes((int)s.Length);

            File.WriteAllBytes(dllFullPath, data);
        }

        return Assembly.LoadFrom(dllFullPath);
    };
}

La clé ici est d'écrire les octets d'un fichier et de le charger à partir de son emplacement. Pour éviter l'oeuf et la poule problème, vous devez vous assurer que vous déclarez le gestionnaire avant d'accéder à l'assemblée, et que vous n'avez pas accès les membres de l'assemblée (ou instancier tout ce qui a affaire avec l'assemblée) à l'intérieur de chargement (assemblée de la résolution) de la partie. Prenez également le soin de s'assurer GetMyApplicationSpecificPath() n'est pas tout le répertoire temp depuis les fichiers temporaires pourrait être tenté d'obtenir effacée par d'autres programmes ou par vous-même (pas que ça sera effacé pendant que votre programme accède à la dll, mais au moins de ses nuisances. AppData est le bon endroit). Notez également que vous devez écrire les octets à chaque fois, tu ne peux pas le charger à partir d'un emplacement simplement parce que la dll y habite déjà.

Si l'assemblée est entièrement géré, vous pouvez voir ce lien ou cette quant à la façon de charger les dll.