L'incorporation de Dll dans un fichier exécutable compilé

Si elles sont en fait gérés assemblées, vous pouvez utiliser ILMerge. Pour Dll natives, vous aurez un peu plus de travail à faire.

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

OriginalL'auteur Shog9

Oui, il est possible de fusionner .NET des exécutables avec les bibliothèques. Il existe plusieurs outils disponibles pour faire le travail:

• ILMerge est un utilitaire qui peut être utilisé pour fusionner plusieurs .NET assemblées en une seule assemblée.
• Mono mkbundle, les paquets un exe et tous les assemblys avec libmono dans un seul paquet binaire.
• IL-Repack est une SOIE alterantive à ILMerge, avec quelques fonctionnalités supplémentaires.

En outre, ce peut être combiné avec le Mono Éditeur De Liens, qui supprime inutilement du code et à cet effet transforme l'assemblée petits.

Une autre possibilité est d'utiliser .NETZ, ce qui ne permet pas seulement la compression d'une assemblée, mais aussi pouvez le pack dll directement dans le fichier exe. La différence avec les solutions mentionnées ci-dessus, c'est que .NETZ ne pas les fusionner, ils restent assemblées distinctes, mais sont emballés dans un seul paquet.

.NETZ est un outil open source qui les comprime et les packs Microsoft .NET Framework exécutable (EXE, DLL) des fichiers afin de les rendre plus petits.

OriginalL'auteur Bobby

La extrait de Jeffrey Richter est très bon. En bref, l'ajout de la bibliothèque est aussi intégré des ressources et ajouter un rappel avant toute autre chose. Voici une version du code (qui se trouve dans les commentaires de sa page) que j'ai mis au début de la Principale méthode pour une application console (assurez-vous que tous les appels qui utilisent la bibliothèque sont dans une méthode différente pour Principal).

AppDomain.CurrentDomain.AssemblyResolve += (sender, bargs) =>
        {
            String dllName = new AssemblyName(bargs.Name).Name + ".dll";
            var assem = Assembly.GetExecutingAssembly();
            String resourceName = assem.GetManifestResourceNames().FirstOrDefault(rn => rn.EndsWith(dllName));
            if (resourceName == null) return null; //Not found, maybe another handler will find it
            using (var stream = assem.GetManifestResourceStream(resourceName))
            {
                Byte[] assemblyData = new Byte[stream.Length];
                stream.Read(assemblyData, 0, assemblyData.Length);
                return Assembly.Load(assemblyData);
            }
        };

OriginalL'auteur Steve

Vérifier boxedapp

Il peut intégrer une dll dans n'importe quelle application. Écrit en C# aussi, bien sûr 🙂

Espère que cela aide.

OriginalL'auteur

Je vous recommande de vérifier la .NETZ utilitaire, qui compresse également l'assemblée avec un schéma de votre choix:

http://madebits.com/netz/help.php#single

OriginalL'auteur Nathan Baulch

Ni le ILMerge approche ni Lars Holm Jensen de la gestion de l'événement AssemblyResolve de travail pour un plugin d'accueil. Dire exécutable H des charges de l'assemblée P de façon dynamique et accède via l'interface IP définie dans un ensemble distinct. Pour intégrer IP en H on besoin d'un peu de modification de Lars code:

Dictionary<string, Assembly> loaded = new Dictionary<string,Assembly>();
AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
{   Assembly resAssembly;
    string dllName = args.Name.Contains(",") ? args.Name.Substring(0, args.Name.IndexOf(',')) : args.Name.Replace(".dll","");
    dllName = dllName.Replace(".", "_");
    if ( !loaded.ContainsKey( dllName ) )
    {   if (dllName.EndsWith("_resources")) return null;
        System.Resources.ResourceManager rm = new System.Resources.ResourceManager(GetType().Namespace + ".Properties.Resources", System.Reflection.Assembly.GetExecutingAssembly());
        byte[] bytes = (byte[])rm.GetObject(dllName);
        resAssembly = System.Reflection.Assembly.Load(bytes);
        loaded.Add(dllName, resAssembly);
    }
    else
    {   resAssembly = loaded[dllName];  }
    return resAssembly;
};  

Le truc pour gérer répété des tentatives de résolution de la même assemblée et le retour à l'existant au lieu de créer une nouvelle instance.

EDIT:
De peur de gâcher .NET de la sérialisation, assurez-vous de retourner la valeur null pour toutes les assemblées qui ne sont pas intégrées dans le vôtre, ainsi défaut la norme de comportement. Vous pouvez obtenir une liste de ces bibliothèques par:

static HashSet<string> IncludedAssemblies = new HashSet<string>();
string[] resources = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceNames();
for(int i = 0; i < resources.Length; i++)
{   IncludedAssemblies.Add(resources[i]);  }

et il suffit de retourner la valeur null si l'assemblée n'appartient pas à IncludedAssemblies .

OriginalL'auteur Ant_222

Outre ILMerge, si vous ne voulez pas vous embêter avec les commutateurs de ligne de commande, je recommande vraiment ILMerge-Gui. C'est un projet open source, vraiment bon!!!

