static void Main()
{
// Read the main configuration file
var xmlDoc = ReadConfiguration();
// if MQ is installed, we need to inject in the configuration file
// the necessary bindingredirect to use the amqmdnet installed in the GAC (even if older than the one ship with the tool)
bool mqInstalled = CheckMqInstalled(out string mqVersion);
if (mqInstalled)
{
AddBindingRedirect(xmlDoc, mqVersion);
}
// Prepare a new application domain setup with the modified configuration file
var config = xmlDoc.ToString();
var setup = new AppDomainSetup();
setup.SetConfigurationBytes(Encoding.Default.GetBytes(config));
var newdomain = AppDomain.CreateDomain("MQExplorerPlusWithRightAPI", new Evidence(), setup);
void startupaction()
{
Thread thread = new Thread(() =>
{
App.Main();
});
thread.SetApartmentState(
ApartmentState.STA);
thread.Start();
}
newdomain.DoCallBack(startupaction);
}
/// <exception cref="ArgumentNullException"><paramref name="assemblyDirectory"/> is <see langword="null" />.</exception>
public AppDomainIsolation(string assemblyDirectory, string assemblyConfiguration)
{
if (string.IsNullOrEmpty(assemblyDirectory))
{
throw new ArgumentNullException(nameof(assemblyDirectory));
}
var configuration = AssemblyConfigurationFileTransformer.GetConfigurationBytes(assemblyDirectory, assemblyConfiguration);
var setup = new AppDomainSetup();
setup.ShadowCopyFiles = "true";
setup.SetConfigurationBytes(configuration);
Domain = AppDomain.CreateDomain("AppDomainIsolation:" + Guid.NewGuid(), null, setup);
var type = typeof(T);
LoadToolchainAssemblies(type);
try
{
Object = (T)Domain.CreateInstanceAndUnwrap(type.Assembly.FullName, type.FullName);
}
catch
{
Object = (T)Domain.CreateInstanceFromAndUnwrap(type.Assembly.Location, type.FullName);
}
}
private static void Main(string[] args)
{
var typedArgs = TypedArgs.FromArgs(args);
var config = new RuntimeConfig();
config.AddCodeBaseFor(typeof(Program).Assembly.GetName());
config.AddCodeBaseFor(typeof(IPluginController).Assembly.GetName());
config.AddCodeBaseFor(typeof(ILogService).Assembly.GetName());
var setup = new AppDomainSetup()
{
ApplicationBase = AppDomain.CurrentDomain.BaseDirectory,
PrivateBinPath = Environment.CurrentDirectory,
PrivateBinPathProbe = "ExcludeAppBase",
ConfigurationFile = typedArgs.AssemblyFile + ".config"
};
setup.SetConfigurationBytes(config.GetBytes());
var pluginDomain = AppDomain.CreateDomain("Plugin", null, setup);
pluginDomain.AssemblyResolve += AssemblyResolve;
var bootstrapper = (Bootstrapper)pluginDomain.CreateInstanceAndUnwrap(typeof(Bootstrapper).Assembly.FullName, typeof(Bootstrapper).FullName);
bootstrapper.RunPluginDomain(args);
}
/// <exception cref="ArgumentNullException"><paramref name="assemblyDirectory"/> is <see langword="null" />.</exception>
public AppDomainIsolation(string assemblyDirectory, string assemblyConfiguration, IEnumerable <BindingRedirect> bindingRedirects, IEnumerable <string> preloadedAssemblies)
{
if (string.IsNullOrEmpty(assemblyDirectory))
{
throw new ArgumentNullException(nameof(assemblyDirectory));
}
var configuration = AssemblyConfigurationFileTransformer.GetConfigurationBytes(
assemblyDirectory, assemblyConfiguration, bindingRedirects);
var setup = new AppDomainSetup();
setup.ShadowCopyFiles = "true";
setup.SetConfigurationBytes(configuration);
Domain = AppDomain.CreateDomain("AppDomainIsolation:" + Guid.NewGuid(), null, setup);
foreach (var pa in preloadedAssemblies)
{
Domain.Load(new AssemblyName {
CodeBase = pa
});
}
var type = typeof(T);
try
{
Object = (T)Domain.CreateInstanceAndUnwrap(type.Assembly.FullName, type.FullName);
}
catch
{
Object = (T)Domain.CreateInstanceFromAndUnwrap(type.Assembly.Location, type.FullName);
}
}
public void TestNET45Caller_AppDomain4_AssemblyLocator()
{
Assembly net45Caller = Assembly.LoadFrom(TestAssembly45RelativePath);
AppDomainSetup setup = new AppDomainSetup()
{
//ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
ApplicationBase = net45Caller.CodeBase, // -> AssemblyLocator will crash
ApplicationName = "TestNET45Caller",
SandboxInterop = true,
ShadowCopyFiles = Boolean.TrueString,
TargetFrameworkName = ".NETFramework,Version=v4.5"
};
setup.SetConfigurationBytes(System.Text.Encoding.UTF8.GetBytes(NET45Config));
System.Security.Policy.Evidence evidence = new System.Security.Policy.Evidence(AppDomain.CurrentDomain.Evidence);
evidence.AddAssemblyEvidence(new System.Security.Policy.ApplicationDirectory(@"..\..\..\]BET[.Playground.Interop.COM.NET45Caller\bin\Debug\"));
// create domain
AppDomain net45CallerDomain = AppDomain.CreateDomain(
"TestNET45Caller",
evidence,
setup
);
try
{
_BET_.Playground.Core.AssemblyLocator.Init(net45CallerDomain);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
/// <summary>
/// Loads the specified plugin assembly file into the returned plugin application domain.
/// </summary>
/// <param name="pluginAssemblyFile">the.NET maven plugin</param>
/// <returns>application domain for .NET maven plugin</returns>
///
internal AppDomain GetApplicationDomainFor(FileInfo pluginAssemblyFile)
{
Console.WriteLine("Loading Generator: " + pluginAssemblyFile.DirectoryName);
AppDomainSetup setup = new AppDomainSetup();
setup.ApplicationBase = pluginAssemblyFile.DirectoryName;
// This is a fix for NPANDAY-398. The AppDomain should never load NPanday.Plugin in the version
// that was referenced by the .NET-Plugin itself, but rather the version of NPanday.Plugin that
// the Generator is compiled against.
setup.SetConfigurationBytes(Encoding.UTF8.GetBytes(@"
<configuration>
<runtime>
<assemblyBinding xmlns=""urn:schemas-microsoft-com:asm.v1"">
<dependentAssembly>
<assemblyIdentity name=""NPanday.Plugin""
publicKeyToken=""4b435f4d76e2f0e6""
culture=""neutral"" />
<bindingRedirect oldVersion=""0.0.0.0-65535.65535.65535.65535""
newVersion=""" + typeof(FieldAttribute).Assembly.GetName().Version + @"""/>
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>
"));
AppDomain applicationDomain = AppDomain.CreateDomain("Loader", null, setup);
string assemblyName = pluginAssemblyFile.Name.Replace(pluginAssemblyFile.Extension, "");
applicationDomain.Load(assemblyName);
return(applicationDomain);
}
public void TestNET2Caller_AppDomain2_CustomDomain4()
{
Assembly net2Caller = Assembly.LoadFrom(TestAssemblyRelativePath);
AppDomainSetup setup = new AppDomainSetup()
{
ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
ApplicationName = "TestNET2Caller",
SandboxInterop = true,
ShadowCopyFiles = Boolean.TrueString,
TargetFrameworkName = ".NETFramework,Version=v2.0" // appdomain is more or less ignoring < 4.5 :(
};
setup.SetConfigurationBytes(System.Text.Encoding.UTF8.GetBytes(NET2Config));
System.Security.Policy.Evidence evidence = new System.Security.Policy.Evidence(AppDomain.CurrentDomain.Evidence);
evidence.AddAssemblyEvidence(new System.Security.Policy.ApplicationDirectory(@"..\..\..\]BET[.Playground.Interop.COM.NET2Caller\bin\Debug\"));
// create domain
AppDomain net2CallerDomain = AppDomain.CreateDomain(
"TestNET2Caller",
evidence,
setup
);
AssemblyLocator.Init(net2CallerDomain);
try
{
var prg = net2CallerDomain.CreateInstanceAndUnwrap(net2Caller.FullName, net2Caller.GetType().FullName);
var callCom = prg.GetType().GetMethod("CallCom");
var result = callCom.Invoke(prg, null) as string;
Assert.AreEqual <string>(ErrorMsg, result); // fail
Assert.Inconclusive(InconclusiveMsg);
}
catch (Exception ex)
{
if (ex.HResult == -2146233054)
{
Assert.Fail($"Expected Fail 1: {ex.Message}");
}
if (ex.HResult == -2147024894)
{
Assert.Fail($"Expected Fail 2: {ex.Message}");
}
if (ex.HResult == -2147024773)
{
Assert.Fail($"Expected Fail 3: {ex.Message}");
}
Assert.Fail($"Unknown Fail: {ex.Message}");
}
finally
{
AppDomain.Unload(net2CallerDomain);
}
}
// Helper to create a cofigured domain using a config file excerpt
public static AppDomain CreateDomain(string configFile)
{
AppDomain current = App;
AppDomainSetup ads = new AppDomainSetup {
ApplicationBase = current.BaseDirectory,
};
string configExcerpt = File.ReadAllText(Path.Combine("Content", "Configuration", configFile));
string configTemplate = File.ReadAllText(Path.Combine("Content", "Configuration", "configuration-template.xml"));
byte[] bytes = Encoding.ASCII.GetBytes(configTemplate.Replace("{UNIVERSAL_CONFIGURATION}", configExcerpt));
ads.SetConfigurationBytes(bytes);
File.WriteAllBytes(ads.ConfigurationFile = Path.GetTempFileName(), bytes);
return(AppDomain.CreateDomain(configFile, current.Evidence, ads));
}
public void TestNET45App_AppDomain2_CustomDomain2()
{
AppDomainSetup setup = new AppDomainSetup()
{
PrivateBinPath = TestPath,
ApplicationBase = TestPath,
ApplicationName = "TestNET45App",
TargetFrameworkName = ".NETFramework,Version=v4.5",
};
setup.SetConfigurationBytes(System.Text.Encoding.UTF8.GetBytes(NET45Config));
Type proxy = typeof(Proxy);
System.Security.Policy.Evidence evidence = AppDomain.CurrentDomain.Evidence;
// create domain
AppDomain net45AppDomain = AppDomain.CreateDomain(
"TestNET45App",
evidence,
setup
);
try
{
var prg = (Proxy)net45AppDomain.CreateInstanceAndUnwrap(proxy.Assembly.FullName, proxy.FullName);
// this will only work when it is referenced in the project?
var assembly = prg.GetAssembly(TestAssembly45RelativePath);
var instance = Activator.CreateInstance(assembly.GetType(TestObject45));
var call = assembly.GetType(TestObject45).GetMethod("Call");
var result = call.Invoke(instance, null) as string;
Assert.AreEqual <string>("This assembly is NET Dll Version v4.0.30319", result);
}
catch (Exception ex)
{
Assert.Fail($"Unknown Fail: {ex.Message}");
}
finally
{
AppDomain.Unload(net45AppDomain);
}
}
internal static void SetConfigurationFile(AppDomainSetup appDomainSetup, string testSourceConfigFile)
{
if (!string.IsNullOrEmpty(testSourceConfigFile))
{
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("UnitTestAdapter: Using configuration file {0} to setup appdomain for test source {1}.", testSourceConfigFile, Path.GetFileNameWithoutExtension(testSourceConfigFile));
}
appDomainSetup.ConfigurationFile = Path.GetFullPath(testSourceConfigFile);
try
{
// Add redirection of the built 11.0 Object Model assembly to the current version if that is not 11.0
var currentVersionOfObjectModel = typeof(TestCase).Assembly.GetName().Version.ToString();
if (!string.Equals(currentVersionOfObjectModel, ObjectModelVersionBuiltAgainst))
{
var assemblyName = typeof(TestCase).Assembly.GetName();
var configurationBytes =
XmlUtilities.AddAssemblyRedirection(
testSourceConfigFile,
assemblyName,
ObjectModelVersionBuiltAgainst,
assemblyName.Version.ToString());
appDomainSetup.SetConfigurationBytes(configurationBytes);
}
}
catch (Exception ex)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("Exception hit while adding binding redirects to test source config file. Exception : {0}", ex);
}
}
}
else
{
// Use the current domains configuration setting.
appDomainSetup.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
}
}
private void ThreadProc()
{
try
{
var setup = new AppDomainSetup
{
ApplicationBase = AppDomain.CurrentDomain.BaseDirectory,
ApplicationName = "RPC client",
PrivateBinPath = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath,
PrivateBinPathProbe = AppDomain.CurrentDomain.SetupInformation.PrivateBinPathProbe
};
if (_startInfo.AppDomainConfiguration != null)
{
setup.SetConfigurationBytes(_startInfo.AppDomainConfiguration);
}
var appDomain = AppDomain.CreateDomain(setup.ApplicationName, AppDomain.CurrentDomain.Evidence, setup);
try
{
appDomain.ExecuteAssembly(_startInfo.FileName, _startInfo.Arguments.ToArray());
}
finally
{
AppDomain.Unload(appDomain);
}
}
catch (Exception exception)
{
_exception = exception;
}
finally
{
HasExited = true;
OnExited();
}
}
private static AppDomain CreateAppDomain(string applicationPath)
{
var appDomainSetup = new AppDomainSetup {
ApplicationBase = Path.GetDirectoryName(typeof(Program).Assembly.Location)
};
appDomainSetup.SetConfigurationBytes(Encoding.UTF8.GetBytes($@"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<runtime>
<assemblyBinding xmlns=""urn:schemas-microsoft-com:asm.v1"">
<dependentAssembly>
<assemblyIdentity name=""Microsoft.VisualStudio.ExtensionManager"" publicKeyToken=""b03f5f7f11d50a3a"" culture=""neutral"" />
<bindingRedirect oldVersion=""10.0.0.0-{VsProductVersion.Major}.0.0.0"" newVersion=""{VsProductVersion.Major}.0.0.0"" />
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>"));
var appDomain = AppDomain.CreateDomain($"{nameof(Installer)} {VsProductVersion}", null, appDomainSetup);
var assemblyResolver = appDomain.CreateInstanceFromAndUnwrap <AssemblyResolver>();
assemblyResolver.Install(Path.GetDirectoryName(applicationPath));
return(appDomain);
}
/// <summary>
/// Creates an ITask instance and returns it.
/// </summary>
internal static ITask CreateTask(LoadedType loadedType, string taskName, string taskLocation, int taskLine, int taskColumn, LogError logError
#if FEATURE_APPDOMAIN
, AppDomainSetup appDomainSetup
#endif
, bool isOutOfProc
#if FEATURE_APPDOMAIN
, out AppDomain taskAppDomain
#endif
)
{
#if FEATURE_APPDOMAIN
bool separateAppDomain = loadedType.HasLoadInSeparateAppDomainAttribute();
s_resolverLoadedType = null;
taskAppDomain = null;
ITask taskInstanceInOtherAppDomain = null;
#endif
try
{
#if FEATURE_APPDOMAIN
if (separateAppDomain)
{
if (!loadedType.Type.GetTypeInfo().IsMarshalByRef)
{
logError
(
taskLocation,
taskLine,
taskColumn,
"TaskNotMarshalByRef",
taskName
);
return(null);
}
else
{
// Our task depend on this name to be precisely that, so if you change it make sure
// you also change the checks in the tasks run in separate AppDomains. Better yet, just don't change it.
// Make sure we copy the appdomain configuration and send it to the appdomain we create so that if the creator of the current appdomain
// has done the binding redirection in code, that we will get those settings as well.
AppDomainSetup appDomainInfo = new AppDomainSetup();
// Get the current app domain setup settings
byte[] currentAppdomainBytes = appDomainSetup.GetConfigurationBytes();
// Apply the appdomain settings to the new appdomain before creating it
appDomainInfo.SetConfigurationBytes(currentAppdomainBytes);
if (BuildEnvironmentHelper.Instance.RunningTests)
{
// Prevent the new app domain from looking in the VS test runner location. If this
// is not done, we will not be able to find net.r_eg.IeXod.* assemblies.
appDomainInfo.ApplicationBase = BuildEnvironmentHelper.Instance.CurrentMSBuildToolsDirectory;
appDomainInfo.ConfigurationFile = BuildEnvironmentHelper.Instance.CurrentMSBuildConfigurationFile;
}
AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolver;
s_resolverLoadedType = loadedType;
taskAppDomain = AppDomain.CreateDomain(isOutOfProc ? "taskAppDomain (out-of-proc)" : "taskAppDomain (in-proc)", null, appDomainInfo);
if (loadedType.LoadedAssembly != null)
{
taskAppDomain.Load(loadedType.LoadedAssembly.GetName());
}
#if FEATURE_APPDOMAIN_UNHANDLED_EXCEPTION
// Hook up last minute dumping of any exceptions
taskAppDomain.UnhandledException += new UnhandledExceptionEventHandler(ExceptionHandling.UnhandledExceptionHandler);
#endif
}
}
else
#endif
{
// perf improvement for the same appdomain case - we already have the type object
// and don't want to go through reflection to recreate it from the name.
return((ITask)Activator.CreateInstance(loadedType.Type));
}
#if FEATURE_APPDOMAIN
if (loadedType.Assembly.AssemblyFile != null)
{
taskInstanceInOtherAppDomain = (ITask)taskAppDomain.CreateInstanceFromAndUnwrap(loadedType.Assembly.AssemblyFile, loadedType.Type.FullName);
// this will force evaluation of the task class type and try to load the task assembly
Type taskType = taskInstanceInOtherAppDomain.GetType();
// If the types don't match, we have a problem. It means that our AppDomain was able to load
// a task assembly using Load, and loaded a different one. I don't see any other choice than
// to fail here.
if (taskType != loadedType.Type)
{
logError
(
taskLocation,
taskLine,
taskColumn,
"ConflictingTaskAssembly",
loadedType.Assembly.AssemblyFile,
loadedType.Type.GetTypeInfo().Assembly.Location
);
taskInstanceInOtherAppDomain = null;
}
}
else
{
taskInstanceInOtherAppDomain = (ITask)taskAppDomain.CreateInstanceAndUnwrap(loadedType.Type.GetTypeInfo().Assembly.FullName, loadedType.Type.FullName);
}
return(taskInstanceInOtherAppDomain);
#endif
}
finally
{
#if FEATURE_APPDOMAIN
// Don't leave appdomains open
if (taskAppDomain != null && taskInstanceInOtherAppDomain == null)
{
AppDomain.Unload(taskAppDomain);
RemoveAssemblyResolver();
}
#endif
}
}
public void TestNET2Caller_AppDomain4_AssemblyLocator()
{
Assembly net2Caller = Assembly.LoadFrom(TestAssemblyRelativePath);
AppDomainSetup setup = new AppDomainSetup()
{
//ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
ApplicationBase = net2Caller.CodeBase, // -> AssemblyLocator will crash
ApplicationName = "TestNET2Caller",
SandboxInterop = true,
ShadowCopyFiles = Boolean.TrueString,
TargetFrameworkName = ".NETFramework,Version=v2.0" // appdomain is more or less ignoring < 4.5 :(
};
setup.SetConfigurationBytes(System.Text.Encoding.UTF8.GetBytes(NET2Config));
System.Security.Policy.Evidence evidence = new System.Security.Policy.Evidence(AppDomain.CurrentDomain.Evidence);
evidence.AddAssemblyEvidence(new System.Security.Policy.ApplicationDirectory(@"..\..\..\]BET[.Playground.Interop.COM.NET2Caller\bin\Debug\"));
// create domain
AppDomain net2CallerDomain = AppDomain.CreateDomain(
"TestNET4Caller",
evidence,
setup
);
try
{
AssemblyLocator.Init(net2CallerDomain);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
/*
* Could not load file or assembly ']BET[.Playground.Core, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null' or one of its dependencies. Das System kann die angegebene Datei nicht finden.
*
* === Pre-bind state information ===
* LOG: DisplayName = ]BET[.Playground.Core, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
* (Fully-specified)
*
* LOG: Appbase = ../]BET[.Playground/]BET[.Playground.Interop.COM.NET2Caller/bin/Debug/Playground.Interop.COM.NET2Caller.exe
* LOG: Initial PrivatePath = ../Projects/]BET[.Playground/]BET[.Playground.Interop.COM.NET2Caller/bin/Debug/Playground.Interop.COM.NET2Caller.exe
* Calling assembly : (Unknown).
* ===
* LOG: This bind starts in default load context.
* LOG: Found application configuration file (\PROGRAM FILES (X86)\MICROSOFT VISUAL STUDIO 14.0\COMMON7\IDE\COMMONEXTENSIONS\MICROSOFT\TESTWINDOW\vstest.executionengine.x86.exe.Config).
* LOG: Using application configuration file: \PROGRAM FILES (X86)\MICROSOFT VISUAL STUDIO 14.0\COMMON7\IDE\COMMONEXTENSIONS\MICROSOFT\TESTWINDOW\vstest.executionengine.x86.exe.Config
* LOG: Using host configuration file:
* LOG: Using machine configuration file from \Windows\Microsoft.NET\Framework\v4.0.30319\config\machine.config.
* LOG: Policy not being applied to reference at this time (private, custom, partial, or location-based assembly bind).
* LOG: Attempting download of new URL ../]BET[.Playground/]BET[.Playground.Interop.COM.NET2Caller/bin/Debug/Playground.Interop.COM.NET2Caller.exe/]BET[.Playground.Core.DLL.
* LOG: Attempting download of new URL ../]BET[.Playground/]BET[.Playground.Interop.COM.NET2Caller/bin/Debug/Playground.Interop.COM.NET2Caller.exe/]BET[.Playground.Core/]BET[.Playground.Core.DLL.
* LOG: Attempting download of new URL ../]BET[.Playground/]BET[.Playground.Interop.COM.NET2Caller/bin/Debug/Playground.Interop.COM.NET2Caller.exe/]BET[.Playground.Core.EXE.
* LOG: Attempting download of new URL ../]BET[.Playground/]BET[.Playground.Interop.COM.NET2Caller/bin/Debug/Playground.Interop.COM.NET2Caller.exe/]BET[.Playground.Core/]BET[.Playground.Core.EXE.
*
*
* at System.Reflection.RuntimeAssembly._nLoad(AssemblyName fileName, String codeBase, Evidence assemblySecurity, RuntimeAssembly locationHint, StackCrawlMark& stackMark, IntPtr pPrivHostBinder, Boolean throwOnFileNotFound, Boolean forIntrospection, Boolean suppressSecurityChecks)
* at System.Reflection.RuntimeAssembly.nLoad(AssemblyName fileName, String codeBase, Evidence assemblySecurity, RuntimeAssembly locationHint, StackCrawlMark& stackMark, IntPtr pPrivHostBinder, Boolean throwOnFileNotFound, Boolean forIntrospection, Boolean suppressSecurityChecks)
* at System.Reflection.RuntimeAssembly.InternalLoadAssemblyName(AssemblyName assemblyRef, Evidence assemblySecurity, RuntimeAssembly reqAssembly, StackCrawlMark& stackMark, IntPtr pPrivHostBinder, Boolean throwOnFileNotFound, Boolean forIntrospection, Boolean suppressSecurityChecks)
* at System.Reflection.RuntimeAssembly.InternalLoad(String assemblyString, Evidence assemblySecurity, StackCrawlMark& stackMark, IntPtr pPrivHostBinder, Boolean forIntrospection)
* at System.Reflection.RuntimeAssembly.InternalLoad(String assemblyString, Evidence assemblySecurity, StackCrawlMark& stackMark, Boolean forIntrospection)
* at System.Reflection.Assembly.Load(String assemblyString)
* at System.Runtime.Serialization.FormatterServices.LoadAssemblyFromString(String assemblyName)
* at System.Reflection.MemberInfoSerializationHolder..ctor(SerializationInfo info, StreamingContext context)
* at System.AppDomain.add_AssemblyLoad(AssemblyLoadEventHandler value)
* at _BET_.Playground.Core.AssemblyLocator.Init(AppDomain domain) in ..\]BET[.Playground\]BET[.Playground.Core\Assembly.cs:line 14
* at _BET_.Playground.UnitTests.Interop.TestNET2Caller_AppDomain3_CreateCom2() in ..\]BET[.Playground\]BET[.Playground.UnitTests\Interop.cs:line 529
*
*/
}
}
public void TestNET45Caller_AppDomain3_CreateCom2()
{
Assembly net45Caller = Assembly.LoadFrom(TestAssembly45RelativePath);
AppDomainSetup setup = new AppDomainSetup()
{
PrivateBinPath = net45Caller.CodeBase,
ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
//ApplicationBase = net45Caller.CodeBase, // -> AssemblyLocator will crash
ApplicationName = "TestNET45Caller",
SandboxInterop = true,
ShadowCopyFiles = Boolean.TrueString,
TargetFrameworkName = ".NETFramework,Version=v4.5",
};
setup.SetConfigurationBytes(System.Text.Encoding.UTF8.GetBytes(NET45Config));
System.Security.Policy.Evidence evidence = new System.Security.Policy.Evidence(AppDomain.CurrentDomain.Evidence);
evidence.AddAssemblyEvidence(new System.Security.Policy.ApplicationDirectory(@"..\..\..\]BET[.Playground.Interop.COM.NET45Caller\bin\Debug\"));
// create domain
AppDomain net45CallerDomain = AppDomain.CreateDomain(
"TestNET45Caller",
evidence,
setup
);
_BET_.Playground.Core.AssemblyLocator.Init(net45CallerDomain);
try
{
var handle = net45CallerDomain.CreateComInstanceFrom(net45Caller.ManifestModule.FullyQualifiedName, net45Caller.GetType().FullName);
var prg = handle.Unwrap();
var callCom = prg.GetType().GetMethod("CallCom");
var result = callCom.Invoke(prg, null) as string;
Assert.AreEqual <string>(ErrorMsg, result); // fail
Assert.Inconclusive(InconclusiveMsg);
}
catch (Exception ex)
{
// Could not load type 'System.Reflection.RuntimeAssembly' from
// assembly 'Playground.Interop.COM.NET2Caller, Version=1.0.0.0,
// Culture =neutral, PublicKeyToken=null'
if (ex.HResult == -2146233054)
{
Assert.Fail($"Expected Fail 1: {ex.Message}");
}
// Could not load file or assembly 'Playground.Interop.COM.NET2Caller,
// Version =1.0.0.0, Culture=neutral, PublicKeyToken=null' or one of
// its dependencies. Das System kann die angegebene Datei nicht finden.
if (ex.HResult == -2147024894)
{
Assert.Fail($"Expected Fail 2: {ex.Message}");
}
// Could not load file or assembly 'Playground.Interop.COM.NET2Caller,
// Version =1.0.0.0, Culture=neutral, PublicKeyToken=null' or one of
// its dependencies. Die Syntax für den Dateinamen, Verzeichnisnamen
// oder die Datenträgerbezeichnung ist falsch.
if (ex.HResult == -2147024773)
{
Assert.Fail($"Expected Fail 3: {ex.Message}");
}
Assert.Fail($"Unknown Fail: {ex.Message}");
}
finally
{
AppDomain.Unload(net45CallerDomain);
}
}
public void TestNET45Caller_AppDomain2_CustomDomain1()
{
AppDomainSetup setup = new AppDomainSetup()
{
PrivateBinPath = TestPath,
ApplicationBase = TestPath,
ApplicationName = "TestNET45Caller",
SandboxInterop = true,
ShadowCopyFiles = Boolean.TrueString,
TargetFrameworkName = ".NETFramework,Version=v4.5"
};
setup.SetConfigurationBytes(System.Text.Encoding.UTF8.GetBytes(NET2Config));
System.Security.Policy.Evidence evidence = new System.Security.Policy.Evidence(AppDomain.CurrentDomain.Evidence);
evidence.AddAssemblyEvidence(new System.Security.Policy.ApplicationDirectory(TestPath));
Type proxy = typeof(Proxy);
// create domain
AppDomain net45CallerDomain = AppDomain.CreateDomain(
"TestNET45Caller",
evidence,
setup
);
try
{
var prg = (Proxy)net45CallerDomain.CreateInstanceAndUnwrap(proxy.Assembly.FullName, proxy.FullName);
var assembly = prg.GetAssembly(TestAssembly45RelativePath);
var instance = Activator.CreateInstance(assembly.GetType(TestObject45));
var call = assembly.GetType(TestObject45).GetMethod(TestMethod);
var result = call.Invoke(instance, null) as string;
Assert.AreEqual <string>(ErrorMsg, result); // fail
}
catch (Exception ex)
{
if (ex.HResult == -2146233054)
{
Assert.Fail($"Expected Fail 1: {ex.Message}");
}
if (ex.HResult == -2147024894)
{
Assert.Fail($"Expected Fail 2: {ex.Message}");
}
if (ex.HResult == -2147024773)
{
Assert.Fail($"Expected Fail 3: {ex.Message}");
}
Assert.Fail($"Unknown Fail: {ex.Message}");
}
finally
{
AppDomain.Unload(net45CallerDomain);
}
Assert.Inconclusive(InconclusiveMsg);
}
/// <summary>
/// Create an instance of the wrapped ITask for a batch run of the task.
/// </summary>
public ITask CreateTaskInstance(ElementLocation taskLocation, TaskLoggingContext taskLoggingContext, AppDomainSetup appDomainSetup, bool isOutOfProc)
{
separateAppDomain = false;
separateAppDomain = loadedType.HasLoadInSeparateAppDomainAttribute();
taskAppDomain = null;
if (separateAppDomain)
{
if (!loadedType.Type.IsMarshalByRef)
{
taskLoggingContext.LogError
(
new BuildEventFileInfo(taskLocation),
"TaskNotMarshalByRef",
taskName
);
return null;
}
else
{
// Our task depend on this name to be precisely that, so if you change it make sure
// you also change the checks in the tasks run in separate AppDomains. Better yet, just don't change it.
// Make sure we copy the appdomain configuration and send it to the appdomain we create so that if the creator of the current appdomain
// has done the binding redirection in code, that we will get those settings as well.
AppDomainSetup appDomainInfo = new AppDomainSetup();
// Get the current app domain setup settings
byte[] currentAppdomainBytes = appDomainSetup.GetConfigurationBytes();
// Apply the appdomain settings to the new appdomain before creating it
appDomainInfo.SetConfigurationBytes(currentAppdomainBytes);
taskAppDomain = AppDomain.CreateDomain(isOutOfProc ? "taskAppDomain (out-of-proc)" : "taskAppDomain (in-proc)", null, appDomainInfo);
// Hook up last minute dumping of any exceptions
taskAppDomain.UnhandledException += new UnhandledExceptionEventHandler(ExceptionHandling.UnhandledExceptionHandler);
}
}
// instantiate the task in given domain
if (taskAppDomain == null || taskAppDomain == AppDomain.CurrentDomain)
{
// perf improvement for the same appdomain case - we already have the type object
// and don't want to go through reflection to recreate it from the name.
taskInstance = (ITask)Activator.CreateInstance(loadedType.Type);
return taskInstance;
}
if (loadedType.Assembly.AssemblyFile != null)
{
taskInstance = (ITask)taskAppDomain.CreateInstanceFromAndUnwrap(loadedType.Assembly.AssemblyFile, loadedType.Type.FullName);
// this will force evaluation of the task class type and try to load the task assembly
Type taskType = taskInstance.GetType();
// If the types don't match, we have a problem. It means that our AppDomain was able to load
// a task assembly using Load, and loaded a different one. I don't see any other choice than
// to fail here.
if (taskType != loadedType.Type)
{
taskLoggingContext.LogError
(
new BuildEventFileInfo(taskLocation),
"ConflictingTaskAssembly",
loadedType.Assembly.AssemblyFile,
loadedType.Type.Assembly.Location
);
taskInstance = null;
}
}
else
{
taskInstance = (ITask)taskAppDomain.CreateInstanceAndUnwrap(loadedType.Type.Assembly.FullName, loadedType.Type.FullName);
}
return taskInstance;
}