Menyematkan DLL dalam executable yang dikompilasi

Apakah mungkin untuk menanamkan DLL yang sudah ada ke dalam executable C # yang dikompilasi (sehingga Anda hanya memiliki satu file untuk didistribusikan)? Jika mungkin, bagaimana cara melakukannya?

Biasanya, saya keren dengan hanya meninggalkan DLL di luar dan memiliki program setup menangani semuanya, tetapi ada beberapa orang di tempat kerja yang bertanya kepada saya dan saya benar-benar tidak tahu.

Saya sangat merekomendasikan untuk menggunakan Costura.Fody - sejauh ini cara terbaik dan termudah untuk menanamkan sumber daya dalam perakitan Anda. Ini tersedia sebagai paket NuGet.

Install-Package Costura.Fody

Setelah menambahkannya ke proyek, itu akan secara otomatis menanamkan semua referensi yang disalin ke direktori output ke dalam perakitan utama Anda . Anda mungkin ingin membersihkan file yang disematkan dengan menambahkan target ke proyek Anda:

Install-CleanReferencesTarget

Anda juga dapat menentukan apakah akan menyertakan pdb, mengecualikan rakitan tertentu, atau mengekstraksi rakitan dengan cepat. Sejauh yang saya tahu, majelis yang tidak dikelola juga didukung.

Memperbarui

Saat ini, beberapa orang mencoba menambahkan dukungan untuk DNX .

Perbarui 2

Untuk versi Fody terbaru, Anda harus memiliki MSBuild 16 (jadi Visual Studio 2019). Fody versi 4.2.1 akan melakukan MSBuild 15. (referensi: Fody hanya didukung pada MSBuild 16 ke atas. Versi saat ini: 15 )

Cukup klik kanan proyek Anda di Visual Studio, pilih Properti Proyek -> Sumber Daya -> Tambahkan Sumber Daya -> Tambahkan File yang Ada ... Dan masukkan kode di bawah ini ke App.xaml.cs Anda atau yang setara.

public App()
{
    AppDomain.CurrentDomain.AssemblyResolve +=new ResolveEventHandler(CurrentDomain_AssemblyResolve);
}

System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
    string dllName = args.Name.Contains(',') ? args.Name.Substring(0, args.Name.IndexOf(',')) : args.Name.Replace(".dll","");

    dllName = dllName.Replace(".", "_");

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

    return System.Reflection.Assembly.Load(bytes);
}

Inilah posting blog asli saya: http://codeblog.larsholm.net/2011/06/embed-dlls-easily-in-a-net-assembly/

Jika mereka benar-benar dikelola rakitan, Anda dapat menggunakan ILMerge . Untuk DLL asli, Anda akan memiliki sedikit pekerjaan yang harus dilakukan.

Lihat juga: Bagaimana C ++ windows dll dapat digabungkan ke dalam aplikasi C # exe?

Ya, dimungkinkan untuk menggabungkan .NET yang dapat dieksekusi dengan perpustakaan. Ada beberapa alat yang tersedia untuk menyelesaikan pekerjaan:

• ILMerge adalah utilitas yang dapat digunakan untuk menggabungkan banyak rakitan .NET menjadi satu rakitan.
• Mono mkbundle , sebuah exe dan semua rakitan dengan libmono ke dalam satu paket biner.
• IL-Repack adalah alternatif FLOSS untuk ILMerge, dengan beberapa fitur tambahan.

Selain itu, ini dapat dikombinasikan dengan Mono Linker , yang menghapus kode yang tidak digunakan dan karenanya membuat perakitan yang dihasilkan lebih kecil.

Kemungkinan lain adalah dengan menggunakan .NETZ , yang tidak hanya memungkinkan kompres suatu rakitan, tetapi juga dapat mengemas dll langsung ke exe. Perbedaannya dengan solusi yang disebutkan di atas adalah bahwa. NETZ tidak menggabungkan mereka, mereka tetap rakitan terpisah tetapi dikemas dalam satu paket.

.NETZ adalah alat sumber terbuka yang mengompresi dan mengemas file Microsoft .NET Framework yang dapat dieksekusi (EXE, DLL) untuk membuatnya lebih kecil.

