[vb.NET] System.Data.SQLite into .exe

 System.Diagnostics.Process.Start("regsvr32.exe", "PfadZurDLL\System.Data.SQLite.DLL")

Option Strict On
Imports System.Reflection

Namespace My

    Partial Friend Class MyApplication

        Private Sub Form1_Startup(ByVal sender As Object, ByVal e As Microsoft.VisualBasic.ApplicationServices.StartupEventArgs) Handles Me.Startup
            AddHandler AppDomain.CurrentDomain.AssemblyResolve, AddressOf DLLDateiAusResourcesLaden
        End Sub

        Private Function DLLDateiAusResourcesLaden(ByVal sender As Object, ByVal args As System.ResolveEventArgs) As System.Reflection.Assembly

            If args.Name.Contains("System.Data.SQLite") Then
                Return System.Reflection.Assembly.Load(My.Resources.System_Data_SQLite)
            Else
                Return Nothing
            End If

        End Function

        'Private Function LoadDLLFromStream(ByVal sender As Object, ByVal args As System.ResolveEventArgs) As System.Reflection.Assembly

        '    Using stream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("System.Data.SQLite.dll")

        '        Dim assemblyData(CInt(stream.Length - 1)) As Byte

        '        stream.Read(assemblyData, 0, assemblyData.Length)

        '        Return System.Reflection.Assembly.Load(assemblyData)

        '    End Using

        'End Function

    End Class

End Namespace

public class AssemblyLoader
    {
        private static Dictionary<string, Assembly> dic;

        static AssemblyLoader()
        {
            AssemblyLoader.dic = null;
        }

        public AssemblyLoader()
        {
        }

        public static Assembly Get(string assemblyFullName)
        {
            Assembly item;
            if (!(AssemblyLoader.dic == null ? false : AssemblyLoader.dic.Count != 0))
            {
                item = null;
            }
            else if (!AssemblyLoader.dic.ContainsKey(assemblyFullName))
            {
                item = null;
            }
            else
            {
                item = AssemblyLoader.dic[assemblyFullName];
            }
            return item;
        }

        public static void Load(string embeddedResource, string fileName)
        {
            if (AssemblyLoader.dic == null)
            {
                AssemblyLoader.dic = new Dictionary<string, Assembly>();
            }
            byte[] numArray = null;
            Assembly assembly = null;
            Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedResource);
            try
            {
                if (manifestResourceStream == null)
                {
                    throw new Exception(string.Concat(embeddedResource, " is not found in Embedded Resources."));
                }
                numArray = new byte[(int)manifestResourceStream.Length];
                manifestResourceStream.Read(numArray, 0, (int)manifestResourceStream.Length);
                try
                {
                    assembly = Assembly.Load(numArray);
                    AssemblyLoader.dic.Add(assembly.FullName, assembly);
                    return;
                }
                catch
                {
                }
            }
            finally
            {
                if (manifestResourceStream != null)
                {
                    ((IDisposable)manifestResourceStream).Dispose();
                }
            }
            bool flag = false;
            string str = "";
            SHA1CryptoServiceProvider sHA1CryptoServiceProvider = new SHA1CryptoServiceProvider();
            try
            {
                string str1 = BitConverter.ToString(sHA1CryptoServiceProvider.ComputeHash(numArray)).Replace("-", string.Empty);
                str = string.Concat(Path.GetTempPath(), fileName);
                if (!File.Exists(str))
                {
                    flag = false;
                }
                else
                {
                    flag = (str1 != BitConverter.ToString(sHA1CryptoServiceProvider.ComputeHash(File.ReadAllBytes(str))).Replace("-", string.Empty) ? false : true);
                }
            }
            finally
            {
                if (sHA1CryptoServiceProvider != null)
                {
                    ((IDisposable)sHA1CryptoServiceProvider).Dispose();
                }
            }
            if (!flag)
            {
                File.WriteAllBytes(str, numArray);
            }
            assembly = Assembly.LoadFile(str);
            AssemblyLoader.dic.Add(assembly.FullName, assembly);
        }
    }

        private static Assembly CurrentDomainAssemblyResolve(object sender, ResolveEventArgs args)
        {
            return AssemblyLoader.Get(args.Name);
        }

        [STAThread]
        private static void Main()
        {
            string str = "NAMESPACE.LIBRARY.dll";
            AssemblyLoader.Load(str, str);
            AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(Program.CurrentDomainAssemblyResolve);
            /*Standard Code*/
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new frmMain());
        }