Loader for loading embedded assemblies z

using System ;

using System.Collections.Generic ;

using System.IO ;

using System.Linq ;

using System.Reflection ;

using System.Runtime.InteropServices ;

 

namespace Utility

{

public class Loader

{

const string LibsFolder = "Libs" ;

 

static readonly Dictionary < string , Assembly > Libraries = new Dictionary < string , Assembly >();

static readonly Dictionary < string , Assembly > ReflectionOnlyLibraries = new Dictionary < string , Assembly >();

 

public static void Start ()

{

AppDomain . CurrentDomain . AssemblyResolve += FindAssembly ;

 

PreloadUnmanagedLibraries ();

 

var app = new App ();

app . Run ();

}

 

[DllImport("kernel32.dll")]

private static extern IntPtr LoadLibrary ( string dllToLoad );

 

private static void PreloadUnmanagedLibraries ()

{

// Preload correct library

var bittyness = "x86" ;

if ( IntPtr . Size == 8 )

bittyness = "x64" ;

 

var assemblyName = Assembly . GetExecutingAssembly (). GetName ();

 

var libraries = Assembly . GetExecutingAssembly (). GetManifestResourceNames ()

. Where ( s => s . StartsWith ( String . Format ( "{1}.{2}.{0}." , bittyness , assemblyName . Name , LibsFolder )))

. ToArray ();

 

var dirName = Path . Combine ( Path . GetTempPath (), String . Format ( "{2}.{1}.{0}" , assemblyName . Version , bittyness , assemblyName . Name ));

if (! Directory . Exists ( dirName ))

Directory . CreateDirectory ( dirName );

 

foreach ( var lib in libraries )

{

string dllPath = Path . Combine ( dirName , String . Join ( "." , lib . Split ( '.' ). Skip ( 3 )));

 

if (! File . Exists ( dllPath ))

{

using ( Stream stm = Assembly . GetExecutingAssembly (). GetManifestResourceStream ( lib ))

{

// Copy the assembly to the temporary file

try

{

using ( Stream outFile = File . Create ( dllPath ))

{

stm . CopyTo ( outFile );

}

}

catch

{

// This may happen if another process has already created and loaded the file.

// Since the directory includes the version number of this assembly we can

// assume that it's the same bits, so we just ignore the excecption here and

// load the DLL.

}

}

}

 

// We must explicitly load the DLL here because the temporary directory

// is not in the PATH.

// Once it is loaded, the DllImport directives that use the DLL will use

// the one that is already loaded into the process.

LoadLibrary ( dllPath );

}

}

 

internal static Assembly LoadAssembly ( string fullName )

{

Assembly a ;

 

var executingAssembly = Assembly . GetExecutingAssembly ();

 

var assemblyName = executingAssembly . GetName ();

 

var shortName = new AssemblyName ( fullName ). Name ;

if ( Libraries . ContainsKey ( shortName ))

return Libraries [ shortName ];

 

var resourceName = String . Format ( "{0}.{2}.{1}.dll" , assemblyName . Name , shortName , LibsFolder );

var actualName = executingAssembly . GetManifestResourceNames (). FirstOrDefault ( n => string . Equals ( n , resourceName , StringComparison . OrdinalIgnoreCase ));

 

if ( string . IsNullOrEmpty ( actualName ))

{

// The library might be a mixed mode assembly. Try loading from the bitty folders.

var bittyness = "x86" ;

if ( IntPtr . Size == 8 )

bittyness = "x64" ;

 

resourceName = String . Format ( "{0}.{3}.{1}.{2}.dll" , assemblyName . Name , bittyness , shortName , LibsFolder );

actualName = executingAssembly . GetManifestResourceNames (). FirstOrDefault ( n => string . Equals ( n , resourceName , StringComparison . OrdinalIgnoreCase ));

 

if ( string . IsNullOrEmpty ( actualName ))

{

Libraries [ shortName ] = null ;

return null ;

}

 

// Ok, mixed mode assemblies cannot be loaded through Assembly.Load.

// See http://stackoverflow.com/questions/2945080/ and http://connect.microsoft.com/VisualStudio/feedback/details/97801/

// But, since it's an unmanaged library we've already dumped it to disk to preload it into the process.

// So, we'll just load it from there.

var dirName = Path . Combine ( Path . GetTempPath (), String . Format ( "{2}.{1}.{0}" , assemblyName . Version , bittyness , assemblyName . Name ));

var dllPath = Path . Combine ( dirName , String . Join ( "." , actualName . Split ( '.' ). Skip ( 3 )));

 

if (! File . Exists ( dllPath ))

{

Libraries [ shortName ] = null ;

return null ;

}

 

a = Assembly . LoadFile ( dllPath );

Libraries [ shortName ] = a ;

return a ;

}

 

using ( var s = executingAssembly . GetManifestResourceStream ( actualName ))

{

var data = new BinaryReader ( s ). ReadBytes (( int ) s . Length );

 

byte [] debugData = null ;

if ( executingAssembly . GetManifestResourceNames (). Contains ( String . Format ( "{0}.{2}.{1}.pdb" , assemblyName . Name , shortName , LibsFolder )))

{

using ( var ds = executingAssembly . GetManifestResourceStream ( String . Format ( "{0}.{2}.{1}.pdb" , assemblyName . Name , shortName , LibsFolder )))

{

debugData = new BinaryReader ( ds ). ReadBytes (( int ) ds . Length );

}

}

 

if ( debugData != null )

{

a = Assembly . Load ( data , debugData );

Libraries [ shortName ] = a ;

return a ;

}

a = Assembly . Load ( data );

Libraries [ shortName ] = a ;

return a ;

}

}

 

internal static Assembly ReflectionOnlyLoadAssembly ( string fullName )

{

var executingAssembly = Assembly . GetExecutingAssembly ();

 

var assemblyName = Assembly . GetExecutingAssembly (). GetName ();

 

string shortName = new AssemblyName ( fullName ). Name ;

if ( ReflectionOnlyLibraries . ContainsKey ( shortName ))

return ReflectionOnlyLibraries [ shortName ];

 

var resourceName = String . Format ( "{0}.{2}.{1}.dll" , assemblyName . Name , shortName , LibsFolder );

 

if (! executingAssembly . GetManifestResourceNames (). Contains ( resourceName ))

{

ReflectionOnlyLibraries [ shortName ] = null ;

return null ;

}

 

using ( var s = executingAssembly . GetManifestResourceStream ( resourceName ))

{

var data = new BinaryReader ( s ). ReadBytes (( int ) s . Length );

 

var a = Assembly . ReflectionOnlyLoad ( data );

ReflectionOnlyLibraries [ shortName ] = a ;

 

return a ;

}

}

 

internal static Assembly FindAssembly ( object sender , ResolveEventArgs args )

{

return LoadAssembly ( args . Name );

}

 

internal static Assembly FindReflectionOnlyAssembly ( object sender , ResolveEventArgs args )

{

return ReflectionOnlyLoadAssembly ( args . Name );

}

}

}