ILMerge dapat menggabungkan rakitan ke satu rakitan tunggal asalkan rakitan hanya memiliki kode yang dikelola. Anda dapat menggunakan aplikasi commandline, atau menambahkan referensi ke exe dan secara terprogram bergabung. Untuk versi GUI ada Eazfuscator , dan juga .Netz yang keduanya gratis. Aplikasi berbayar termasuk BoxedApp dan SmartAssembly .

Jika Anda harus menggabungkan rakitan dengan kode yang tidak dikelola, saya akan menyarankan SmartAssembly . Saya tidak pernah mengalami cegukan dengan SmartAssembly tetapi dengan yang lainnya. Di sini, ia dapat menanamkan dependensi yang diperlukan sebagai sumber daya ke exe utama Anda.

Anda dapat melakukan semua ini secara manual tidak perlu khawatir jika perakitan dikelola atau dalam mode campuran dengan menyematkan dll ke sumber daya Anda dan kemudian mengandalkan Majelis AppDomain ResolveHandler. Ini adalah solusi satu atap dengan mengadopsi kasus terburuk, yaitu rakitan dengan kode yang tidak dikelola.

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

Kuncinya di sini adalah untuk menulis byte ke file dan memuat dari lokasinya. Untuk menghindari masalah ayam dan telur, Anda harus memastikan bahwa Anda menyatakan pawang sebelum mengakses rakitan dan bahwa Anda tidak mengakses anggota rakitan (atau instantiate apa pun yang harus berurusan dengan rakitan) di dalam bagian pemuatan (penyelesaian rakitan). Juga berhati-hatilah untuk memastikan GetMyApplicationSpecificPath()tidak ada direktori temp karena file temp dapat diupayakan dihapus oleh program lain atau oleh Anda sendiri (bukan berarti ia akan dihapus ketika program Anda mengakses dll, tetapi setidaknya itu gangguan. AppData baik) lokasi). Juga perhatikan bahwa Anda harus menulis byte setiap kali, Anda tidak dapat memuat dari lokasi hanya karena dll sudah ada di sana.

Untuk dll yang dikelola, Anda tidak perlu menulis byte, tetapi langsung memuat dari lokasi dll, atau hanya membaca byte dan memuat perakitan dari memori. Seperti ini atau lebih:

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

    //or just

    return Assembly.LoadFrom(dllFullPath); //if location is known.

Jika perakitan sepenuhnya tidak dikelola, Anda dapat melihat tautan ini atau ini tentang cara memuat dll.

The kutipan oleh Jeffrey Richter sangat baik. Singkatnya, tambahkan perpustakaan sebagai sumber daya yang disematkan dan tambahkan panggilan balik sebelum hal lain. Berikut ini adalah versi kode (ditemukan di komentar halamannya) yang saya letakkan di awal metode Utama untuk aplikasi konsol (pastikan saja panggilan yang menggunakan perpustakaan menggunakan metode yang berbeda dengan Utama).

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

Untuk memperluas pada asnwer @ Bobby di atas. Anda dapat mengedit .csproj Anda untuk menggunakan IL-Repack untuk secara otomatis mengemas semua file menjadi satu rakitan ketika Anda membangun.

1. Instal paket nuget ILRepack.MSBuild.Task dengan Install-Package ILRepack.MSBuild.Task
2. Edit bagian AfterBuild dari .csproj Anda

Berikut adalah contoh sederhana yang menggabungkan ExampleAssemblyToMerge.dll ke dalam output proyek Anda.

<!-- ILRepack -->
<Target Name="AfterBuild" Condition="'$(Configuration)' == 'Release'">

   <ItemGroup>
    <InputAssemblies Include="$(OutputPath)\$(AssemblyName).exe" />
    <InputAssemblies Include="$(OutputPath)\ExampleAssemblyToMerge.dll" />
   </ItemGroup>

   <ILRepack 
    Parallel="true"
    Internalize="true"
    InputAssemblies="@(InputAssemblies)"
    TargetKind="Exe"
    OutputFile="$(OutputPath)\$(AssemblyName).exe"
   />
</Target>

