/// <summary>
/// This method is needed to create an instance of a generic type using the
/// fully qualified name.
/// <see cref="http://msdn.microsoft.com/en-us/library/w3f99sx1.aspx"/>
/// </summary>
/// <param name="assemblyName">The name of the assembly</param>
/// <param name="typeName">The full name of the type</param>
/// <returns>A new instance of the specified type</returns>
public static object CreateInstanceFullyQualifiedName(string assemblyName, string typeName)
{
if (string.IsNullOrWhiteSpace(assemblyName))
{
throw new ArgumentNullException("assemblyName");
}
if (string.IsNullOrWhiteSpace(typeName))
{
throw new ArgumentNullException("typeName");
}
var assembly = AssembliesManager.LoadAssembly(assemblyName);
var type = Type.GetType(typeName + "," + assembly.FullName);
var instance = type == null ? null : Activator.CreateInstance(type);
if (instance != null)
{
Console.WriteLine(@"Instance of type {0} was created.", typeName);
}
else
{
Console.Error.WriteLine(@"Instance of type {0} was not created.", typeName);
}
return(instance);
}
public static void Main(string[] args)
{
#if DEBUG
//Debugger.Launch();
#endif
Thread.Sleep(10000);
AppDomain.CurrentDomain.AssemblyLoad += AssembliesManager.Loaded;
AppDomain.CurrentDomain.AssemblyResolve += AssembliesManager.Resolve;
AppDomain.CurrentDomain.UnhandledException += CurrentDomainUnhandledException;
var startParameters = new StartParameters(args);
channelName = startParameters.ChannelName;
AssembliesManager.LoadAssembly(startParameters.TesterAssembly);
if (string.IsNullOrEmpty(channelName))
{
SendError(new Exception("Channel name for interprocess communication was not set."));
return;
}
try
{
ExperimentScope.Start(startParameters);
}
catch (Exception ex)
{
SendError(ex);
}
}
/// <summary>
/// Initialize <see cref="TypeServices" /> object that provides services from TypeSystem to given owner.
/// </summary>
/// <param name="owner">Owner which uses current <see cref="TypeServices" />.</param>
/// <param name="manager">Representation of AppDomain where assemblies are stored.</param>
internal TypeServices(AssemblyProvider owner, AssembliesManager manager)
{
_owner = owner;
_manager = manager;
//every assembly has to have runtime as prioritized reference
//note that adding Runtime reference to itself is not a problem
References.Add(Settings.Runtime);
//assembly used for resolving is also owner itself
References.Add(owner.Key);
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyLoader" /> class.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="factories">The factories used for loading assemblies.</param>
public AssemblyLoader(MachineSettings settings, params AssemblyProviderFactory[] factories)
{
_manager = new AssembliesManager(this, settings);
_assemblyFactories = factories.ToArray();
_nullCallHandler = new DirectGenerator(nullCallHandler);
AppDomain = new AppDomainServices(_manager);
//register cleaning of overriding generators
Settings.BeforeInterpretation += () => _overridingGenerators.Clear();
}
public Assembly LoadAssembly(string dialogTitle)
{
this.dialog.Title = dialogTitle;
Assembly result = null;
if (this.dialog.ShowDialog().Value)
{
var file = new FileInfo(this.dialog.FileName);
result = AssembliesManager.LoadAssembly(this.dialog.FileName);
}
return(result);
}
private void assignControlToAssembly()
{
if (ENABLE_TESTING_ENVIRONMENT.Equals(true))
{
return;
}
bool error = false;
error = !AssembliesManager.assignControlAssembly("sideBarSettings", panelMenuOptionsContainer);
if (error)
{
Interaction.MsgBox("Error: assembly cound not be assigned a panel, " + AssembliesManager.errorMessage);
this.Close();
return;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AppDomainServices"/> class.
/// </summary>
/// <param name="manager">The assemblies manager.</param>
internal AppDomainServices(AssembliesManager manager)
{
_manager = manager;
//hook events
_manager.ComponentAdded += (c) =>
{
if (ComponentAdded != null)
{
ComponentAdded(c);
}
};
_manager.ComponentRemoved += (c) =>
{
if (ComponentRemoved != null)
{
ComponentRemoved(c);
}
};
_manager.AssemblyAdded += (a) =>
{
if (AssemblyAdded != null)
{
AssemblyAdded(a);
}
};
_manager.AssemblyRemoved += (a) =>
{
if (AssemblyRemoved != null)
{
AssemblyRemoved(a);
}
};
_manager.Cache.MethodInvalidated += (m) =>
{
if (MethodInvalidated != null)
{
MethodInvalidated(m);
}
};
}
public void LoadProjectAssemblies(List <string> projectAssemblies)
{
var builder = AssembliesManager.LoadBuilder(projectAssemblies);
_container = builder.Build();
}
internal TypeAssembly(AssembliesManager manager, AssemblyProvider assembly)
{
_manager = manager;
Assembly = assembly;
}
