DLL'leri derlenmiş bir yürütülebilir dosyaya katıştırma

Önceden var olan bir DLL'yi derlenmiş bir C # yürütülebilir dosyasına gömmek mümkün mü (böylece dağıtacak yalnızca bir dosyanız var)? Mümkünse, bunu nasıl yapabilirim?

Normalde, DLL'leri dışarıda bırakarak ve kurulum programını her şeyi halletmekten hoşlanıyorum, ama işte bana bunu soran birkaç insan var ve dürüstçe bilmiyorum.

Costura.Fody'yi kullanmanızı kesinlikle tavsiye ederim - kaynakları montajınıza dahil etmenin en iyi ve en kolay yolu. NuGet paketi olarak mevcuttur.

Install-Package Costura.Fody

Projeye ekledikten sonra, çıkış dizinine kopyalanan tüm başvuruları otomatik olarak ana derlemenize gömer . Projenize bir hedef ekleyerek katıştırılmış dosyaları temizlemek isteyebilirsiniz:

Install-CleanReferencesTarget

Ayrıca, pdb'leri dahil edip etmeyeceğinizi, belirli derlemeleri hariç tutabileceğinizi veya derlemeleri derhal çıkarabileceğinizi de belirtebilirsiniz. Bildiğim kadarıyla, yönetilmeyen meclisler de destekleniyor.

Güncelleme

Şu anda, bazı insanlar DNX için destek eklemeye çalışıyor .

Güncelleme 2

En son Fody sürümü için MSBuild 16 (Visual Studio 2019) gereklidir. Fody sürüm 4.2.1, MSBuild 15 yapacak. (Başvuru: Fody, yalnızca MSBuild 16 ve üstü sürümlerde desteklenir. Geçerli sürüm: 15 )

Visual Studio'da projenizi sağ tıklatın, Proje Özellikleri -> Kaynaklar -> Kaynak Ekle -> Mevcut Dosya Ekle… 'yi seçin ve aşağıdaki kodu App.xaml.cs veya eşdeğerinize ekleyin.

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

İşte orijinal blog yazım: http://codeblog.larsholm.net/2011/06/embed-dlls-easily-in-a-net-assembly/

Gerçekten yönetilen derlemeler varsa, ILMerge'yi kullanabilirsiniz . Yerel DLL'ler için, yapmak için biraz daha işiniz olacak.

Ayrıca bkz: Nasıl bir C ++ windows dll bir C # uygulama exe birleştirilebilir?

Evet, .NET yürütülebilir dosyalarını kitaplıklarla birleştirmek mümkündür. İşi yapmak için birden fazla araç vardır:

• ILMerge , birden çok .NET derlemesini tek bir derlemede birleştirmek için kullanılabilen bir yardımcı programdır.
• Mono mkbundle , bir exe ve libmono ile tüm montajları tek bir ikili pakete paketler.
• IL-Repack , bazı ek özelliklere sahip ILMerge'ye alternatif bir FLOSS'tur.

Ek olarak , kullanılmayan kodu kaldıran Mono Linker ile birleştirilebilir ve bunun sonucunda oluşan montaj daha küçük olur.

Başka bir olasılık, sadece bir montajın sıkıştırılmasına izin vermekle kalmaz, aynı zamanda dll'leri doğrudan exe'ye paketleyebilen .NETZ'yi kullanmaktır . Yukarıda belirtilen çözümlerin farkı, .NETZ'nin bunları birleştirmemesi, ayrı montajlar halinde kalmaları ancak tek bir pakette paketlenmesidir.

.NETZ, Microsoft .NET Framework yürütülebilir (EXE, DLL) dosyalarını daha küçük yapmak için sıkıştırıp paketleyen açık kaynaklı bir araçtır.