Anda bisa menambahkan DLL sebagai sumber daya yang disematkan, dan kemudian minta program Anda membongkar mereka ke direktori aplikasi pada startup (setelah memeriksa untuk melihat apakah mereka sudah ada di sana).

Setup file sangat mudah dibuat, meskipun, saya tidak berpikir ini akan sia-sia.

EDIT: Teknik ini akan mudah dengan majelis .NET. Dengan DLL non-.NET akan jauh lebih banyak pekerjaan (Anda harus mencari tahu di mana harus membongkar file dan mendaftarkannya dan sebagainya).

Produk lain yang dapat menangani ini dengan elegan adalah SmartAssembly, di SmartAssembly.com . Produk ini akan, selain menggabungkan semua dependensi menjadi satu DLL, (opsional) mengaburkan kode Anda, menghapus meta-data tambahan untuk mengurangi ukuran file yang dihasilkan, dan juga dapat benar-benar mengoptimalkan IL untuk meningkatkan kinerja runtime.

Ada juga beberapa jenis fitur penanganan / pelaporan pengecualian global yang ditambahkannya ke perangkat lunak Anda (jika diinginkan) yang dapat berguna. Saya percaya ini juga memiliki API baris perintah sehingga Anda dapat menjadikannya bagian dari proses pembuatan Anda.

Baik pendekatan ILMerge maupun Lars Holm Jensen yang menangani acara AssemblyResolve tidak akan berfungsi untuk host plugin. Katakanlah H dapat dieksekusi, rakitan P secara dinamis dan mengaksesnya melalui antarmuka IP yang ditentukan dalam rakitan terpisah. Untuk menanamkan IP ke dalam H, seseorang perlu sedikit modifikasi pada kode Lars:

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;
};  

Trik untuk menangani upaya berulang untuk menyelesaikan rakitan yang sama dan mengembalikan yang sudah ada alih-alih membuat contoh baru.

EDIT: Jangan sampai merusak. Serialisasi NET, pastikan untuk mengembalikan null untuk semua majelis yang tidak tertanam dalam Anda, sehingga default ke perilaku standar. Anda bisa mendapatkan daftar perpustakaan ini dengan:

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]);  }

dan hanya mengembalikan nol jika majelis yang lulus bukan milik IncludedAssemblies.

.NET Core 3.0 secara alami mendukung kompilasi ke .exe tunggal

Fitur ini diaktifkan oleh penggunaan properti berikut di file proyek Anda (.csproj):

    <PropertyGroup>
        <PublishSingleFile>true</PublishSingleFile>
    </PropertyGroup>

Ini dilakukan tanpa alat eksternal.

Lihat jawaban saya untuk pertanyaan ini untuk perincian lebih lanjut.

Ini mungkin terdengar sederhana, tetapi WinRar memberikan opsi untuk mengompres banyak file ke file yang dapat dieksekusi.
Ini memiliki banyak opsi yang dapat dikonfigurasi: ikon terakhir, ekstrak file ke jalur yang diberikan, file untuk dieksekusi setelah ekstraksi, logo / teks khusus untuk popup yang ditampilkan selama ekstraksi, tidak ada jendela sembulan sama sekali, teks perjanjian lisensi, dll.
Mungkin bermanfaat dalam beberapa kasus .

Saya menggunakan kompiler csc.exe yang dipanggil dari skrip .vbs.

