public static Foo GetRemote (AppDomain domain)
{
Foo test = (Foo) domain.CreateInstanceAndUnwrap (
typeof (Foo).Assembly.FullName,
typeof (Foo).FullName, new object [0]);
return test;
}
static CrossDomainTester CreateCrossDomainTester (AppDomain domain)
{
Type testerType = typeof (CrossDomainTester);
return (CrossDomainTester) domain.CreateInstanceAndUnwrap (
testerType.Assembly.FullName, testerType.FullName, false,
BindingFlags.Public | BindingFlags.Instance, null, new object [0],
CultureInfo.InvariantCulture, new object [0], domain.Evidence);
}
/// <summary>
/// Generates the license file.
/// </summary>
protected override void ExecuteTask()
{
FileInfo licensesFile = null;
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Assemblies.BaseDirectory == null)
{
Assemblies.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
// get the output .licenses file
if (OutputFile == null)
{
try {
licensesFile = new FileInfo(Project.GetFullPath(Target + ".licenses"));
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2015"), Target), Location, ex);
}
}
else
{
licensesFile = OutputFile;
}
// make sure the directory for the .licenses file exists
if (!licensesFile.Directory.Exists)
{
licensesFile.Directory.Create();
}
// determine whether .licenses file need to be recompiled
if (!NeedsCompiling(licensesFile))
{
return;
}
Log(Level.Verbose, ResourceUtils.GetString("String_CompilingLicenseUsingTarget"),
InputFile.FullName, licensesFile.FullName, Target);
if (HasCommandLineCompiler)
{
// the command line compiler does not allow us to specify the
// full path to the output file, so we have it create the licenses
// file in a temp directory, and copy it to its actual output
// location
// use a newly created temporary directory as working directory
BaseDirectory = FileUtils.GetTempDirectory();
try {
// set target assembly for generated licenses file
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/target:\"{0}\"", Target)));
// set input filename
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/complist:\"{0}\"", InputFile.FullName)));
// set output directory
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/outdir:\"{0}\"", BaseDirectory.FullName)));
// suppress display of startup banner
Arguments.Add(new Argument("/nologo"));
// adjust verbosity of tool if necessary
if (Verbose)
{
Arguments.Add(new Argument("/v"));
}
// use command line tool to compile licenses file
base.ExecuteTask();
// delete any existing output file
if (File.Exists(licensesFile.FullName))
{
File.Delete(licensesFile.FullName);
}
// copy licenses file to output file (with overwrite)
File.Copy(Path.Combine(BaseDirectory.FullName, Target + ".licenses"),
licensesFile.FullName, true);
} finally {
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = BaseDirectory;
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
else
{
// create new domain
AppDomain newDomain = AppDomain.CreateDomain("LicenseGatheringDomain",
AppDomain.CurrentDomain.Evidence);
LicenseGatherer licenseGatherer = (LicenseGatherer)
newDomain.CreateInstanceAndUnwrap(typeof(LicenseGatherer).Assembly.FullName,
typeof(LicenseGatherer).FullName, false, BindingFlags.Public | BindingFlags.Instance,
null, new object[0], CultureInfo.InvariantCulture, new object[0],
AppDomain.CurrentDomain.Evidence);
licenseGatherer.CreateLicenseFile(this, licensesFile.FullName);
// unload newly created domain
AppDomain.Unload(newDomain);
}
}
public void Create(IScriptHost host)
{
try
{
m_scriptHost = host;
((IScriptHostWithResourceData)host).GetResourceName(out var nameString);
string resourceName = Marshal.PtrToStringAnsi(nameString);
bool useTaskScheduler = true;
bool useSyncContext = false;
#if IS_FXSERVER
string basePath = "";
{
// we can't invoke natives if not doing this
InternalManager.ScriptHost = host;
basePath = Native.API.GetResourcePath(resourceName);
useTaskScheduler = Native.API.GetNumResourceMetadata(resourceName, "clr_disable_task_scheduler") == 0;
useSyncContext = Native.API.GetNumResourceMetadata(resourceName, "clr_experimental_2021_12_31_use_sync_context") > 0;
if (host is IScriptHostWithManifest manifestHost)
{
if (manifestHost.IsManifestVersionV2Between("bodacious", ""))
{
useTaskScheduler = false;
}
}
}
#endif
m_appDomain = AppDomain.CreateDomain($"ScriptDomain_{m_instanceId}", AppDomain.CurrentDomain.Evidence, new AppDomainSetup()
{
#if IS_FXSERVER
ApplicationBase = basePath
#endif
});
m_appDomain.SetupInformation.ConfigurationFile = "dummy.config";
m_intManager = (InternalManager)m_appDomain.CreateInstanceAndUnwrap(typeof(InternalManager).Assembly.FullName, typeof(InternalManager).FullName);
if (useTaskScheduler)
{
m_intManager.CreateTaskScheduler();
}
m_intManager.SetConfiguration(useSyncContext: useSyncContext);
m_intManager.SetResourceName(resourceName);
// TODO: figure out a cleaner solution to Mono JIT corruption so server doesn't have to be slower
#if IS_FXSERVER && !OS_WIN
m_intManager.SetScriptHost(new WrapScriptHost(host), m_instanceId);
#else
m_intManager.SetScriptHost(Marshal.GetIUnknownForObject(host), m_instanceId);
m_comRuntime = Marshal.GetComInterfaceForObject(this, typeof(IScriptRuntime));
#endif
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
if (e.InnerException != null)
{
Debug.WriteLine(e.InnerException.ToString());
}
throw;
}
}
private static int _appDomainCount = 0; // only used to give each AppDomain a unique name
public AppDomainInfo(LoggerBase log, PropellerSettings settings, PropellerModuleSettings moduleSettings, ISettingsSaver saver)
{
ModuleSettings = moduleSettings;
Saver = saver;
_log = log;
_activeConnections = 0;
// Determine the temporary folder that DLLs will be copied to
var tempFolder = settings.TempFolder ?? Path.GetTempPath();
Directory.CreateDirectory(tempFolder);
// Find a new folder to put the DLL/EXE files into
int j = 1;
do
{
TempPathUsed = Path.Combine(tempFolder, "propeller-tmp-" + (j++));
}while (Directory.Exists(TempPathUsed));
Directory.CreateDirectory(TempPathUsed);
// Copy all the DLLs/EXEs to the temporary folder
foreach (var sourceFile in
new[] { typeof(PropellerEngine), typeof(IPropellerModule), typeof(HttpServer), typeof(Ut) }.Select(type => type.Assembly.Location).Concat(
new[] { "*.exe", "*.dll", "*.pdb" }.SelectMany(ext => Directory.EnumerateFiles(Path.GetDirectoryName(moduleSettings.ModuleDll), ext))))
{
var destFile = Path.Combine(TempPathUsed, Path.GetFileName(sourceFile));
if (File.Exists(destFile))
{
_log.Warn(2, "Skipping file {0} because destination file {1} already exists.".Fmt(sourceFile, destFile));
}
else
{
_log.Info(2, "Copying file {0} to {1}".Fmt(sourceFile, destFile));
File.Copy(sourceFile, destFile);
}
}
// Create an AppDomain
var setup = new AppDomainSetup {
ApplicationBase = TempPathUsed, PrivateBinPath = TempPathUsed
};
AppDomain = AppDomain.CreateDomain("Propeller AppDomain #{0}, module {1}".Fmt(_appDomainCount++, moduleSettings.ModuleName), null, setup);
RunnerProxy = (AppDomainRunner)AppDomain.CreateInstanceAndUnwrap("Propeller", "RT.Propeller.AppDomainRunner");
RunnerProxy.Init(
Path.Combine(TempPathUsed, Path.GetFileName(moduleSettings.ModuleDll)),
moduleSettings.ModuleType,
moduleSettings.ModuleName,
moduleSettings.Settings,
_log,
saver);
IEnumerable <string> filters = moduleSettings.MonitorFilters ?? Enumerable.Empty <string>();
if (RunnerProxy.FileFiltersToBeMonitoredForChanges != null)
{
filters = filters.Concat(RunnerProxy.FileFiltersToBeMonitoredForChanges);
}
foreach (var filter in filters.Concat(moduleSettings.ModuleDll))
{
addFileSystemWatcher(Path.GetDirectoryName(filter), Path.GetFileName(filter));
}
UrlMappings = moduleSettings.Hooks.Select(hook => new UrlMapping(hook, Handle, true)).ToArray();
_log.Info("Module {0} URLs: {1}".Fmt(moduleSettings.ModuleName, moduleSettings.Hooks.JoinString("; ")));
}
/// <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;
}
public int RunTest()
{
try
{
object t = null;
string s = (string)t;
AppDomain domain = AppDomain.CreateDomain("testdomain");
Remo server = (Remo)domain.CreateInstanceAndUnwrap(typeof(Test).Assembly.FullName, "Remo");
if (System.Threading.Thread.GetDomainID() == server.GetDomainId())
{
throw new TestException("Object not created in new domain", 1);
}
Dada d = new Dada();
d.p = 22;
server.Run();
server.Run2(88, "hola");
server.Run3(99, d, "adeu");
string r = server.Run4(200, d, "que");
CheckValue(r, "vist", 140);
try {
server.Run5(200, d, "que");
throw new TestException("Exception expected", 150);
}
catch (Exception ex) {
CheckValue(ex.Message, "peta", 151);
}
Dada d2;
d = server.Run6(99, out d2, "adeu");
CheckValue(d.p, 987, 161);
CheckValue(d2.p, 987, 162);
d.p = 22;
d2 = server.Run7(d);
CheckValue(d.p, 22, 170);
CheckValue(d2.p, 33, 170);
byte[] ba = new byte[5];
for (byte n = 0; n < ba.Length; n++)
{
ba [n] = n;
}
server.Run8(ba);
for (int n = 0; n < ba.Length; n++)
{
CheckValue(ba[n], (byte)(ba.Length - n), 180);
}
StringBuilder sb = new StringBuilder("un");
server.Run9_1(sb);
Test.CheckValue(sb, new StringBuilder("un"), 190);
StringBuilder sb2 = new StringBuilder("prefix");
StringBuilder sb3 = server.Run9_2(sb2);
Test.CheckValue(sb2, new StringBuilder("prefix"), 192);
Test.CheckValue(sb3, new StringBuilder("prefix-middle"), 192);
StringBuilder sb4 = server.Run9_3(sb3);
Test.CheckValue(sb3, new StringBuilder("prefix-middle"), 193);
Test.CheckValue(sb4, new StringBuilder("prefix-middle-end"), 193);
}
catch (TestException ex)
{
Console.WriteLine("TEST ERROR ({0}): {1}", ex.Code, ex);
return(ex.Code);
}
catch (Exception ex)
{
Console.WriteLine("TEST ERROR: " + ex);
return(-1);
}
return(0);
}
private static void Marshalling()
{
AppDomain adCallingThreadDomain = Thread.GetDomain();
string callingDomainName = adCallingThreadDomain.FriendlyName;
Console.WriteLine("Default AppDomain's friendly name={0}", callingDomainName);
string exeAssembly = Assembly.GetEntryAssembly().FullName;
Console.WriteLine("Main assembly={0}", exeAssembly);
AppDomain ad2 = null;
// *** DEMO 1:使用Marshal-by-Reference进行跨APPDomain通信 ***
Console.WriteLine("{0}Demo #1", Environment.NewLine);
// 新建一个AppDomain(从当前AppDomain继承安全性和配置)
ad2 = AppDomain.CreateDomain("AD #2", null, null);
MarshalByRefType mbrt = null;
// 将我们的程序集加载到新AppDomain中，构造一个对象，把它
// 封送回我们的AppDomain（实际得到对一个代理的引用）
mbrt = (MarshalByRefType)
ad2.CreateInstanceAndUnwrap(exeAssembly, "MarshalByRefType");
// CLR 在类型上撒谎了
Console.WriteLine("Type={0}", mbrt.GetType());
// 证明得到的是对一个代理对象的引用
Console.WriteLine("Is proxy={0}", RemotingServices.IsTransparentProxy(mbrt));
// 看起来像是在MarshalByRefType上调用一个方法，实则不然
// 我们是在代理类型上调用一个方法，代理使线程切换到拥有对象的
// 那个AppDomain，并在真实的对象上调用这个方法
mbrt.SomeMethod();
// 卸载新的AppDomain
AppDomain.Unload(ad2);
// mbrt引用一个有效的代理对象；代理对象引用一个无效的AppDomain
try
{
// 在代理类型上调用一个方法，AppDomain无效，造成抛出异常
mbrt.SomeMethod();
Console.WriteLine("Successful call.");
}
catch (AppDomainUnloadedException)
{
Console.WriteLine("Failed call.");
}
// *** DEMO 2:使用Marshal-by-Value进行跨AppDomain通信 ***
Console.WriteLine("{0}Demo #2", Environment.NewLine);
// 新建一个AppDomain（从当前AppDomain继承安全性和配置）
ad2 = AppDomain.CreateDomain("AD #2", null, null);
// 将我们的程序集加载到新AppDomain中，构造一个对象，把它
// 封送回我们的AppDomain（实际得到对一个代理的引用）
mbrt = (MarshalByRefType)
ad2.CreateInstanceAndUnwrap(exeAssembly, "MarshalByRefType");
// 对象的方法返回所返回对象的副本；
// 对象按值（而非按引用）封送
MarshalByValType mbvt = mbrt.MethodWithReturn();
// 证明得到的不是对一个代理对象的引用
Console.WriteLine("Is proxy={0}", RemotingServices.IsTransparentProxy(mbvt));
// 看起来是在MarshalByValType上调用一个方法，实际也是如此
Console.WriteLine("Returned object created " + mbvt.ToString());
// 卸载新的AppDomain
AppDomain.Unload(ad2);
// mbvt引用有效的对象：卸载AppDomain没有影响
try
{
// 我们是在对象上调用一个方法：不会抛出异常
Console.WriteLine("Returned object created " + mbvt.ToString());
Console.WriteLine("Successful call.");
}
catch (AppDomainUnloadedException)
{
Console.WriteLine("Failed call.");
}
// DEMO 3: 使用不可封送的类型进行跨AppDomain通信 ***
Console.WriteLine("{0}Demo #3", Environment.NewLine);
// 新建一个AppDomain（从当前AppDomain继承安全性和配置）
ad2 = AppDomain.CreateDomain("AD #2", null, null);
// 将我们的程序集加载到新AppDomain中，构造一个对象，把它
// 封送回我们的AppDomain（实际得到对一个代理的引用）
mbrt = (MarshalByRefType)
ad2.CreateInstanceAndUnwrap(exeAssembly, "MarshalByRefType");
// 对象的方法返回一个不可封送的对象：抛出异常
NonMarshalableType nmt = mbrt.MethodArgAndReturn(callingDomainName);
// 这里永远执行不到...
}
private static ProxyNancyReferenceProber CreateRemoteReferenceProber(AppDomain appDomain)
{
return((ProxyNancyReferenceProber)appDomain.CreateInstanceAndUnwrap(
typeof(ProxyNancyReferenceProber).Assembly.FullName,
typeof(ProxyNancyReferenceProber).FullName));
}
/// <summary>
/// Creates a <see cref="MServer"/> instance.
/// </summary>
/// <param name="domain">The domain name</param>
/// <param name="createNewAppDomain">true if MServerFactory should create a dedicated
/// AppDomain for the <see cref="MServer"/> instance.</param>
/// <returns>A <see cref="MServer"/> instance.</returns>
public static MServer CreateServer(String domain, bool createNewAppDomain)
{
if (domain == null)
{
throw new ArgumentNullException("domain");
}
if (domains.Contains(domain))
{
throw new DomainAlreadyExistsException(domain);
}
String typeName = ConfigurationSettings.AppSettings[CustomServerConfigurationKey];
Type serverType = null;
if (typeName != null && typeName != String.Empty)
{
// TODO: Allow custom servers..
}
else
{
serverType = typeof(MDefaultServer);
}
if (createNewAppDomain)
{
// Lets create a seperated AppDomain for this server
AppDomain currentDomain = AppDomain.CurrentDomain;
String baseDir = new FileInfo(currentDomain.BaseDirectory).FullName;
String configFile = String.Format(
"{0}/{1}.config",
baseDir, domain);
AppDomainSetup setup = new AppDomainSetup();
setup.ApplicationName = domain;
setup.ApplicationBase = currentDomain.SetupInformation.ApplicationBase;
setup.PrivateBinPath = currentDomain.SetupInformation.PrivateBinPath;
setup.ConfigurationFile = configFile;
// setup.ShadowCopyFiles = "false";
// setup.ShadowCopyDirectories = appBase;
Evidence baseEvidence = currentDomain.Evidence;
Evidence evidence = new Evidence(baseEvidence);
AppDomain newDomain = AppDomain.CreateDomain(
domain, evidence, setup);
object remoteInstance = newDomain.CreateInstanceAndUnwrap(
serverType.Assembly.FullName, serverType.FullName);
// Register the domain
domains.Add(domain, new DomainInfo(domain, remoteInstance as MServer, newDomain));
// As this already method "unwraps" the target object, its safe
// to return it - in an "wrapped" object we should invoke the
// class's constructor
return((MServer)remoteInstance);
}
else
{
object localInstance = Activator.CreateInstance(serverType);
// Register the domain
domains.Add(domain, new DomainInfo(domain, localInstance as MServer));
return((MServer)localInstance);
}
}
public static void Main(string[] args)
{
var containers = ContainerAdapterFactory.CreateAdapters().ToArray();
var benchmarks = BenchmarkFactory.CreateBenchmarks().ToArray();
var benchmarkResults = new List <BenchmarkResult>();
var existingBenchmarkResults = new List <BenchmarkResult>();
if (args != null && args.Any(a => a.Equals("-update", StringComparison.OrdinalIgnoreCase)))
{
existingBenchmarkResults.AddRange(XmlOutputReader.GetExistingBenchmarkResults(benchmarks, containers));
}
foreach (var container in containers)
{
AppDomain childDomain = null;
try
{
AppDomainSetup domainSetup = new AppDomainSetup()
{
ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile,
ApplicationName = AppDomain.CurrentDomain.SetupInformation.ApplicationName,
LoaderOptimization = LoaderOptimization.MultiDomainHost
};
childDomain = AppDomain.CreateDomain("AppDomain for " + container.Name, null, domainSetup);
ContainerAdapterRuntime runtime = (ContainerAdapterRuntime)childDomain.CreateInstanceAndUnwrap(
typeof(ContainerAdapterRuntime).Assembly.FullName,
typeof(ContainerAdapterRuntime).FullName);
var containerBenchmarkResults = runtime.Run(container.GetType(), existingBenchmarkResults);
benchmarkResults.AddRange(containerBenchmarkResults);
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(
" Container '{0}' failed: {1}",
container.Name,
ex.Message);
Console.ResetColor();
}
finally
{
if (childDomain != null)
{
AppDomain.Unload(childDomain);
}
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
}
Console.WriteLine();
}
XmlOutputReader.AddHistoricBenchmarkResults(benchmarkResults);
IOutput output = new MultiOutput(
new XmlOutput(),
new HtmlOutput(),
new MarkdownOutput(),
new CsvOutput(),
new CsvRateOutput(),
new ChartOutput(),
new ZipOutput(),
new JsonOutput(),
new GithubPagesOutput());
output.Create(benchmarks, benchmarkResults);
Console.WriteLine("Done");
}
private static AppDomainProxy CreateProxy(AppDomain domain)
{
Type typeProxy = typeof(AppDomainProxy);
return((AppDomainProxy)domain.CreateInstanceAndUnwrap(typeProxy.Assembly.FullName, typeProxy.FullName));
}
/// <summary>
/// Discovers all SolidDna plug-ins
/// </summary>
/// <param name="addinPath">The path to the add-in that is calling this setup (typically acquired using GetType().Assembly.Location)</param>
/// <param name="loadAll">True to find all plug-ins in the same folder as the SolidDna dll</param>
/// <param name="log">True to log the output of the loading. Use false when registering for COM</param>
/// <returns></returns>
public static List <SolidPlugIn> SolidDnaPlugIns(string addinPath, bool log, bool loadAll = true)
{
// Create new empty list
var assemblies = new List <SolidPlugIn>();
// Find all dll's in the same directory
if (loadAll)
{
// Log it
if (log)
{
Logger.LogDebugSource($"Loading all PlugIns...");
}
if (UseDetachedAppDomain)
{
// Invalid combination... cannot load all from cross domain
// (we don't create the PlugInDetails class for each item
Debugger.Break();
}
// Clear old list
PlugInDetails = new Dictionary <string, List <PlugInDetails> >();
// Add new based on if found
foreach (var path in Directory.GetFiles(addinPath, "*.dll", SearchOption.TopDirectoryOnly))
{
GetPlugIns(path, (plugin) =>
{
// Log it
if (log)
{
Logger.LogDebugSource($"Found plugin {plugin.AddInTitle} in {path}");
}
assemblies.Add(plugin);
});
}
}
// Or load explicit ones
else
{
// Log it
if (log)
{
Logger.LogDebugSource($"Explicitly loading {PlugInDetails?.Count} PlugIns...");
}
// For each assembly
foreach (var p in PlugInDetails)
{
// And each plug-in inside it
foreach (var path in p.Value)
{
try
{
// If we are called in the main domain, cross-load
if (UseDetachedAppDomain)
{
// Log it
if (log)
{
Logger.LogDebugSource($"Cross-domain loading PlugIn {path.AssemblyFullName}...");
}
// Create instance of the plug-in via cross-domain and cast back
var plugin = (dynamic)PlugInAppDomain.CreateInstanceAndUnwrap(
path.AssemblyFullName,
path.TypeFullName);
// If we got it, add it to the list
if (plugin != null)
{
assemblies.Add(plugin);
}
else if (log)
{
// Log error
Logger.LogErrorSource($"Failed to create instance of PlugIn {path.AssemblyFullName}");
}
}
else
{
GetPlugIns(path.FullPath, (plugin) =>
{
// Log it
if (log)
{
Logger.LogDebugSource($"Found plugin {plugin.AddInTitle} in {path}");
}
assemblies.Add(plugin);
});
}
}
catch (Exception ex)
{
// Log error
// Logger?.LogCriticalSource($"Unexpected error: {ex}");
}
}
}
}
// Log it
if (log)
{
Logger.LogDebugSource($"Loaded {assemblies?.Count} plug-ins from {addinPath}");
}
return(assemblies);
}
public static int Main(string [] args)
{
AppDomain domain = AppDomain.CreateDomain("newdomain");
Test test = (Test)domain.CreateInstanceAndUnwrap(typeof(Test).Assembly.FullName, typeof(Test).FullName);
bool didAbort;
Test testHere = new Test();
if (!RemotingServices.IsTransparentProxy(test))
{
Console.WriteLine("test is no proxy");
return(5);
}
try {
test.abortOtherIndirect(testHere);
} catch (ThreadAbortException e) {
object state = e.ExceptionState;
Thread.ResetAbort();
if ((JustSomeClass)state != testHere.other)
{
Console.WriteLine("other class not preserved in state");
return(16);
}
}
try {
didAbort = false;
test.abortString();
} catch (ThreadAbortException e) {
object state;
state = e.ExceptionState;
Thread.ResetAbort();
didAbort = true;
if (state == null)
{
Console.WriteLine("state is null");
return(13);
}
else
{
if (RemotingServices.IsTransparentProxy(state))
{
Console.WriteLine("state is proxy");
return(1);
}
if (!((string)state).Equals("bla"))
{
Console.WriteLine("state is wrong: " + (string)state);
return(2);
}
}
if (RemotingServices.IsTransparentProxy(e))
{
Console.WriteLine("exception is proxy");
return(3);
}
if (test.getState() != null)
{
Console.WriteLine("have state");
return(12);
}
}
if (!didAbort)
{
Console.WriteLine("no abort");
return(4);
}
try {
didAbort = false;
test.abortProxy();
} catch (ThreadAbortException e) {
object state;
state = e.ExceptionState;
Thread.ResetAbort();
didAbort = true;
if (state == null)
{
Console.WriteLine("state is null");
return(14);
}
else
{
if (!RemotingServices.IsTransparentProxy(state))
{
Console.WriteLine("state is not proxy");
return(6);
}
if (((Test)state).getInt() != 123)
{
Console.WriteLine("state doesn't work");
return(15);
}
}
if (RemotingServices.IsTransparentProxy(e))
{
Console.WriteLine("exception is proxy");
return(7);
}
}
if (!didAbort)
{
Console.WriteLine("no abort");
return(8);
}
try {
didAbort = false;
test.abortOther();
} catch (ThreadAbortException e) {
object state = null;
bool stateExc = false;
didAbort = true;
try {
state = e.ExceptionState;
Console.WriteLine("have state");
} catch (Exception) {
stateExc = true;
/* FIXME: if we put this after the try/catch, mono
* quietly quits */
Thread.ResetAbort();
}
if (!stateExc)
{
Console.WriteLine("no state exception");
return(9);
}
if (RemotingServices.IsTransparentProxy(e))
{
Console.WriteLine("exception is proxy");
return(10);
}
}
if (!didAbort)
{
Console.WriteLine("no abort");
return(11);
}
// #539394
// Calling Thread.Abort () from a remoting call throws a ThreadAbortException which
// cannot be caught because the exception handling code is confused by the domain
// transitions
bool res = false;
Thread thread = new Thread(delegate() {
AppDomain d = AppDomain.CreateDomain("foo");
var t = (Test1)d.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName,
"Test1");
res = t.Run();
});
thread.Start();
thread.Join();
if (!res)
{
return(12);
}
Console.WriteLine("done");
return(0);
}
public static T CreateInstance <T>(AppDomain domain)
{
T obj = (T)domain.CreateInstanceAndUnwrap(typeof(T).Assembly.FullName, typeof(T).FullName);
return(obj);
}
static Program GetRemote (AppDomain domain)
{
Program test = (Program) domain.CreateInstanceAndUnwrap (
typeof (Program).Assembly.FullName,
typeof (Program).FullName, new object [0]);
return test;
}
static SingleRunner CreateRunnerInAppDomain()
{
var rc = (SingleRunner)_ad.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(SingleRunner).FullName);
return(rc);
}
public object CreateObject(string assemblyName, string typeName)
{
return(appDomain.CreateInstanceAndUnwrap(assemblyName, typeName));
}
/// <summary>
/// Loads the FSharpLint worker from FSharpLint.Application in a
/// separate app domain and returns a proxy to the worker.
/// </summary>
/// <returns>Proxy to the worker from FSharpLint.Application.</returns>
private IFSharpLintWorker GetWorker(AppDomain appDomain)
{
return((FSharpLint.Worker.IFSharpLintWorker)appDomain.CreateInstanceAndUnwrap("FSharpLint.Application", "FSharpLint.Application.FSharpLintWorker+FSharpLintWorker"));
}
static int Main(string [] args)
{
string assembly = null;
string directory = null;
string lockfile = null;
string name = null;
string logname = null;
var assebmlyArgs = new List <string>();
foreach (string s in args)
{
if (s.Length > 3 && s [0] == '-' && s [2] == ':')
{
string arg = s.Substring(3);
switch (Char.ToLower(s [1]))
{
case 'd': directory = arg; break;
case 'l': lockfile = arg; break;
case 'n': name = arg; break;
case 'm': logname = arg; break;
default: Usage(); break;
}
}
else
{
if (assembly != null)
{
assebmlyArgs.Add(s);
}
else
{
assembly = s;
}
}
}
if (logname == null)
{
logname = assembly;
}
if (assembly == null)
{
error(logname, "Assembly name is missing");
Usage();
}
if (directory != null)
{
if (Syscall.chdir(directory) != 0)
{
error(logname, "Could not change to directory {0}", directory);
return(1);
}
}
// Use lockfile to allow only one instance
if (lockfile == null)
{
lockfile = String.Format("/tmp/{0}.lock", Path.GetFileName(assembly));
}
int lfp = Syscall.open(lockfile, OpenFlags.O_RDWR | OpenFlags.O_CREAT | OpenFlags.O_EXCL,
FilePermissions.S_IRUSR | FilePermissions.S_IWUSR | FilePermissions.S_IRGRP);
if (lfp < 0)
{
// Provide some useful info
if (File.Exists(lockfile))
{
error(logname, String.Format("Lock file already exists: {0}", lockfile));
}
else
{
error(logname, String.Format("Cannot open/create lock file exclusively: {0}", lockfile));
}
return(1);
}
if (Syscall.lockf(lfp, LockfCommand.F_TLOCK, 0) < 0)
{
info(logname, "Daemon is already running.");
return(0);
}
try {
// Write pid to lock file
string pid = Syscall.getpid().ToString() + Environment.NewLine;
IntPtr buf = Marshal.StringToCoTaskMemAnsi(pid);
Syscall.write(lfp, buf, (ulong)pid.Length);
Marshal.FreeCoTaskMem(buf);
// Create new AppDomain to run service
AppDomainSetup setup = new AppDomainSetup();
setup.ApplicationBase = Environment.CurrentDirectory;
setup.ConfigurationFile = Path.Combine(Environment.CurrentDirectory, assembly + ".config");
setup.ApplicationName = logname;
AppDomain newDomain = AppDomain.CreateDomain(logname, AppDomain.CurrentDomain.Evidence, setup);
MonoServiceRunner rnr = newDomain.CreateInstanceAndUnwrap(
typeof(MonoServiceRunner).Assembly.FullName,
typeof(MonoServiceRunner).FullName,
true,
BindingFlags.Default,
null,
new object [] { assembly, name, logname, assebmlyArgs.ToArray() },
null, null, null) as MonoServiceRunner;
if (rnr == null)
{
error(logname, "Internal Mono Error: Could not create MonoServiceRunner.");
return(1);
}
return(rnr.StartService());
} finally {
// Remove lock file when done
if (File.Exists(lockfile))
{
File.Delete(lockfile);
}
}
}
/// <summary>
/// Load the script from an assembly into an AppDomain.
/// </summary>
/// <param name='dom'></param>
/// <param name='assembly'></param>
/// <param name='stateSource'></param>
/// <returns>false if load failed, true if suceeded</returns>
public bool Load(AppDomain dom, string assembly, StateSource stateSource)
{
m_Assembly = assembly;
m_stateSource = stateSource;
ApiManager am = new ApiManager();
foreach (string api in am.GetApis())
{
m_Apis[api] = am.CreateApi(api);
m_Apis[api].Initialize(Engine, Part, ScriptTask, m_coopSleepHandle);
}
try
{
object[] constructorParams;
Assembly scriptAssembly = dom.Load(Path.GetFileNameWithoutExtension(assembly));
Type scriptType = scriptAssembly.GetType("SecondLife.XEngineScript");
if (scriptType != null)
{
constructorParams = new object[] { m_coopSleepHandle };
}
else if (!m_coopTermination)
{
scriptType = scriptAssembly.GetType("SecondLife.Script");
constructorParams = null;
}
else
{
m_log.ErrorFormat(
"[SCRIPT INSTANCE]: Not starting script {0} (id {1}) in part {2} (id {3}) in object {4} in {5}. You must remove all existing {6}* script DLL files before using enabling co-op termination"
+ ", either by setting DeleteScriptsOnStartup = true in [XEngine] for one run"
+ " or by deleting these files manually.",
ScriptTask.Name, ScriptTask.ItemID, Part.Name, Part.UUID, Part.ParentGroup.Name, Engine.World.Name, assembly);
return(false);
}
// m_log.DebugFormat(
// "[SCRIPT INSTANCE]: Looking to load {0} from assembly {1} in {2}",
// scriptType.FullName, Path.GetFileNameWithoutExtension(assembly), Engine.World.Name);
if (dom != System.AppDomain.CurrentDomain)
{
m_Script
= (IScript)dom.CreateInstanceAndUnwrap(
Path.GetFileNameWithoutExtension(assembly),
scriptType.FullName,
false,
BindingFlags.Default,
null,
constructorParams,
null,
null,
null);
}
else
{
m_Script
= (IScript)scriptAssembly.CreateInstance(
scriptType.FullName,
false,
BindingFlags.Default,
null,
constructorParams,
null,
null);
}
//ILease lease = (ILease)RemotingServices.GetLifetimeService(m_Script as ScriptBaseClass);
//RemotingServices.GetLifetimeService(m_Script as ScriptBaseClass);
// lease.Register(this);
}
catch (Exception e)
{
m_log.ErrorFormat(
"[SCRIPT INSTANCE]: Not starting script {0} (id {1}) in part {2} (id {3}) in object {4} in {5}. Error loading assembly {6}. Exception {7}{8}",
ScriptTask.Name, ScriptTask.ItemID, Part.Name, Part.UUID, Part.ParentGroup.Name, Engine.World.Name, assembly, e.Message, e.StackTrace);
return(false);
}
try
{
foreach (KeyValuePair <string, IScriptApi> kv in m_Apis)
{
m_Script.InitApi(kv.Key, kv.Value);
}
// // m_log.Debug("[Script] Script instance created");
Part.SetScriptEvents(ItemID,
(int)m_Script.GetStateEventFlags(State));
}
catch (Exception e)
{
m_log.ErrorFormat(
"[SCRIPT INSTANCE]: Not starting script {0} (id {1}) in part {2} (id {3}) in object {4} in {5}. Error initializing script instance. Exception {6}{7}",
ScriptTask.Name, ScriptTask.ItemID, Part.Name, Part.UUID, Part.ParentGroup.Name, Engine.World.Name, e.Message, e.StackTrace);
return(false);
}
m_SaveState = true;
string savedState = Path.Combine(Path.GetDirectoryName(assembly),
ItemID.ToString() + ".state");
if (File.Exists(savedState))
{
string xml = String.Empty;
try
{
FileInfo fi = new FileInfo(savedState);
int size = (int)fi.Length;
if (size < 512000)
{
using (FileStream fs = File.Open(savedState,
FileMode.Open, FileAccess.Read, FileShare.None))
{
Byte[] data = new Byte[size];
fs.Read(data, 0, size);
xml = Encoding.UTF8.GetString(data);
ScriptSerializer.Deserialize(xml, this);
AsyncCommandManager.CreateFromData(Engine,
LocalID, ItemID, ObjectID,
PluginData);
// m_log.DebugFormat("[Script] Successfully retrieved state for script {0}.{1}", PrimName, m_ScriptName);
Part.SetScriptEvents(ItemID,
(int)m_Script.GetStateEventFlags(State));
if (!Running)
{
m_startOnInit = false;
}
Running = false;
// we get new rez events on sim restart, too
// but if there is state, then we fire the change
// event
// We loaded state, don't force a re-save
m_SaveState = false;
m_startedFromSavedState = true;
}
}
else
{
m_log.WarnFormat(
"[SCRIPT INSTANCE]: Not starting script {0} (id {1}) in part {2} (id {3}) in object {4} in {5}. Unable to load script state file {6}. Memory limit exceeded.",
ScriptTask.Name, ScriptTask.ItemID, Part.Name, Part.UUID, Part.ParentGroup.Name, Engine.World.Name, savedState);
}
}
catch (Exception e)
{
m_log.ErrorFormat(
"[SCRIPT INSTANCE]: Not starting script {0} (id {1}) in part {2} (id {3}) in object {4} in {5}. Unable to load script state file {6}. XML is {7}. Exception {8}{9}",
ScriptTask.Name, ScriptTask.ItemID, Part.Name, Part.UUID, Part.ParentGroup.Name, Engine.World.Name, savedState, xml, e.Message, e.StackTrace);
}
}
// else
// {
// ScenePresence presence = Engine.World.GetScenePresence(part.OwnerID);
// if (presence != null && (!postOnRez))
// presence.ControllingClient.SendAgentAlertMessage("Compile successful", false);
// }
return(true);
}
/// <summary>
/// Initializes the current reader with respect to its environment.
/// </summary>
public void Initialize()
{
AppDomain tempDomainToLoadAssembly = null;
string tempDomainName = "AppInsightsDomain-" + Guid.NewGuid().ToString();
Stopwatch sw = Stopwatch.StartNew();
// The following approach is used to load Microsoft.WindowsAzure.ServiceRuntime assembly and read the required information.
// Create a new AppDomain and try to load the ServiceRuntime dll into it.
// Then using reflection, read and save all the properties we care about and unload the new AppDomain.
// This approach ensures that if the app is running in Azure Cloud Service, we read the necessary information deterministically
// and without interfering with any customer code which could be loading same/different version of Microsoft.WindowsAzure.ServiceRuntime.dll.
try
{
AppDomainSetup domaininfo = new AppDomainSetup();
domaininfo.ApplicationBase = Path.GetDirectoryName(AzureRoleEnvironmentContextReader.AssemblyLoaderType.Assembly.Location);
// Create a new AppDomain
tempDomainToLoadAssembly = AppDomain.CreateDomain(tempDomainName, null, domaininfo);
WindowsServerEventSource.Log.AzureRoleEnvironmentContextReaderAppDomainTroubleshoot(tempDomainName, " Successfully created with ApplicationBase: " + domaininfo.ApplicationBase);
// Load the RemoteWorker assembly to the new domain
tempDomainToLoadAssembly.Load(typeof(AzureServiceRuntimeAssemblyLoader).Assembly.FullName);
WindowsServerEventSource.Log.AzureRoleEnvironmentContextReaderAppDomainTroubleshoot(tempDomainName, " Successfully loaded assembly: " + typeof(AzureServiceRuntimeAssemblyLoader).Assembly.FullName);
// Any method invoked on this object will be executed in the newly created AppDomain.
AzureServiceRuntimeAssemblyLoader remoteWorker = (AzureServiceRuntimeAssemblyLoader)tempDomainToLoadAssembly.CreateInstanceAndUnwrap(AzureRoleEnvironmentContextReader.AssemblyLoaderType.Assembly.FullName, AzureRoleEnvironmentContextReader.AssemblyLoaderType.FullName);
bool success = remoteWorker.ReadAndPopulateContextInformation(out this.roleName, out this.roleInstanceName);
if (success)
{
WindowsServerEventSource.Log.AzureRoleEnvironmentContextReaderInitializedSuccess(this.roleName, this.roleInstanceName);
}
else
{
WindowsServerEventSource.Log.AzureRoleEnvironmentContextReaderInitializationFailed();
}
}
catch (Exception ex)
{
WindowsServerEventSource.Log.UnknownErrorOccured("AzureRoleEnvironmentContextReader Initialize", ex.ToString());
}
finally
{
try
{
if (tempDomainToLoadAssembly != null)
{
AppDomain.Unload(tempDomainToLoadAssembly);
WindowsServerEventSource.Log.AzureRoleEnvironmentContextReaderAppDomainTroubleshoot(tempDomainName, " Successfully Unloaded.");
WindowsServerEventSource.Log.AzureRoleEnvironmentContextReaderInitializationDuration(sw.ElapsedMilliseconds);
}
}
catch (Exception ex)
{
WindowsServerEventSource.Log.AzureRoleEnvironmentContextReaderAppDomainTroubleshoot(tempDomainName, "AppDomain unload failed with exception: " + ex.ToString());
}
}
}
private static T CreateInstance <T>(AppDomain domain)
{
return((T)domain.CreateInstanceAndUnwrap(typeof(T).Assembly.FullName,
typeof(T).FullName));
}
protected virtual void OnGUI()
{
this.exposersFolder = EditorGUILayout.TextField("Exposers Folder", this.exposersFolder);
EditorGUILayout.HelpBox("After generating, this current instance of Unity Editor will be unstable and might crash anytime.", MessageType.Warning);
if (GUILayout.Button("Generate") == true)
{
List <ExposedClass> classes = new List <ExposerGenerator.ExposedClass>();
// Manual init
classes.Add(new ExposedClass()
{
type = typeof(Renderer),
excluded = new List <string>()
{
"material", "materials", "sharedMaterial"
}
});
classes.Add(new ExposedClass()
{
type = typeof(MeshFilter),
excluded = new List <string>()
{
"mesh"
}
});
classes.Add(new ExposedClass()
{
type = typeof(Collider),
excluded = new List <string>()
{
"material"
}
});
classes.Add(new ExposedClass()
{
type = typeof(Transform),
included = new List <string>()
{
"localPosition", "localEulerAngles", "localScale"
}
});
Dictionary <string, string> installs = new Dictionary <string, string>();
NGUnityDetectorWindow.GetInstalls(installs);
foreach (var pair in installs)
{
string dllPath = Path.Combine(pair.Value, @"Editor\Data\Managed\UnityEngine.dll");
AppDomainSetup domaininfo = new AppDomainSetup();
domaininfo.ApplicationBase = @"Library\ScriptAssemblies";
Evidence adevidence = AppDomain.CurrentDomain.Evidence;
AppDomain domain = AppDomain.CreateDomain("MyDomain", adevidence, domaininfo);
Type type2 = typeof(ProxyDomain);
var value = (ProxyDomain)domain.CreateInstanceAndUnwrap(type2.Assembly.FullName, type2.FullName);
value.GetAssembly(dllPath);
Assembly unityEngine = Assembly.LoadFile(dllPath);
Debug.Log("Assembly found at " + dllPath);
for (int i = 0; i < classes.Count; i++)
{
Type type = unityEngine.GetType(classes[i].type.FullName, true);
PropertyInfo[] pis = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
for (int j = 0; j < pis.Length; j++)
{
if (classes[i].included.Count > 0 && classes[i].included.Contains(pis[j].Name) == false)
{
continue;
}
if (classes[i].excluded.Contains(pis[j].Name) == true ||
pis[j].IsDefined(typeof(ObsoleteAttribute), false) == true ||
pis[j].IsDefined(typeof(HideInInspector), false) == true ||
pis[j].GetIndexParameters().Length != 0 || // Skip indexer.
pis[j].CanRead == false || // Skip prop without both get/set.
pis[j].CanWrite == false ||
this.CanExposeTypeInInspector(pis[j].PropertyType) == false)
{
continue;
}
List <string> versions;
if (classes[i].properties.TryGetValue(pis[j].Name, out versions) == false)
{
versions = new List <string>();
classes[i].properties.Add(pis[j].Name, versions);
}
versions.Add(pair.Key);
}
FieldInfo[] fis = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
for (int j = 0; j < fis.Length; j++)
{
if (classes[i].included.Count > 0 && classes[i].included.Contains(fis[j].Name) == false)
{
continue;
}
if (classes[i].excluded.Contains(fis[j].Name) == true ||
fis[j].IsDefined(typeof(ObsoleteAttribute), false) == true ||
fis[j].IsDefined(typeof(HideInInspector), false) == true ||
this.CanExposeTypeInInspector(fis[j].FieldType) == false)
{
continue;
}
List <string> versions;
if (classes[i].fields.TryGetValue(fis[j].Name, out versions) == false)
{
versions = new List <string>();
classes[i].fields.Add(fis[j].Name, versions);
}
versions.Add(pair.Key);
}
}
AppDomain.Unload(domain);
}
string latestUnityVersion = "0";
foreach (var pair in installs)
{
if ((pair.Key[0] == '2' && (latestUnityVersion[0] == '4' || latestUnityVersion[0] == '5')) ||
(pair.Key[0] == latestUnityVersion[0] && latestUnityVersion.CompareTo(pair.Key) < 0) ||
latestUnityVersion[0] == '0')
{
latestUnityVersion = pair.Key;
}
}
latestUnityVersion = latestUnityVersion.Substring(0, latestUnityVersion.LastIndexOf('.'));
StringBuilder linkBuffer = Utility.GetBuffer();
linkBuffer.AppendLine("<linker>");
linkBuffer.AppendLine(" <assembly fullname=\"UnityEngine\">");
linkBuffer.AppendLine(" <type fullname=\""+ typeof(GameObject).FullName + "\" preserve=\"all\"/>");
Directory.CreateDirectory(this.exposersFolder);
string path;
for (int i = 0; i < classes.Count; i++)
{
StringBuilder buffer = Utility.GetBuffer();
linkBuffer.AppendLine(" <type fullname=\""+ classes[i].type.FullName + "\" preserve=\"all\"/>");
buffer.Append(@"// File auto-generated by ExposerGenerator.
using System.Reflection;
using UnityEngine;
namespace NGTools.NGRemoteScene
{
internal sealed class " + classes[i].type.Name + @"Exposer : ComponentExposer
{
public " + classes[i].type.Name + @"Exposer() : base(typeof(" + classes[i].type.Name + @"))
{
}" );
this.AddMembers(buffer, "Property", classes[i].properties, latestUnityVersion);
this.AddMembers(buffer, "Field", classes[i].fields, latestUnityVersion);
buffer.Append(@"
}
}");
Debug.Log("Type " + classes[i].type.FullName);
foreach (var item in classes[i].properties)
{
Debug.Log("Property " + item.Key + " in " + string.Join(", ", item.Value.ToArray()));
}
foreach (var item in classes[i].fields)
{
Debug.Log("Field " + item.Key + " in " + string.Join(", ", item.Value.ToArray()));
}
path = Path.Combine(this.exposersFolder, classes[i].type.Name + "Exposer.cs");
File.WriteAllText(path, Utility.ReturnBuffer(buffer));
Debug.Log("Exposer generated at \"" + path + "\".");
}
linkBuffer.AppendLine(" </assembly>");
linkBuffer.AppendLine("</linker>");
path = Path.Combine(this.exposersFolder, "link.xml");
Debug.Log("Links generated at \"" + path + "\".");
File.WriteAllText(Path.Combine(this.exposersFolder, "link.xml"), Utility.ReturnBuffer(linkBuffer));
}
}
static void TestCAS(string connectString1, string connectString2)
{
// Create permission set for sandbox AppDomain.
// This example only allows execution.
PermissionSet permissions = new PermissionSet(PermissionState.None);
permissions.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
// Create sandbox AppDomain with permission set that only allows execution,
// and has no SqlClientPermissions.
AppDomainSetup appDomainSetup = new AppDomainSetup();
appDomainSetup.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
AppDomain firstDomain = AppDomain.CreateDomain("NoSqlPermissions", null, appDomainSetup, permissions);
// Create helper object in sandbox AppDomain so that code can be executed in that AppDomain.
Type helperType = typeof(PartialTrustHelper);
PartialTrustHelper firstHelper = (PartialTrustHelper)firstDomain.CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName);
try {
// Attempt to open a connection in the sandbox AppDomain.
// This is expected to fail.
firstHelper.TestConnectionOpen(connectString1);
Console.WriteLine("Connection opened, unexpected.");
}
catch (System.Security.SecurityException ex) {
Console.WriteLine("Failed, as expected: {0}",
ex.FirstPermissionThatFailed);
// Uncomment the following line to see Exception details.
// Console.WriteLine("BaseException: " + ex.GetBaseException());
}
// Add permission for a specific connection string.
SqlClientPermission sqlPermission = new SqlClientPermission(PermissionState.None);
sqlPermission.Add(connectString1, "", KeyRestrictionBehavior.AllowOnly);
permissions.AddPermission(sqlPermission);
AppDomain secondDomain = AppDomain.CreateDomain("OneSqlPermission", null, appDomainSetup, permissions);
PartialTrustHelper secondHelper = (PartialTrustHelper)secondDomain.CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName);
// Try connection open again, it should succeed now.
try {
secondHelper.TestConnectionOpen(connectString1);
Console.WriteLine("Connection opened, as expected.");
}
catch (System.Security.SecurityException ex) {
Console.WriteLine("Unexpected failure: {0}", ex.Message);
}
// Try a different connection string. This should fail.
try {
secondHelper.TestConnectionOpen(connectString2);
Console.WriteLine("Connection opened, unexpected.");
}
catch (System.Security.SecurityException ex) {
Console.WriteLine("Failed, as expected: {0}", ex.Message);
}
}
public static T CreateObject <T>(this AppDomain domain) where T : MarshalByRefObject
{
Type type = typeof(T);
return((T)domain.CreateInstanceAndUnwrap(type.Assembly.FullName, type.FullName));
}
public NewDomainTestHelper(AppDomainSetup setupInformation)
{
domain = AppDomain.CreateDomain("TestDomain", AppDomain.CurrentDomain.Evidence, setupInformation);
testObject = (T)domain.CreateInstanceAndUnwrap(typeof(T).Assembly.FullName, typeof(T).FullName);
}
/// <summary>
/// This is used to create the assembly loader instance.
/// </summary>
/// <param name="project">The project from which to get the
/// necessary dependency information.</param>
/// <returns>Returns the assembly loader instance</returns>
public static AssemblyLoader CreateAssemblyLoader(
SandcastleProject project)
{
string[] files;
string dirName, fileSpec, sourcePath;
int idx;
if (loader == null)
{
AppDomain appDomain = AppDomain.CreateDomain(
"SHFBNamespaceInfo");
loader = (AssemblyLoader)appDomain.CreateInstanceAndUnwrap(
typeof(AssemblyLoader).Assembly.FullName,
typeof(AssemblyLoader).FullName, false,
BindingFlags.NonPublic | BindingFlags.Instance, null,
new object[0], CultureInfo.InvariantCulture,
new object[0], AppDomain.CurrentDomain.Evidence);
loader.AppDomain = appDomain;
foreach (DocumentAssembly da in project.Assemblies)
{
if (!da.CommentsOnly)
{
loader.AddDependency(da.AssemblyPath);
}
}
foreach (DependencyItem di in project.Dependencies)
{
sourcePath = di.DependencyPath;
if (!sourcePath.StartsWith("GAC:"))
{
if (sourcePath.IndexOfAny(new char[] { '*', '?' }) == -1)
{
loader.AddDependency(sourcePath);
}
else
{
idx = sourcePath.LastIndexOf('\\');
dirName = sourcePath.Substring(0, idx);
fileSpec = sourcePath.Substring(idx + 1);
files = Directory.GetFiles(dirName, fileSpec);
foreach (string name in files)
{
if (name.EndsWith(".dll") || name.EndsWith(".exe"))
{
loader.AddDependency(name);
}
}
}
}
}
}
return(loader);
}
public NewDomainTestHelper(AppDomainSetup setupInformation, PermissionSet permissionSet, params StrongName[] fullTrustAssemblies)
{
domain = AppDomain.CreateDomain("TestDomain", null, setupInformation, permissionSet, fullTrustAssemblies);
testObject = (T)domain.CreateInstanceAndUnwrap(typeof(T).Assembly.FullName, typeof(T).FullName);
}
/// <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 Microsoft.Build.* 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 += 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 static bool RunService(out string msg)
{
bool retValue = false;
msg = "";
try
{
string.Format("启动位于 {0} 位置的 {1} 服务，并启动实例： {2}",
ServiceContext.Current.ContentPath,
ServiceContext.Current.Name,
ServiceContext.Current.TargetType)
.Info();
AppDomainSetup oSetup = new AppDomainSetup();
oSetup.ApplicationName = ServiceContext.Current.Name;
oSetup.ApplicationBase = ServiceContext.Current.ContentPath;
//oSetup.PrivateBinPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "private");
oSetup.CachePath = Path.Combine(Directory.GetParent(AppDomain.CurrentDomain.BaseDirectory.TrimEnd(new char[] { '\\' })).FullName,
"Cache");
oSetup.ShadowCopyFiles = "true"; //启用影像复制程序集
oSetup.ShadowCopyDirectories = oSetup.ApplicationBase;
oSetup.ConfigurationFile = Path.Combine(oSetup.ApplicationBase, ServiceContext.Current.AssemblyName + ".dll.config");
oSetup.PrivateBinPath = oSetup.ApplicationBase;
string.Format("基础路径：{0}", oSetup.ApplicationBase).Info();
string.Format("BIN路径：{0}", oSetup.PrivateBinPath).Info();
string.Format("镜像路径：{0}", oSetup.ShadowCopyDirectories).Info();
string.Format("缓存路径：{0}", oSetup.CachePath).Info();
string.Format("配置文件：{0}", oSetup.ConfigurationFile).Info();
AppDomain newDomain = AppDomain.CreateDomain(ServiceContext.Current.Name,
AppDomain.CurrentDomain.Evidence,
oSetup);
newDomain.SetData("logRoot",
Path.Combine(
Directory.GetParent(
AppDomain.CurrentDomain.BaseDirectory.TrimEnd(new char[] { '\\' })).FullName,
"logs"));
IService service = newDomain.CreateInstanceAndUnwrap(ServiceContext.Current.AssemblyName,
ServiceContext.Current.TargetType) as IService;
Sponsor <IService> s = new Sponsor <IService>(service);
service.Start();
ServiceContext.Current.ServiceDomain = newDomain;
ServiceContext.Current.Service = s;
retValue = true;
}
catch (Exception eX)
{
msg = eX.Message;
msg.Error();
eX.Exception();
}
return(retValue);
}
static void Main_ObjectInstance(string[] args)
{
//有了一个类型对象后(Type的派生类实例如RuntimeType实例), 如何用他创建一个对象
Version v = typeof(System.Object).Assembly.GetName().Version;
string asb = "System.Messaging, PublicKeyToken=b03f5f7f11d50a3a, Culture=neutral, Version=" + v.ToString();
Assembly msxml = Assembly.Load(asb);
Type[] types = msxml.GetExportedTypes();
Console.WriteLine("All types defined in System.Messaging.dll:");
foreach (Type ty in types)
{
Console.WriteLine(ty.FullName);
}
Console.WriteLine(Environment.NewLine);
Type t = types[types.Length - 5];
string assemblyName = t.Assembly.FullName;
string typename = t.FullName;
Console.WriteLine(typename);
Console.WriteLine(assemblyName);
Console.WriteLine(Environment.NewLine);
//-
object m1 = System.Activator.CreateInstance(t); //Type参数及ctor参数
Console.WriteLine("m1 : " + m1.GetType());
//-
//ObjectHandle oh = Activator.CreateComInstanceFrom(assemblyName, typename); //TODO 怎么传
//object m2 = oh.Unwarp();
//-
AppDomain ad = AppDomain.CurrentDomain;
object m3 = ad.CreateInstanceAndUnwrap(assemblyName, typename);
Console.WriteLine("m3 : " + m3.GetType());
//-
//object m4 = t.InvokeMember();
//-
//object m5 = t.GetConstructor().Invoke(null);
//- 数组
int[] arr = (int[])System.Array.CreateInstance(typeof(int), 5);
Console.WriteLine("Array : " + arr.GetType());
Console.WriteLine(arr.Length);
//- 委托
MyDel md = (MyDel)System.Delegate.CreateDelegate(typeof(MyDel), typeof(Chapter23_Assembly_ObjectInstance).GetMethod("SomeMethod"), true);
Console.WriteLine("Delegate : " + md.GetType());
Console.WriteLine(md.GetInvocationList().Length);
//- 泛型类型
Type open = typeof(TestGeneraic <,>);
Type close = open.MakeGenericType(typeof(string), typeof(int));
object m6 = Activator.CreateInstance(close);
Console.WriteLine("m6 : " + m6.GetType());
}
public static void DebugScreen(String strLayoutXMLPath, String strSourceCode, String strViewNo, ViewMode mode)
{
ABCHelper.ABCWaitingDialog.Show("", ". . .");
try
{
ABCBaseScreen screen = null;
Type type = null;
Assembly ass = null;
#region Build
if (String.IsNullOrWhiteSpace(strSourceCode) == false)
{
ass = ABCScreenFactory.CompileScreenSouceCode(strSourceCode, strViewNo);
if (ass != null)
{
type = ass.GetType("ABCApp.Screens." + strViewNo + "Screen");
}
}
if (type == null)
{
type = typeof(ABCBaseScreen);
}
#endregion
Assembly asBase = null;
ABCScreenManager globalBase = null;
AppDomain domain = AppDomain.CreateDomain("DebugABCScreen", AppDomain.CurrentDomain.Evidence, AppDomain.CurrentDomain.SetupInformation);
try
{
asBase = domain.Load(typeof(ABCScreenManager).Assembly.FullName);
globalBase = (ABCScreenManager)domain.CreateInstanceAndUnwrap("ABCBaseScreen", "ABCScreen.ABCScreenManager");
globalBase.CallInitialize();
if (ass != null)
{
domain.Load(ass.GetName());
}
screen = (ABCBaseScreen)domain.CreateInstanceAndUnwrap(type.Assembly.FullName, type.FullName);
if (screen != null)
{
screen.LoadScreen(strLayoutXMLPath, mode);
ABCHelper.ABCWaitingDialog.Close();
screen.ShowDialog();
}
}
catch (Exception ex)
{
}
screen = null;
globalBase = null;
asBase = null;
AppDomain.Unload(domain);
domain = null;
}
catch (Exception exx)
{ }
GC.Collect(); // collects all unused memory
GC.WaitForPendingFinalizers(); // wait until GC has finished its work
GC.Collect();
ABCHelper.ABCWaitingDialog.Close();
}
public void LoadAssemblies()
{
if (ad != null)
{
System.Console.Error.WriteLine("Unloading domain");
AppDomain.Unload(ad);
}
ad = AppDomain.CreateDomain("MyAppDomain");
object o = ad.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "CompleteSharp+MyAppDomain+Hack");
Hack h = o as Hack;
h.ad = this;
int idx = 0;
foreach (string a in assemblies)
{
try
{
FileInfo fi = new FileInfo(a);
times[idx] = fi.LastWriteTime;
idx++;
System.Console.Error.WriteLine("Loading: " + a);
h.Load(a);
}
catch (Exception e)
{
reportError(e);
}
}
}
/// <summary>
/// Creates the app-domain and the instance of the ResourceRetriever and
/// sets the private fields with the references.
/// </summary>
///
private void CreateAppDomain()
{
if (_domain == null)
{
// Create an app-domain to load the resource assemblies in so that they can be
// unloaded.
_domain = AppDomain.CreateDomain("ResourceIndirectDomain");
_resourceRetriever =
(ResourceRetriever)_domain.CreateInstanceAndUnwrap(
Assembly.GetExecutingAssembly().FullName,
"System.Management.Automation.ResourceRetriever");
}
}
