public Mapper()
{
_assemblyRepository = new AssemblyRepository();
_typeRepository = new TypeRepository(_assemblyRepository);
_memberRepository = new MemberRepository(_typeRepository);
_modelCreator = new ModelCreator(_typeRepository, _memberRepository);
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="assemblyRepository">Instancia do repositório de assemblies.</param>
/// <param name="assemblyParts">Relação dos nomes dos assemblies que devem ser resolvidos.</param>
public AssemblyPartsResolver(IAssemblyRepository assemblyRepository, IEnumerable <AssemblyPart> assemblyParts)
{
assemblyRepository.Require("assemblyRepository").NotNull();
assemblyParts.Require("assemblyNames").NotNull();
_assemblyRepository = assemblyRepository;
_assemblyParts = assemblyParts;
}
public async Task <Type> GenerateAsync(Type serviceType, GenerateOptions options)
{
AssemblyName asmName;
if (_createOptions.AssemblyNameProvider == null)
{
asmName = CreateAssemblyName(serviceType);
}
else
{
asmName = _createOptions.AssemblyNameProvider.GetName(serviceType, options);
}
IAssemblyRepository asmRepo = _createOptions.AssemblyRepository;
Stream asmContent = asmRepo == null ? null : await asmRepo.GetAsync(asmName);
Assembly asm;
if (asmContent == null)
{
AssemblyBuilder asmBuilder = GenerateInternal(asmName, serviceType, options);
using (MemoryStream dll = new MemoryStream())
{
await asmBuilder.SaveAsync(dll, new SaveOptions());
if (asmRepo != null)
{
asmContent = await asmRepo.CreateAsync(asmName);
try
{
dll.Position = 0;
await dll.CopyToAsync(asmContent);
}
finally
{
asmRepo.DisposeStream(asmContent);
}
}
asm = Assembly.Load(dll.GetBuffer());
}
}
else
{
try
{
using (MemoryStream dll = new MemoryStream())
{
await asmContent.CopyToAsync(dll);
asm = Assembly.Load(dll.GetBuffer());
}
}
finally
{
asmRepo.DisposeStream(asmContent);
}
}
return(asm.GetType(_typeFullName));
}
public CachingAssemblyRepository(IAssemblyRepository repository, TimeSpan TTL, ILogger log)
{
this.repository = repository;
this.TTL = TTL;
this.log = log;
this.purgeTimer = new System.Threading.Timer(OnPurge, null, 1000, 1000);
}
public CachingAssemblyRepository(IAssemblyRepository repository, TimeSpan TTL, ILogger log)
{
this.repository = repository;
this.TTL = TTL;
this.log = log;
this.purgeTimer = new System.Threading.Timer(OnPurge, null, 1000, 1000);
}
public MockAssemblyRepository()
{
var container = new AssemblyContainer();
container.Add(typeof(MockPlugin1).Assembly.Location);
container.Add(typeof(PluginCreator).Assembly.Location);
this.repos = container;
this.Fetched = new Dictionary<string, byte[]>();
}
public MockAssemblyRepository()
{
var container = new AssemblyContainer();
container.Add(typeof(MockPlugin1).Assembly.Location);
container.Add(typeof(PluginCreator).Assembly.Location);
this.repos = container;
this.Fetched = new Dictionary <string, byte[]>();
}
protected override void establish_context()
{
assembly_resolver = dependency <IAssemblyRepository>();
assembly_name = "MbUnit.Framework.dll";
args = new List <string> {
assembly_name, "TestAttribute", "output.html"
}.ToArray();
sut = create_sut();
}
public ProjectInfo(
IAssemblyRepository assemblyRepository,
IFilesRepository filesRepository,
IMigrationsRepository migrationsRepository,
ILog log)
{
_assemblyRepository = assemblyRepository ?? new AssemblyRepository();
_filesRepository = filesRepository ?? new FilesRepository();
_migrationsRepository = migrationsRepository ?? new MigrationsRepository();
_log = log ?? new Log();
}
public object Create(PluginDescriptor descriptor, IAssemblyRepository assemblies, IDictionary <string, object> settings)
{
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
if (assemblies == null)
{
throw new ArgumentNullException("assemblies");
}
try
{
ResolveEventHandler resolveHandler = new ResolveEventHandler((s, e) =>
{
// Fetch assembly from repository and load it into the appdomain
byte[] assemblyBytes = assemblies.Fetch(e.Name);
if (assemblyBytes != null)
{
return(Assembly.Load(assemblyBytes));
}
// Unable to resolve this assembly
return(null);
});
AppDomain.CurrentDomain.AssemblyResolve += resolveHandler;
object plugin = AppDomain.CurrentDomain.CreateInstanceAndUnwrap(descriptor.QualifiedName.AssemblyFullName, descriptor.QualifiedName.TypeFullName);
AppDomain.CurrentDomain.AssemblyResolve -= resolveHandler;
ApplySettings(plugin, settings);
this.log.Info(Resources.CreatedPlugin, plugin.GetType().FullName);
return(plugin);
}
catch (PluginException ex)
{
this.log.Error(ex.Message);
throw;
}
catch (Exception ex)
{
this.log.Error(ex.Message);
throw new PluginException(ex.Message, ex);
}
}
public AssemblyService(IAssemblyRepository assemblyRepository)
{
_assemRepo = assemblyRepository;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="domain"></param>
/// <param name="assemblyRepository"></param>
public AssemblyLoader(AppDomain domain, IAssemblyRepository assemblyRepository)
{
assemblyRepository.Require("assemblyRepository").NotNull();
_domain = domain;
_assemblyRepository = assemblyRepository;
}
public Client(ILogger log, IPluginRepository pluginRepository, IAssemblyRepository assemblyRepository)
{
this.log = log;
this.pluginRepository = pluginRepository;
this.assemblyRepository = assemblyRepository;
}
public ReportOptionsFactory(IAssemblyRepository assembly_resolver)
{
this.assembly_resolver = assembly_resolver;
}
public FetchAssemblyHandler(IAssemblyRepository assemblyRepository, ILogger log)
{
this.log = log;
this.assemblyRepository = assemblyRepository;
}
public TypeRepository(IAssemblyRepository assemblyRepository)
{
_assemblyRepository = assemblyRepository;
}
public object Create(PluginDescriptor descriptor, IAssemblyRepository assemblies, IDictionary<string, object> settings)
{
if (descriptor == null)
throw new ArgumentNullException("descriptor");
if (assemblies == null)
throw new ArgumentNullException("assemblies");
try
{
ResolveEventHandler resolveHandler = new ResolveEventHandler((s, e) =>
{
// Fetch assembly from repository and load it into the appdomain
byte[] assemblyBytes = assemblies.Fetch(e.Name);
if (assemblyBytes != null)
return Assembly.Load(assemblyBytes);
// Unable to resolve this assembly
return null;
});
AppDomain.CurrentDomain.AssemblyResolve += resolveHandler;
object plugin = AppDomain.CurrentDomain.CreateInstanceAndUnwrap(descriptor.QualifiedName.AssemblyFullName, descriptor.QualifiedName.TypeFullName);
AppDomain.CurrentDomain.AssemblyResolve -= resolveHandler;
ApplySettings(plugin, settings);
this.log.Info(Resources.CreatedPlugin, plugin.GetType().FullName);
return plugin;
}
catch (PluginException ex)
{
this.log.Error(ex.Message);
throw;
}
catch (Exception ex)
{
this.log.Error(ex.Message);
throw new PluginException(ex.Message, ex);
}
}
public Client(ILogger log, IPluginRepository pluginRepository, IAssemblyRepository assemblyRepository)
{
this.log = log;
this.pluginRepository = pluginRepository;
this.assemblyRepository = assemblyRepository;
}
public CrashInformationCollector(IAssemblyRepository assemblyRepository, string version = null)
{
_assemblyRepository = assemblyRepository;
_version = version;
}
public WcfService(IAssemblyRepository assemblyRepository, IPluginRepository pluginRepository, ILogger log)
{
this.assemblyRepository = assemblyRepository;
this.pluginRepository = pluginRepository;
this.log = log;
}
public ReportOptionsFactory(IAssemblyRepository assembly_resolver, IObservationSpecificationFactory observation_specification_factory)
{
this.assembly_resolver = assembly_resolver;
this.observation_specification_factory = observation_specification_factory;
}
public AssemblyManager()
{
this.irep = new AssemblyRepository();
}
public WcfService(IAssemblyRepository assemblyRepository, IPluginRepository pluginRepository, ILogger log)
{
this.assemblyRepository = assemblyRepository;
this.pluginRepository = pluginRepository;
this.log = log;
}
public CrashInformationCollector(IAssemblyRepository assemblyRepository, string version = null)
{
_assemblyRepository = assemblyRepository;
_version = version;
}