Dalam skrip xyz.cs Anda, tambahkan baris berikut setelah arahan (contoh saya adalah untuk 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"

Tag ref, res, dan ico akan diambil oleh skrip .vbs di bawah ini untuk membentuk perintah csc.

Kemudian tambahkan pemanggil resolver perakitan di Main:

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

... dan tambahkan resolver itu sendiri di suatu tempat di kelas:

    static Assembly CurrentDomain_AssemblyResolve (pengirim objek, ResolveEventArgs args)
    {
        String resourceName = new AssemblyName (args.Name) .Name + ".dll";

        menggunakan (var stream = Assembly.GetExecutingAssembly (). GetManifestResourceStream (resourceName))
        {
            Byte [] assemblyData = Byte baru [stream.Length];
            stream.Baca (assemblyData, 0, assemblyData.Length);
            mengembalikan Assembly.Load (assemblyData);
        }

    }

Saya beri nama skrip vbs agar sesuai dengan nama file .cs (mis. Ssh.vbs mencari ssh.cs); ini membuat menjalankan skrip berkali-kali jauh lebih mudah, tetapi jika Anda bukan idiot seperti saya maka skrip generik dapat mengambil file .cs target dari drag-and-drop:

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

    MENGAMBIL NAMA SCRIPT VBS SEBAGAI NAMA FILE TARGET
    '#############################################
    name_ = Split (wscript.ScriptName, ".") (0)

    'DAPATKAN DLL EKSTERNAL DAN NAMA-NAMA ICON DARI FILE .CS
    '############################################## ######
    Const OPEN_FILE_FOR_READING = 1
    Setel objInputFile = fso.OpenTextFile (name_ & ".cs", 1)

    BACA SEGALA SESUATU DALAM ARRAY
    '############################
    inputData = Berpisah (objInputFile.ReadAll, vbNewline)

    Untuk setiap strData Dalam inputData

        jika dibiarkan (strData, 7) = "// + ref>" lalu 
            csc_references = csc_references & "/ reference:" & trim (ganti (strData, "// + ref>", "")) & ""
        berakhir jika

        jika dibiarkan (strData, 7) = "// + res>" lalu 
            csc_resources = csc_resources & "/ resource:" & trim (ganti (strData, "// + res>", "")) & ""
        berakhir jika

        jika dibiarkan (strData, 7) = "// + ico>" lalu 
            csc_icon = "/ win32icon:" & trim (ganti (strData, "// + ico>", "")) & ""
        berakhir jika
    Lanjut

    objInputFile.Close


    'Gabungkan FILE
    '#################
    oShell.ShellExecute "c: \ windows \ microsoft.net \ framework \ v3.5 \ csc.exe", "/ warnai: 1 / target: exe" & csc_references & csc_resources & csc_icon & "" & name_ & ".cs" , "", "runas", 2


    WScript.Quit (0)

Sangat mungkin tetapi tidak semudah itu, untuk membuat perakitan hybrid asli / terkelola dalam C #. Apakah Anda menggunakan C ++ sebagai gantinya akan jauh lebih mudah, karena kompiler Visual C ++ dapat membuat rakitan hybrid semudah apa pun.

Kecuali Anda memiliki persyaratan ketat untuk menghasilkan perakitan hibrida, saya setuju dengan MusiGenesis bahwa ini tidak sepadan dengan kesulitan yang harus dilakukan dengan C #. Jika Anda perlu melakukannya, mungkin lebih baik Anda beralih ke C ++ / CLI.

Secara umum Anda akan memerlukan beberapa bentuk alat membangun pos untuk melakukan gabungan perakitan seperti yang Anda gambarkan. Ada alat gratis bernama Eazfuscator (eazfuscator.blogspot.com/) yang dirancang untuk bytecode mangling yang juga menangani penggabungan perakitan. Anda bisa menambahkan ini ke dalam baris perintah post build dengan Visual Studio untuk menggabungkan majelis Anda, tetapi jarak tempuh Anda akan bervariasi karena masalah yang akan muncul dalam skenario penggabungan perakitan non-trival.

Anda juga dapat memeriksa untuk melihat apakah build yang membuat NANT memiliki kemampuan untuk menggabungkan rakitan setelah membangun, tetapi saya sendiri tidak cukup terbiasa dengan NANT untuk mengatakan apakah fungsionalitasnya dibangun atau tidak.

Ada juga banyak banyak plugin Visual Studio yang akan melakukan penggabungan perakitan sebagai bagian dari membangun aplikasi.

Atau jika Anda tidak perlu melakukan ini secara otomatis, ada sejumlah alat seperti ILMerge yang akan menggabungkan rakitan .net menjadi satu file.

Masalah terbesar yang saya miliki dengan menggabungkan majelis adalah jika mereka menggunakan ruang nama yang serupa. Atau lebih buruk, referensi berbagai versi dll yang sama (masalah saya umumnya dengan file dll NUnit).