private static void RunAutoexecs(string[] strIncludes, string[] strExcludes)
{
HashSet <string> setIncludes = null;
HashSet <string> setExcludes = null;
if (strIncludes != null && strIncludes.Length > 0)
{
setIncludes = new HashSet <string>();
foreach (string strInclude in strIncludes)
{
setIncludes.Add(strInclude);
}
}
if (strExcludes != null && strExcludes.Length > 0)
{
setExcludes = new HashSet <string>();
foreach (string strExclude in strExcludes)
{
setExcludes.Add(strExclude);
}
}
if (m_eventLoad == null)
{
m_eventLoad = new AssemblyLoadEventHandler(CurrentDomain_AssemblyLoad);
AppDomain.CurrentDomain.AssemblyLoad += m_eventLoad;
}
foreach (Assembly ass in CGestionnaireAssemblies.GetAssemblies())
{
RunAutoexec(ass, setIncludes, setExcludes);
}
}
public void CanLoadInjectionAdapter()
{
//-- arrange
var bootConfig = CreateBootConfiguration(
frameworkModules: new MicroserviceConfig.ModuleConfig[0],
applicationModules: new MicroserviceConfig.ModuleConfig[0]);
var assemlyLoadHandler = new AssemblyLoadEventHandler();
var logger = new MicroserviceHostLoggerMock();
var microserviceUnderTest = new MicroserviceHost(bootConfig, logger);
microserviceUnderTest.AssemblyLoad += assemlyLoadHandler.Handle;
//-- act
microserviceUnderTest.Configure();
//-- assert
assemlyLoadHandler.EventList.Count.Should().Be(2);
assemlyLoadHandler.EventList[0].ImplementedInterface.Should().Be(typeof(IComponentContainerBuilder));
assemlyLoadHandler.EventList[0].AssemblyName.Should().Be("InjectionAdapter");
assemlyLoadHandler.EventList[1].ImplementedInterface.Should().Be(typeof(IFeatureLoader));
assemlyLoadHandler.EventList[1].AssemblyName.Should().Be("NWheels.Implementation");
}
public void ModulesLoadedInOrder()
{
//-- arrange
var logger = new MicroserviceHostLoggerMock();
var host = new MicroserviceHost(CreateBootConfiguration(), logger);
var handler = new AssemblyLoadEventHandler();
var assemblies = new List <string>();
host.AssemblyLoad += handler.Handle;
host.AssemblyLoad += (object sender, AssemblyLoadEventArgs e) =>
{
assemblies.Add(e.AssemblyName);
};
//-- act
host.Configure();
//-- assert
assemblies.ToArray().Should().Equal(new string[] {
"InjectionAdapter",
"NWheels.Implementation",
"FrameworkModule",
"FirstModuleAssembly",
"SecondModuleAssembly",
});
}
//===================================================================
// Initialization performed on startup of the Python runtime. Here we
// scan all of the currently loaded assemblies to determine exported
// names, and register to be notified of new assembly loads.
//===================================================================
internal static void Initialize()
{
namespaces = new
Dictionary<string, Dictionary<Assembly, string>>(32);
probed = new Dictionary<string, int>(32);
//generics = new Dictionary<string, Dictionary<string, string>>();
assemblies = new List<Assembly>(16);
pypath = new List<string>(16);
AppDomain domain = AppDomain.CurrentDomain;
lhandler = new AssemblyLoadEventHandler(AssemblyLoadHandler);
domain.AssemblyLoad += lhandler;
rhandler = new ResolveEventHandler(ResolveHandler);
domain.AssemblyResolve += rhandler;
Assembly[] items = domain.GetAssemblies();
foreach (var a in items)
{
try
{
ScanAssembly(a);
assemblies.Add(a);
}
catch (Exception ex)
{
Debug.WriteLine(string.Format("Error scanning assembly {0}. {1}", a, ex));
}
}
}
public void CheckMicroserviceConfigOnConfiguring()
{
//-- arrange
var host = new MicroserviceHost(CreateBootConfiguration(), new MicroserviceHostLoggerMock());
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += handler.Handle;
//-- act
host.Configure();
//-- assert
var config = CreateBootConfiguration();
handler.ContainerEventArgs.Should().NotBeNull();
handler.ContainerEventArgs.AssemblyName.Should().Be(config.MicroserviceConfig.InjectionAdapter.Assembly);
handler.ContainerEventArgs.Destination.Count.Should().Be(1);
handler.FeatureLoaderEventArgsList.Should().HaveCount(
1 + config.MicroserviceConfig.FrameworkModules.Length + config.MicroserviceConfig.ApplicationModules.Length);
handler.FeatureLoaderEventArgsList.Should().ContainSingle(
x => x.AssemblyName == config.MicroserviceConfig.ApplicationModules[0].Assembly);
handler.FeatureLoaderEventArgsList.Should().ContainSingle(
x => x.AssemblyName == config.MicroserviceConfig.ApplicationModules[1].Assembly);
handler.FeatureLoaderEventArgsList.Should().ContainSingle(
x => x.AssemblyName == config.MicroserviceConfig.FrameworkModules[0].Assembly);
}
public void TryDiscoverDuplicatedFeatureLoaderOnConfiguring()
{
//-- arrange
var logger = new MicroserviceHostLoggerMock();
var config = CreateBootConfiguration();
var host = new MicroserviceHost(config, logger);
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += handler.Handle;
host.AssemblyLoad += (object sender, AssemblyLoadEventArgs e) =>
{
if (e.ImplementedInterface == typeof(IFeatureLoader))
{
if (e.AssemblyName == "FirstModuleAssembly")
{
e.Destination.Add(typeof(DuplicatedFeatureLoader));
}
}
};
//-- act
Action configuring = () => host.Configure();
//-- assert
configuring.ShouldThrow <Exception>();
}
public void InjectionAdapterModuleFeatureLoadersWereNotLoaded()
{
//-- arrange
var logger = new MicroserviceHostLoggerMock();
var config = CreateBootConfiguration();
var host = new MicroserviceHost(config, logger);
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += handler.Handle;
host.AssemblyLoad += (object sender, AssemblyLoadEventArgs e) =>
{
if ((e.AssemblyName == config.MicroserviceConfig.InjectionAdapter.Assembly &&
e.ImplementedInterface != typeof(IComponentContainerBuilder)) ||
(e.AssemblyName != config.MicroserviceConfig.InjectionAdapter.Assembly &&
e.ImplementedInterface == typeof(IComponentContainerBuilder)))
{
throw new Exception("AssemblyLoadEventHandler.Handle check haven't passed.");
}
};
//-- act
Action act = () => host.Configure();
//-- assert
act.ShouldNotThrow <Exception>();
}
public void InjectionAdapterCtorWithoutArgumentExceptionThrown()
{
//-- arrange
var logger = new MicroserviceHostLoggerMock();
var config = CreateBootConfiguration();
config.MicroserviceConfig.InjectionAdapter.Assembly = "AdapterInjectionCtorWithoutArgument";
var host = new MicroserviceHost(config, logger);
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += handler.Handle;
host.AssemblyLoad += (object sender, AssemblyLoadEventArgs e) =>
{
if (e.ImplementedInterface == typeof(IComponentContainerBuilder))
{
if (e.AssemblyName == "AdapterInjectionCtorWithoutArgument")
{
e.Destination.Add(typeof(ComponentContainerBuilderCtorWithoutArgument));
}
}
};
//-- act
Action act = () => host.Configure();
//-- assert
act.ShouldThrow <Exception>();
}
//===================================================================
// Initialization performed on startup of the Python runtime. Here we
// scan all of the currently loaded assemblies to determine exported
// names, and register to be notified of new assembly loads.
//===================================================================
internal static void Initialize()
{
namespaces = new
Dictionary <string, Dictionary <Assembly, string> >(32);
probed = new Dictionary <string, int>(32);
//generics = new Dictionary<string, Dictionary<string, string>>();
assemblies = new List <Assembly>(16);
pypath = new List <string>(16);
AppDomain domain = AppDomain.CurrentDomain;
lhandler = new AssemblyLoadEventHandler(AssemblyLoadHandler);
domain.AssemblyLoad += lhandler;
rhandler = new ResolveEventHandler(ResolveHandler);
domain.AssemblyResolve += rhandler;
Assembly[] items = domain.GetAssemblies();
for (int i = 0; i < items.Length; i++)
{
Assembly a = items[i];
assemblies.Add(a);
ScanAssembly(a);
}
}
public void CheckDefaultFeatureLoadersDiscoveredOnConfiguring()
{
//-- arrange
var logger = new MicroserviceHostLoggerMock();
var host = new MicroserviceHost(CreateBootConfiguration(), logger);
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += handler.Handle;
//-- act
host.Configure();
//-- assert
var logs = logger.TakeLog();
logs.Should().Contain(new string[] {
"FoundFeatureLoaderComponent(component=FirstFeatureLoader)",
"FoundFeatureLoaderComponent(component=SecondFeatureLoader)",
"FoundFeatureLoaderComponent(component=SeventhFeatureLoader)",
});
}
/// <summary>
/// Initialization performed on startup of the Python runtime. Here we
/// scan all of the currently loaded assemblies to determine exported
/// names, and register to be notified of new assembly loads.
/// </summary>
internal static void Initialize()
{
namespaces = new ConcurrentDictionary <string, ConcurrentDictionary <Assembly, string> >();
probed = new Dictionary <string, int>(32);
//generics = new Dictionary<string, Dictionary<string, string>>();
assemblies = new ConcurrentQueue <Assembly>();
pypath = new List <string>(16);
AppDomain domain = AppDomain.CurrentDomain;
lhandler = new AssemblyLoadEventHandler(AssemblyLoadHandler);
domain.AssemblyLoad += lhandler;
rhandler = new ResolveEventHandler(ResolveHandler);
domain.AssemblyResolve += rhandler;
Assembly[] items = domain.GetAssemblies();
foreach (Assembly a in items)
{
try
{
ScanAssembly(a);
assemblies.Enqueue(a);
}
catch (Exception ex)
{
Debug.WriteLine("Error scanning assembly {0}. {1}", a, ex);
}
}
}
public override void GenerateCode(AssemblyBuilder assemblyBuilder)
{
base.GenerateCode(assemblyBuilder);
WXMLModel model = null;
using (XmlReader xr = new XmlTextReader(_fileName))
{
model = WXMLModel.LoadFromXml(xr);
}
IRepositoryProvider prov = WmsDefinitionManager.GetRepositoryProvider();
foreach (CodeCompileUnit unit in prov.CreateCompileUnits(model))
{
assemblyBuilder.AddCodeCompileUnit(this, unit);
}
string fn = Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(assemblyBuilder.GetTempFilePhysicalPath("dll")));
AssemblyLoadEventHandler d = null;
d = delegate(object sender, AssemblyLoadEventArgs args)
{
if (args.LoadedAssembly.ManifestModule.Name.StartsWith(fn))
{
prov.SetRepositoryAssembly(args.LoadedAssembly);
AppDomain.CurrentDomain.AssemblyLoad -= d;
}
};
AppDomain.CurrentDomain.AssemblyLoad += d;
}
public void AssemblyLoad()
{
RemoteInvoke(() => {
bool AssemblyLoadFlag = false;
AssemblyLoadEventHandler handler = (sender, args) =>
{
if (args.LoadedAssembly.FullName.Equals(typeof(AppDomainTests).Assembly.FullName))
{
AssemblyLoadFlag = !AssemblyLoadFlag;
}
};
AppDomain.CurrentDomain.AssemblyLoad += handler;
try
{
Assembly.LoadFile(typeof(AppDomainTests).Assembly.Location);
}
finally
{
AppDomain.CurrentDomain.AssemblyLoad -= handler;
}
Assert.True(AssemblyLoadFlag);
return(SuccessExitCode);
}).Dispose();
}
public void EmptyBootConfig_DefaultKernelFeaturesLoaded()
{
//-- arrange
var bootConfig = CreateBootConfiguration(
frameworkModules: new MicroserviceConfig.ModuleConfig[0],
applicationModules: new MicroserviceConfig.ModuleConfig[0]);
var assemlyLoadHandler = new AssemblyLoadEventHandler();
var logger = new MicroserviceHostLoggerMock();
var microserviceUnderTest = new MicroserviceHost(bootConfig, logger);
microserviceUnderTest.AssemblyLoad += assemlyLoadHandler.Handle;
var featureLog = new List <string>();
InterceptAllFeatureLoadersLogs(featureLog);
//-- act
microserviceUnderTest.Configure();
//-- assert
featureLog.Should().Contain($"{typeof(Kernel_FeatureOne).Name}.{nameof(IFeatureLoader.ContributeComponents)}");
featureLog.Should().Contain($"{typeof(Kernel_FeatureTwo).Name}.{nameof(IFeatureLoader.ContributeComponents)}");
featureLog.Should().NotContain($"{typeof(Kernel_FeatureThree).Name}.{nameof(IFeatureLoader.ContributeComponents)}");
}
public void AssemblyLoad()
{
RemoteExecutor.Invoke(() => {
bool AssemblyLoadFlag = false;
AssemblyLoadEventHandler handler = (sender, args) =>
{
Assert.Same(AppDomain.CurrentDomain, sender);
Assert.NotNull(args);
Assert.NotNull(args.LoadedAssembly);
if (args.LoadedAssembly.FullName.Equals(typeof(AppDomainTests).Assembly.FullName))
{
AssemblyLoadFlag = true;
}
};
AppDomain.CurrentDomain.AssemblyLoad += handler;
try
{
Assembly.LoadFile(typeof(AppDomainTests).Assembly.Location);
}
finally
{
AppDomain.CurrentDomain.AssemblyLoad -= handler;
}
Assert.True(AssemblyLoadFlag);
}).Dispose();
}
public static void Autoexec()
{
if (m_eventLoad == null)
{
m_eventLoad = new AssemblyLoadEventHandler(CurrentDomain_AssemblyLoad);
AppDomain.CurrentDomain.AssemblyLoad += m_eventLoad;
}
CAnalyseurSyntaxiqueExpression.RegisterFournisseurExpressionsDynamiques(new CFournisseurConstantesObjetDonneeAIdAuto());
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// assemblyloadeventhandler.BeginInvoke(sender, args, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this AssemblyLoadEventHandler assemblyloadeventhandler, Object sender, AssemblyLoadEventArgs args, AsyncCallback callback)
{
if (assemblyloadeventhandler == null)
{
throw new ArgumentNullException("assemblyloadeventhandler");
}
return(assemblyloadeventhandler.BeginInvoke(sender, args, callback, null));
}
private void OnAssemblyLoadEvent(RuntimeAssembly LoadedAssembly)
{
AssemblyLoadEventHandler eventHandler = AssemblyLoad;
if (eventHandler != null)
{
AssemblyLoadEventArgs ea = new AssemblyLoadEventArgs(LoadedAssembly);
eventHandler(this, ea);
}
}
public static void Test_SetAssemblyEvent_01()
{
Test_UnsetAssemblyEvent_01();
_tr.WriteLine("Test_SetAssemblyEvent_01");
ResolveEventHandler resolveEventHandler = new ResolveEventHandler(CurrentDomain_AssemblyResolve);
AssemblyLoadEventHandler assemblyLoadEventHandler = new AssemblyLoadEventHandler(CurrentDomain_AssemblyLoad);
_rs.Data.Add("ResolveEventHandler", resolveEventHandler);
_rs.Data.Add("AssemblyLoadEventHandler", assemblyLoadEventHandler);
AppDomain.CurrentDomain.AssemblyResolve += resolveEventHandler;
AppDomain.CurrentDomain.AssemblyLoad += assemblyLoadEventHandler;
}
public static void Test_SetAssemblyEvent_01()
{
Test_UnsetAssemblyEvent_01();
_tr.WriteLine("Test_SetAssemblyEvent_01");
ResolveEventHandler resolveEventHandler = new ResolveEventHandler(CurrentDomain_AssemblyResolve);
AssemblyLoadEventHandler assemblyLoadEventHandler = new AssemblyLoadEventHandler(CurrentDomain_AssemblyLoad);
_rs.Data.Add("ResolveEventHandler", resolveEventHandler);
_rs.Data.Add("AssemblyLoadEventHandler", assemblyLoadEventHandler);
AppDomain.CurrentDomain.AssemblyResolve += resolveEventHandler;
AppDomain.CurrentDomain.AssemblyLoad += assemblyLoadEventHandler;
}
public static void Test_UnsetAssemblyEvent_01()
{
if (_rs.Data.ContainsKey("ResolveEventHandler"))
{
ResolveEventHandler resolveEventHandler = (ResolveEventHandler)_rs.Data["ResolveEventHandler"];
AppDomain.CurrentDomain.AssemblyResolve -= resolveEventHandler;
_rs.Data.Remove("ResolveEventHandler");
}
if (_rs.Data.ContainsKey("AssemblyLoadEventHandler"))
{
AssemblyLoadEventHandler assemblyLoadEventHandler = (AssemblyLoadEventHandler)_rs.Data["AssemblyLoadEventHandler"];
AppDomain.CurrentDomain.AssemblyLoad -= assemblyLoadEventHandler;
_rs.Data.Remove("AssemblyLoadEventHandler");
}
}
public UdonSharpAssemblyLoadStripScope()
{
FieldInfo info = AppDomain.CurrentDomain.GetType().GetField("AssemblyLoad", BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance);
AssemblyLoadEventHandler handler = info.GetValue(AppDomain.CurrentDomain) as AssemblyLoadEventHandler;
originalDelegates = handler?.GetInvocationList();
if (originalDelegates != null)
{
foreach (Delegate del in originalDelegates)
{
AppDomain.CurrentDomain.AssemblyLoad -= (AssemblyLoadEventHandler)del;
}
}
}
public void NamedKernelModuleLoadedFirstInFrameworkModules()
{
//-- arrange
var logger = new MicroserviceHostLoggerMock();
var config = CreateBootConfiguration();
config.MicroserviceConfig.FrameworkModules = new MicroserviceConfig.ModuleConfig[]
{
new MicroserviceConfig.ModuleConfig()
{
Assembly = "NWheels.Implementation",
Features = new MicroserviceConfig.ModuleConfig.FeatureConfig[] {
new MicroserviceConfig.ModuleConfig.FeatureConfig()
{
Name = "NamedKernelFeatureLoader"
}
}
}
};
var host = new MicroserviceHost(config, logger);
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += (object sender, AssemblyLoadEventArgs e) =>
{
if (e.ImplementedInterface == typeof(IFeatureLoader))
{
if (e.AssemblyName == "NWheels.Implementation")
{
e.Destination.Add(typeof(NamedKernelFeatureLoader));
}
}
};
host.AssemblyLoad += handler.Handle;
//-- act
host.Configure();
//-- assert
var logs = logger.TakeLog();
logs.Skip(1 + 2).First().Should().Be(
"FoundFeatureLoaderComponent(component=NamedKernelFeatureLoader)");
}
public void RegisterMetadataDelayed(string assemblyName, Action<AttributeTableBuilder> delayedWork)
{
Fx.Assert(assemblyName != null, "Checked by caller");
Fx.Assert(delayedWork != null, "Checked by caller");
if (this.onAssemblyLoadedEventHandler == null)
{
this.onAssemblyLoadedEventHandler = new AssemblyLoadEventHandler(this.OnAssemblyLoaded);
AppDomain.CurrentDomain.AssemblyLoad += this.onAssemblyLoadedEventHandler;
}
List<Action<AttributeTableBuilder>> currentDelayedWorkItems;
if (!this.DelayedWorkItems.TryGetValue(assemblyName, out currentDelayedWorkItems))
{
currentDelayedWorkItems = new List<Action<AttributeTableBuilder>>();
this.DelayedWorkItems.Add(assemblyName, currentDelayedWorkItems);
}
currentDelayedWorkItems.Add(delayedWork);
}
public void GetCompileRegistredComponentAfterConfiguring()
{
//-- arrange
var logger = new MicroserviceHostLoggerMock();
var host = new MicroserviceHost(CreateBootConfiguration(), logger);
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += handler.Handle;
//-- act
host.Configure();
var container = host.GetContainer();
var component = container.Resolve <ICompileRegistered>();
//-- assert
component.Should().NotBeNull();
}
public void RegisterMetadataDelayed(string assemblyName, Action <AttributeTableBuilder> delayedWork)
{
Fx.Assert(assemblyName != null, "Checked by caller");
Fx.Assert(delayedWork != null, "Checked by caller");
if (this.onAssemblyLoadedEventHandler == null)
{
this.onAssemblyLoadedEventHandler = new AssemblyLoadEventHandler(this.OnAssemblyLoaded);
AppDomain.CurrentDomain.AssemblyLoad += this.onAssemblyLoadedEventHandler;
}
List <Action <AttributeTableBuilder> > currentDelayedWorkItems;
if (!this.DelayedWorkItems.TryGetValue(assemblyName, out currentDelayedWorkItems))
{
currentDelayedWorkItems = new List <Action <AttributeTableBuilder> >();
this.DelayedWorkItems.Add(assemblyName, currentDelayedWorkItems);
}
currentDelayedWorkItems.Add(delayedWork);
}
public void TryDiscoverUnexistedFeatureLoaderOnConfiguring()
{
//-- arrange
var logger = new MicroserviceHostLoggerMock();
var config = CreateBootConfiguration();
config.MicroserviceConfig.ApplicationModules[0].Features[0].Name = "Abracadabra";
var host = new MicroserviceHost(config, logger);
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += handler.Handle;
//-- act
Action configuring = () => host.Configure();
//-- assert
configuring.ShouldThrow <Exception>();
}
public void InjectionAdapterLoadedFirst()
{
//-- arrange
var logger = new MicroserviceHostLoggerMock();
var host = new MicroserviceHost(CreateBootConfiguration(), logger);
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += handler.Handle;
//-- act
host.Configure();
//-- assert
var logs = logger.TakeLog();
var firstLoadedComponent = logs.FirstOrDefault(x => x.StartsWith("FoundFeatureLoaderComponent"));
firstLoadedComponent.Should().Be("FoundFeatureLoaderComponent(component=ComponentContainerBuilder)");
}
//===================================================================
// Initialization performed on startup of the Python runtime.
//===================================================================
internal static void Initialize() {
pypath = new StringCollection();
namespaces = new Hashtable();
assemblies = new ArrayList();
probed = new Hashtable();
AppDomain domain = AppDomain.CurrentDomain;
lh = new AssemblyLoadEventHandler(AssemblyLoadHandler);
domain.AssemblyLoad += lh;
rh = new ResolveEventHandler(ResolveHandler);
domain.AssemblyResolve += rh;
Assembly[] items = domain.GetAssemblies();
for (int i = 0; i < items.Length; i++) {
Assembly a = items[i];
assemblies.Add(a);
ScanAssembly(a);
}
}
public void CanExecuteFeatureLoadersLifecycle()
{
//-- arrange
var host = new MicroserviceHost(CreateBootConfiguration(), new MicroserviceHostLoggerMock());
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += handler.Handle;
var featureLoaderLog = new List <string>();
AddFeatureLoaderLoggingInterceptor <FirstFeatureLoader>(featureLoaderLog);
AddFeatureLoaderLoggingInterceptor <SecondFeatureLoader>(featureLoaderLog);
//-- act
host.Configure();
//-- assert
featureLoaderLog.Should().Equal(
$"{typeof(FirstFeatureLoader).Name}.{nameof(IFeatureLoader.ContributeConfigSections)}",
$"{typeof(SecondFeatureLoader).Name}.{nameof(IFeatureLoader.ContributeConfigSections)}",
$"{typeof(FirstFeatureLoader).Name}.{nameof(IFeatureLoader.ContributeConfiguration)}",
$"{typeof(SecondFeatureLoader).Name}.{nameof(IFeatureLoader.ContributeConfiguration)}",
$"{typeof(FirstFeatureLoader).Name}.{nameof(IFeatureLoader.ContributeComponents)}",
$"{typeof(SecondFeatureLoader).Name}.{nameof(IFeatureLoader.ContributeComponents)}",
$"{typeof(FirstFeatureLoader).Name}.{nameof(IFeatureLoader.ContributeAdapterComponents)}",
$"{typeof(SecondFeatureLoader).Name}.{nameof(IFeatureLoader.ContributeAdapterComponents)}",
$"{typeof(FirstFeatureLoader).Name}.{nameof(IFeatureLoader.CompileComponents)}",
$"{typeof(SecondFeatureLoader).Name}.{nameof(IFeatureLoader.CompileComponents)}",
$"{typeof(FirstFeatureLoader).Name}.{nameof(IFeatureLoader.ContributeCompiledComponents)}",
$"{typeof(SecondFeatureLoader).Name}.{nameof(IFeatureLoader.ContributeCompiledComponents)}"
);
}
//===================================================================
// Initialization performed on startup of the Python runtime.
//===================================================================
internal static void Initialize()
{
pypath = new StringCollection();
namespaces = new Hashtable();
assemblies = new ArrayList();
probed = new Hashtable();
AppDomain domain = AppDomain.CurrentDomain;
lh = new AssemblyLoadEventHandler(AssemblyLoadHandler);
domain.AssemblyLoad += lh;
rh = new ResolveEventHandler(ResolveHandler);
domain.AssemblyResolve += rh;
Assembly[] items = domain.GetAssemblies();
for (int i = 0; i < items.Length; i++)
{
Assembly a = items[i];
assemblies.Add(a);
ScanAssembly(a);
}
}
//===================================================================
// Initialization performed on startup of the Python runtime. Here we
// scan all of the currently loaded assemblies to determine exported
// names, and register to be notified of new assembly loads.
//===================================================================
internal static void Initialize() {
namespaces = new
Dictionary<string, Dictionary<Assembly, string>>(32);
probed = new Dictionary<string, int>(32);
//generics = new Dictionary<string, Dictionary<string, string>>();
assemblies = new List<Assembly>(16);
pypath = new List<string>(16);
AppDomain domain = AppDomain.CurrentDomain;
lhandler = new AssemblyLoadEventHandler(AssemblyLoadHandler);
domain.AssemblyLoad += lhandler;
rhandler = new ResolveEventHandler(ResolveHandler);
domain.AssemblyResolve += rhandler;
Assembly[] items = domain.GetAssemblies();
for (int i = 0; i < items.Length; i++) {
Assembly a = items[i];
assemblies.Add(a);
ScanAssembly(a);
}
}
public void KernelModulesDefaultFeatureLoadersLoadedFirstAfterInjectionAdapter()
{
//-- arrange
var logger = new MicroserviceHostLoggerMock();
var host = new MicroserviceHost(CreateBootConfiguration(), logger);
var handler = new AssemblyLoadEventHandler();
host.AssemblyLoad += handler.Handle;
//-- act
host.Configure();
//-- assert
var logs = logger.TakeLog();
logs.Skip(1).Take(2).OrderBy(x => x).Should().Equal(new string[] {
"FoundFeatureLoaderComponent(component=CompilationFeatureLoader)",
"FoundFeatureLoaderComponent(component=InvocationSchedulerFeatureLoader)",
});
}
public void AssemblyLoad()
{
bool AssemblyLoadFlag = false;
AssemblyLoadEventHandler handler = (sender, args) =>
{
if (args.LoadedAssembly.FullName.Equals(typeof(AppDomainTests).Assembly.FullName))
{
AssemblyLoadFlag = !AssemblyLoadFlag;
}
};
AppDomain.CurrentDomain.AssemblyLoad += handler;
try
{
Assembly.LoadFile(typeof(AppDomainTests).Assembly.Location);
}
finally
{
AppDomain.CurrentDomain.AssemblyLoad -= handler;
}
Assert.True(AssemblyLoadFlag);
}
private static void HookUpWeakClearingDelegate(WeakReference weakRef)
{
AssemblyLoadEventHandler ret = null;
ret = delegate(object sender, AssemblyLoadEventArgs args)
{
var target = (MemoizingTypeMappingStrategy)weakRef.Target;
if (target == null)
{
//Unhook us, multiple unhooks is fine
AppDomain.CurrentDomain.AssemblyLoad -= ret;
}
else
{
// Since we cache even null returns but we would like to keep the the dynamic behaviour
// If the type request is being proccessed whilst this is called then we might cache the old value
// but that would be mad
target._getTypeCache.Clear();
}
};
Thread.MemoryBarrier();
AppDomain.CurrentDomain.AssemblyLoad += ret;
}
public EventHandler<AssemblyLoadEventArgs> Convert(AssemblyLoadEventHandler handler)
{
// The unit test will weave valid code in here.
throw new NotImplementedException();
}
public void DummyAddMethod (object o, AssemblyLoadEventHandler h)
{
}