OriginalL'auteur tyron

- Je utiliser l'csc.exe compilateur appelé à partir d'un .script vbs.

Dans votre xyz.cs script, ajoutez les lignes suivantes après les directives (mon exemple est pour le Renci SSH):

using System;
using Renci;//FOR THE SSH
using System.Net;//FOR THE ADDRESS TRANSLATION
using System.Reflection;//FOR THE Assembly

//+ref>"C:\Program Files (x86)\Microsoft\ILMerge\Renci.SshNet.dll"
//+res>"C:\Program Files (x86)\Microsoft\ILMerge\Renci.SshNet.dll"
//+ico>"C:\Program Files (x86)\Microsoft CAPICOM 2.1.0.2 SDK\Samples\c_sharp\xmldsig\resources\Traffic.ico"

La ref, res et ico balises seront repris par la .vbs script ci-dessous pour former le scc commande.

Puis ajoutez l'assemblée de résolution appelant à la Main:

public static void Main(string[] args)
{
    AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
    .

...et ajouter le résolveur de lui-même quelque part dans la classe:

 statique de l'Assemblée CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) 
{ 
Chaîne resourceName = new AssemblyName(args.Nom).Nom + ".dll"; 

en utilisant (var stream = Assemblée.GetExecutingAssembly().GetManifestResourceStream(resourceName)) 
{ 
Byte[] assemblyData = new Byte[stream.Longueur]; 
flux de données.Lire(assemblyData, 0, assemblyData.La longueur); 
de retour de l'Assemblée.Charge(assemblyData); 
} 

} 

J'ai le nom du script vbs pour correspondre à la .cs nom de fichier (par exemple ssh.vbs recherche ssh.cs), ce qui rend l'exécution du script de nombreuses fois beaucoup plus facile, mais si vous n'êtes pas un idiot comme moi, alors un script générique pourrait ramasser la cible .cs fichier à partir d'un drag-and-drop:

 Dim name_,oShell,fso 
Set oShell = CreateObject("Shell.L'Application") 
Set fso = CreateObject("Scripting.fileSystemObject") 

"PRENDRE LE SCRIPT VBS NOM QUE LE NOM DE FICHIER CIBLE 
'################################################ 
name_ = Split(wscript.ScriptName, ".")(0) 

'OBTENIR LA DLL EXTERNE ET les NOMS d'icônes DE LA .CS FICHIER 
'####################################################### 
Const OPEN_FILE_FOR_READING = 1 
Ensemble objInputFile = fso.OpenTextFile(name_ & ".cs", 1) 

"LIRE LE TOUT DANS UN TABLEAU 
'############################# 
inputData = Split(objInputFile.ReadAll, vbNewline) 

Pour chaque strData Dans inputData 

si la gauche(strData,7)="//+ref>" alors 
csc_references = csc_references & " /la référence:" & trim(remplacer(strData,"//+ref>","")) & "" 
fin de si 

si la gauche(strData,7)="//+res>" alors 
csc_resources = csc_resources & " /ressource:" & trim(remplacer(strData,"//+res>","")) & "" 
fin de si 

si la gauche(strData,7)="//+ico>" alors 
csc_icon = " /win32icon:" & trim(remplacer(strData,"//+ico>","")) & "" 
fin de si 
Prochaine 

objInputFile.Fermer 


'COMPILER LE FICHIER 
'################ 
oShell.ShellExecute "c:\windows\microsoft.net\framework\v3.5\csc.exe", "/avertir:1 /cible:exe", & csc_references & csc_resources & csc_icon & "" & name_ & ".cs", "", "runas", 2 


WScript.Quitter(0) 

OriginalL'auteur Mark Llewellyn

Généralement vous aurez besoin d'une certaine forme de post-construction de l'outil pour effectuer une assemblée de fusion comme vous le décrivez. Il est un outil gratuit appelé Eazfuscator (eazfuscator.blogspot.com/) qui est conçu pour le bytecode d'amputation qui gère également l'assemblée de la fusion. Vous pouvez ajouter ce dans un poste de construire la ligne de commande avec Visual Studio pour fusionner vos assemblées, mais votre kilométrage peut varier en raison des questions qui se posent dans toutes les trival assemblée fusion des scénarios.

Vous pouvez également vérifier pour voir si la construction de rendre untility NANT a la capacité de fusionner des assemblées après la construction du bâtiment, mais je ne suis pas assez familier avec NANT me dire si la fonctionnalité est intégrée ou non.

Il y a aussi beaucoup beaucoup de Visual Studio plugins qui vont effectuer assemblée de fusion dans le cadre de la construction de l'application.

Sinon, si vous n'avez pas besoin de le faire automatiquement, il y a un certain nombre d'outils comme ILMerge qui vont fusionner .net assemblées dans un seul fichier.

Le plus grand problème que j'ai eu avec la fusion des assemblées est de savoir si ils utilisent tout semblable espaces de noms. Ou pire, de référence à des versions différentes de la même dll (mes problèmes étaient généralement avec la NUnit fichiers dll).

OriginalL'auteur wllmsaccnt