ILMerge , montajın yalnızca yönetilen kodu olması koşuluyla, montajları tek bir montajda birleştirebilir. Komut satırı uygulamasını kullanabilir veya exe'ye başvuru ekleyebilir ve programlı olarak birleştirebilirsiniz. Bir GUI sürümü için orada Eazfuscator zamanda ve .Netz ikisi de serbesttir. Ücretli uygulamalar BoxedApp ve SmartAssembly içerir .

Derlemeleri yönetilmeyen kodla birleştirmeniz gerekiyorsa, SmartAssembly öneririm . SmartAssembly ile hiç bir zaman hıçkırık yapmadım ama diğerleriyle. Burada, gerekli bağımlılıkları ana exe'nize kaynak olarak yerleştirebilir.

Tüm bu manuel olarak derleme yönetilen veya karışık modda dll kaynaklarınıza gömmek ve sonra AppDomain's Assembly güvenerek endişelenmenize gerek yok elle yapabilirsiniz ResolveHandler. Bu, en kötü durumun, yani yönetilmeyen koda sahip montajların benimsenmesiyle tek durak bir çözümdür.

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

Buradaki anahtar, baytları bir dosyaya yazmak ve konumundan yüklemek. Tavuk ve yumurta probleminden kaçınmak için, montaja erişmeden önce işleyiciyi bildirdiğinizden ve yükleme (montaj çözme) parçasının içindeki montaj elemanlarına erişmediğinizden (veya montajla ilgilenmesi gereken herhangi bir şeyi başlattığınızdan) emin olmalısınız. Ayrıca GetMyApplicationSpecificPath()geçici dosyalar diğer programlar veya kendiniz tarafından silinmeye çalışılacağı için herhangi bir geçici dizin olmadığından emin olun (programınız dll'ye erişirken silinecektir, ancak en azından bir sıkıntı. AppData iyidir yer). Ayrıca her seferinde bayt yazmak zorunda olduğunuzu, dll zaten orada bulunduğu için konumdan yükleyemeyeceğinizi unutmayın.

Yönetilen dll için, bayt yazmanız gerekmez, ancak doğrudan dll'nin konumundan yükleyin veya sadece baytları okuyun ve derlemeyi bellekten yükleyin. Bunun gibi:

    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.

Derleme tamamen yönetilmezse, bu bağlantıyı veya bu tür dll'lerin nasıl yükleneceği ile ilgili olarak görebilirsiniz .

Jeffrey Richter alıntı çok iyidir. Kısacası, kütüphanenin gömülü kaynakları olarak ekleyin ve her şeyden önce bir geri arama ekleyin. İşte bir konsol uygulaması için Main yönteminin başına koyduğum kodun (sayfasının yorumlarında bulunan) bir sürümü (sadece kütüphaneyi kullanan tüm çağrıların Main için farklı bir yöntemde olduğundan emin olun).

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

Yukarıdaki @ Bobby'nin asnwer'ını genişletmek . Oluşturduğunuzda tüm dosyaları otomatik olarak tek bir derleme halinde paketlemek üzere IL-Repack'i kullanmak için .csproj dosyanızı düzenleyebilirsiniz .

1. Nuget ILRepack.MSBuild.Task paketini Install-Package ILRepack.MSBuild.Task
2. .Csproj dosyanızın AfterBuild bölümünü düzenleyin

SampleAssemblyToMerge.dll dosyasını proje çıktısında birleştiren basit bir örnek.

<!-- 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>

DLL'leri katıştırılmış kaynaklar olarak ekleyebilir ve programınızın başlangıçta uygulama dizinine açmasını sağlayabilirsiniz (zaten orada olup olmadıklarını kontrol ettikten sonra).

Kurulum dosyalarını yapmak o kadar kolay ki, buna değeceğini sanmıyorum.

EDIT: Bu teknik .NET derlemeleri ile kolay olurdu. Non..NET DLL'leri ile çok daha fazla iş olacaktır (dosyaları nerede açacağınızı ve kaydedeceğinizi bulmanız gerekir).

Bunu zarif bir şekilde ele alabilecek bir diğer ürün SmartAssembly.com'da SmartAssembly . Bu ürün, tüm bağımlılıkları tek bir DLL'de birleştirmenin yanı sıra, (isteğe bağlı olarak) kodunuzu gizler, ortaya çıkan dosya boyutunu azaltmak için fazladan meta verileri kaldırır ve ayrıca IL'yi çalışma zamanı performansını artırmak için optimize edebilir.

Ayrıca, yazılımınıza (istenirse) faydalı olabilecek bir tür küresel istisna işleme / raporlama özelliği de vardır. Ayrıca, oluşturma işleminizin bir parçası haline getirebilmeniz için bir komut satırı API'sı olduğuna inanıyorum.

Ne ILMerge yaklaşımı ne de Lars Holm Jensen, AssemblyResolve etkinliğini ele alması bir eklenti sunucusu için işe yaramayacaktır. Yürütülebilir H'nin derleme P'yi dinamik olarak yüklediğini ve ayrı bir derlemede tanımlanan arabirim IP'si üzerinden eriştiğini varsayalım. To gömmek IP içine H biri Lars koduyla biraz değişiklik yapmak gerekebilir zorundadır:

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

Aynı montajı çözme ve yeni bir örnek oluşturmak yerine mevcut olanı döndürme girişimlerini tekrarlama hilesi.

DÜZENLEME: .NET'in serileştirmesini bozmasın, kendinize gömülmemiş tüm derlemeler için null döndürdüğünüzden emin olun, böylece standart davranışa varsayılan olarak getirin. Bu kütüphanelerin bir listesini şu şekilde alabilirsiniz:

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

ve eğer geçen montaj ait değilse, null değerini döndürün IncludedAssemblies.

.NET Core 3.0 yerel olarak tek bir .exe dosyasına derlemeyi destekler

Bu özellik, proje dosyanızda (.csproj) aşağıdaki özelliğin kullanılmasıyla etkinleştirilir:

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

Bu herhangi bir harici araç olmadan yapılır.

Daha fazla ayrıntı için bu soruya verdiğim cevaba bakınız.

Basit gelebilir, ancak WinRar bir grup dosyayı kendi kendine ayıklanan bir yürütülebilir dosyaya sıkıştırma seçeneği sunar.
Yapılandırılabilir birçok seçenek vardır: son simge, verilen yola dosyaları çıkart, çıkarıldıktan sonra çalıştırılacak dosya, ayıklama sırasında gösterilen açılır pencere için özel logo / metinler, hiç açılır pencere yok, lisans sözleşmesi metni, vb
. .

Bir .vbs komut dosyasından çağrılan csc.exe derleyicisi kullanın.

Xyz.cs betiğinize, yönergelerden sonra aşağıdaki satırları ekleyin (örneğim Renci SSH içindir):

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"

Ref, res ve ico etiketleri, csc komutunu oluşturmak için aşağıdaki .vbs komut dosyası tarafından alınır.

Ardından, Montaj çözücü arayanını Ana Ekrana ekleyin:

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

... ve çözümleyicinin kendisini sınıfın herhangi bir yerine ekleyin:

    static Assembly CurrentDomain_AssemblyResolve (nesne göndericisi, ResolveEventArgs argümanları)
    {
        String resourceName = new AssemblyName (args.Name) .Name + ".dll";

        using (var stream = Assembly.GetExecutingAssembly (). GetManifestResourceStream (resourceName))
        {
            Byte [] assemblyData = yeni Bayt [stream.Length];
            stream.Read (assemblyData, 0, assemblyData.Length);
            Assembly.Load (assemblyData) öğesini döndürür;
        }

    }

Vs betiği .cs dosya adıyla eşleşecek şekilde adlandırıyorum (örneğin, ssh.vbs ssh.cs dosyasını arar); bu, betiği birçok kez çalıştırmayı çok daha kolay hale getirir, ancak benim gibi bir aptal değilseniz, genel bir komut dosyası hedef .cs dosyasını sürükle ve bırak yönteminden alabilir:

    Dim adı_, oShell, fso
    Set oShell = CreateObject ("Shell.Application")
    Set fso = CreateObject ("Scripting.fileSystemObject")

    'HEDEF DOSYA ADI OLARAK VBS SCRIPT ADINI ALIN
    '################################################
    name_ = Böl (wscript.ScriptName, ".") (0)

    'EXCAL DLL'leri VE SİMGESİ İSİMLERİNİ .CS DOSYASINDAN ALIN
    '################################################# ######
    Sabit OPEN_FILE_FOR_READING = 1
    ObjInputFile = fso.OpenTextFile (name_ & ".cs", 1) olarak ayarlayın

    'HER ŞEYİ BİR DÜZEYE OKUYUN
    '#############################
    inputData = Böl (objInputFile.ReadAll, vbNewline)

    Her strData In inputData için

        bırakılırsa (strData, 7) = "// + ref>" 
            csc_references = csc_references & "/ reference:" & kırpma (değiştir (strData, "// + ref>", "")) & ""
        eğer biterse

        bırakılırsa (strData, 7) = "// + res>" 
            csc_resources = csc_resources & "/ resource:" & kırpma (değiştir (strData, "// + res>", "")) & ""
        eğer biterse

        bırakılırsa (strData, 7) = "// + ico>" 
            csc_icon = "/ win32icon:" & trim (değiştir (strData, "// + ico>", "")) & ""
        eğer biterse
    Sonraki

    objInputFile.Close


    'DOSYAYI DERLEYİN
    '################
    oShell.ShellExecute "c: \ windows \ microsoft.net \ framework \ v3.5 \ csc.exe", "/ warn: 1 / target: exe" & csc_references & csc_resources & csc_icon & "" ve ad_ & ".cs" , "", "runas", 2


    WScript.Quit (0)

C # 'da karma yerel / yönetilen bir montaj oluşturmak mümkün ama o kadar kolay değil. Visual C ++ derleyicisi başka bir şey kadar kolay bir şekilde karma derlemeler oluşturabileceğinden, bunun yerine C ++ kullanıyor olsaydınız çok daha kolay olurdu.

Hibrit bir montaj üretmek için katı bir gereksiniminiz olmadıkça, MusiGenesis ile bu C # ile gerçekten uğraşmaya değmez. Bunu yapmanız gerekiyorsa, bunun yerine C ++ / CLI'ye geçmeye bakın.

Genelde, açıkladığınız gibi bir birleştirme birleştirmesi gerçekleştirmek için bir tür post derleme aracının olması gerekir. Montaj birleştirmeyi de işleyen bayt kodu yönetimi için tasarlanmış Eazfuscator (eazfuscator.blogspot.com/) adlı ücretsiz bir araç var. Bunu derlemelerinizi birleştirmek için Visual Studio ile bir derleme sonrası komut satırına ekleyebilirsiniz, ancak herhangi bir trival olmayan birleştirme senaryolarında ortaya çıkacak sorunlardan dolayı kilometreniz değişecektir.

Ayrıca, yapı NANT'ı yapmak için yapı olup olmadığını kontrol edebilirsin NANT, binadan sonra montajları birleştirme yeteneğine sahiptir, ancak işlevselliğin yerleşik olup olmadığını söylemek için kendime NANT hakkında yeterince bilgim yok.

Ayrıca uygulama oluşturmanın bir parçası olarak birleştirme birleştirmesi gerçekleştirecek birçok Visual Studio eklentisi de vardır.

Alternatif olarak, bunun otomatik olarak yapılması gerekmiyorsa, ILMerge gibi .net derlemelerini tek bir dosyada birleştirecek bir dizi araç vardır.

Birleştirme derlemelerinde yaşadığım en büyük sorun, benzer ad alanları kullanmalarıdır. Ya da daha kötüsü, aynı dll farklı sürümleri referans (benim sorunları genellikle NUnit dll dosyaları ile vardı).