public void RegisterAssemblyProvider(AssemblyProvider assemblyProvider)
{
AppDomain.CurrentDomain.AssemblyResolve += delegate(object sender, ResolveEventArgs args) {
byte[] assemblyData = assemblyProvider.GetAssembly(args.Name);
return(assemblyData != null?Assembly.Load(assemblyData) : null);
};
}
public IDictionary <string, IBackend> CreateAll()
{
var result = new Dictionary <string, IBackend>();
foreach (var assembly in AssemblyProvider.GetAll())
{
foreach (var type in assembly.Types)
{
var attribute = type.GetCustomAttribute <DataTableBackendAttribute>();
if (attribute == null)
{
continue;
}
if (!typeof(IBackend).IsAssignableFrom(type))
{
throw new DataTableBackendDoesNotImplementIBackendException(type);
}
result.Add(attribute.Id, (IBackend)Instantiator.Instantiate(type));
}
}
return(result);
}
public IEnumerable <ISaveListener <object> > Create()
{
var result = new List <ISaveListener <object> >();
foreach (var type in AssemblyProvider.GetAll().SelectMany(a => a.Types))
{
if (!type.IsClass)
{
continue;
}
if (type.IsAbstract)
{
continue;
}
if (!typeof(ISaveListener <object>).IsAssignableFrom(type))
{
continue;
}
Logger.LogInformation($"Creating SaveListener {type}");
result.Add((ISaveListener <object>)Instantiator.Instantiate(type));
}
return(result.AsReadOnly());
}
/// <summary>
/// Assembly that has been removed completely from <see cref="AssembliesManager" />.
/// </summary>
/// <param name="assembly">Removed assembly.</param>
private void _onAssemblyRemoved(AssemblyProvider assembly)
{
startTransaction("Unregistering assembly: " + assembly.Name);
try
{
var componentsCopy = GetComponents(assembly).ToArray();
foreach (var component in componentsCopy)
{
_onComponentRemoved(assembly, component);
}
if (assembly.TypeServices.RegisteredInvalidationHandler != null)
{
//remove handler
NameInvalidated -= assembly.TypeServices.RegisteredInvalidationHandler;
}
assembly.Unload();
if (AssemblyRemoved != null)
{
AssemblyRemoved(assembly);
}
}
finally
{
commitTransaction();
}
}
/// <summary>
/// Initialize assemblies setup.
/// </summary>
/// <param name="logger"><see cref="ILogger"/> to use for logging.</param>
/// <param name="entryAssembly"><see cref="Assembly"/> to use as entry assembly - null indicates it will get it from the <see cref="Assembly.GetEntryAssembly()"/> method.</param>
/// <param name="defaultAssemblyProvider">The default <see cref="ICanProvideAssemblies"/> - null inidicates it will use the default implementation.</param>
/// <param name="excludeAllCallback">A callback to build on the exclude all specification.</param>
/// <returns>Discovered <see cref="IAssemblies"/>.</returns>
public static IAssemblies Start(
ILogger logger,
Assembly entryAssembly = null,
ICanProvideAssemblies defaultAssemblyProvider = null,
Action <ExcludeAll> excludeAllCallback = null)
{
var assembliesConfigurationBuilder = new AssembliesConfigurationBuilder();
var assembliesSpecification = assembliesConfigurationBuilder
.ExcludeAll()
.ExceptProjectLibraries()
.ExceptDolittleLibraries();
excludeAllCallback?.Invoke(assembliesSpecification);
if (entryAssembly == null)
{
entryAssembly = Assembly.GetEntryAssembly();
}
var assembliesConfiguration = new AssembliesConfiguration(assembliesConfigurationBuilder.RuleBuilder);
var assemblyFilters = new AssemblyFilters(assembliesConfiguration);
var assemblyProvider = new AssemblyProvider(
new ICanProvideAssemblies[] { defaultAssemblyProvider ?? new DefaultAssemblyProvider(logger, entryAssembly) },
assemblyFilters,
new AssemblyUtility(),
logger);
var assemblies = new Assemblies(entryAssembly, assemblyProvider);
return(assemblies);
}
public static void AddCloudy(this IServiceCollection services, Action <CloudyConfigurator> cloudy)
{
services.Configure <RouteOptions>(options =>
{
options.ConstraintMap.Add("contentroute", typeof(ContentRouteConstraint));
});
var options = new CloudyOptions();
var configurator = new CloudyConfigurator(services, options);
cloudy(configurator);
configurator.AddComponent <CloudyAssemblyHandle>();
if (Assembly.GetCallingAssembly() != Assembly.GetExecutingAssembly())
{
configurator.AddComponentAssembly(Assembly.GetCallingAssembly());
}
var AssemblyProvider = new AssemblyProvider(options.Assemblies.Select(a => new AssemblyWrapper(a)));
services.AddSingleton <IAssemblyProvider>(AssemblyProvider);
services.AddSingleton <IContextDescriptorProvider>(new ContextDescriptorProvider(ContextDescriptor.CreateFrom(options.Contexts)));
foreach (var injector in new DependencyInjectorProvider(new DependencyInjectorCreator(AssemblyProvider)).GetAll())
{
injector.InjectDependencies(services);
}
services.AddTransient <IStartupFilter, InitializerBootstrapper>();
}
/// <summary>
/// Assembly has been registered (every assembly has to be registered exactly one if loaded).
/// </summary>
/// <param name="assembly">Registered assembly.</param>
private void _onAssemblyRegistered(AssemblyProvider assembly)
{
//attach after action to outer scope of assembly
after_reloadAssembly(assembly);
startTransaction("Registering assembly: " + assembly.Name);
//hook component handlers
assembly.ComponentAdded += (compInfo) => _onComponentAdded(assembly, compInfo);
assembly.ComponentRemoved += (compInfo) => _onComponentRemoved(assembly, compInfo);
var services = new TypeServices(assembly, this);
//this assign causes assembly initialization (loading references)
assembly.TypeServices = services;
try
{
if (AssemblyAdded != null)
{
AssemblyAdded(assembly);
}
}
finally
{
commitTransaction();
}
//assembly has to be be initialized only if it is a Root assembly or Root's assembly reference by caller
}
public static IServiceCollection Add_doLittle(this IServiceCollection services)
{
var logAppenders = LoggingConfigurator.DiscoverAndConfigure(Internals.LoggerFactory);
doLittle.Logging.ILogger logger = new Logger(logAppenders);
var assembliesConfigurationBuilder = new AssembliesConfigurationBuilder();
assembliesConfigurationBuilder.IncludeAll();
var contractToImplementorsMap = new ContractToImplementorsMap();
var executingAssembly = typeof(doLittleModule).GetTypeInfo().Assembly;
contractToImplementorsMap.Feed(executingAssembly.GetTypes());
var assemblySpecifiers = new AssemblySpecifiers(assembliesConfigurationBuilder.RuleBuilder, logger);
assemblySpecifiers.SpecifyUsingSpecifiersFrom(executingAssembly);
var assembliesConfiguration = new AssembliesConfiguration(assembliesConfigurationBuilder.RuleBuilder);
var assemblyFilters = new AssemblyFilters(assembliesConfiguration);
var assemblyProvider = new AssemblyProvider(
new ICanProvideAssemblies[] { new DefaultAssemblyProvider(logger) },
assemblyFilters,
new AssemblyUtility(),
assemblySpecifiers);
Internals.AllAssemblies = assemblyProvider.GetAll();
Internals.AssemblyFilters = assemblyFilters;
Internals.AssembliesConfiguration = assembliesConfiguration;
Internals.AssemblyProvider = assemblyProvider;
Internals.Assemblies = new Assemblies(assemblyProvider);
return(services);
}
/// <summary>
/// Adds the root assembly.
/// </summary>
/// <param name="assembly">The assembly.</param>
private void addRootAssembly(AssemblyProvider assembly)
{
//register assembly
_factory.Register(assembly.FullPath, assembly);
//load assembly
Loader.LoadRoot(assembly.FullPath);
}
/// <summary>
/// Handler called for assembly that is invalidated.
/// </summary>
/// <param name="assembly">Invalidated assembly.</param>
private void _onAssemblyInvalidation(AssemblyProvider assembly)
{
//remove invalidated assembly
removeAssembly(assembly);
//affected assemblies can try to reload assembly again
reloadAffectedAssemblies(assembly.Key);
}
/// <summary>
/// Given reference has been added into given <see cref="AssemblyProvider" />. If the
/// referenced assembly doesnot exists it has to be loaded.
/// </summary>
/// <param name="assembly">Assembly which references changed.</param>
/// <param name="reference">Reference that has been added into assembly.</param>
private void _onReferenceAdded(AssemblyProvider assembly, object reference)
{
LoadReferenceAssembly(reference);
//reloading of referencing
Cache.Clear();
CompositionSchemeInvalidation();
}
/// <summary>
/// Handler called on assembly removed.
/// </summary>
/// <param name="provider">The assembly provider.</param>
private void onAssemblyRemoved(AssemblyProvider provider)
{
DispatchedAction(() =>
{
//TODO remove mapping changed handler
_gui.Assemblies.RemoveItem(provider);
});
}
/// <summary>
/// Removes the assembly from AppDomain.
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <returns>TestingAssembly.</returns>
public TestingAssembly RemoveAssembly(AssemblyProvider assembly)
{
afterRuntimeAction(() =>
{
removeRootAssembly(assembly);
});
return(this);
}
/// <summary>
/// Force invalidation of all components that are defined within given assembly.
/// </summary>
/// <param name="assembly">Assembly which components will be invalidated.</param>
private void invalidateDefinedComponents(AssemblyProvider assembly)
{
var componentsCopy = GetComponents(assembly).ToArray();
foreach (var component in componentsCopy)
{
invalidateComponent(assembly, component);
}
}
/// <summary>
/// Handler called on assembly added.
/// </summary>
/// <param name="provider">The assembly provider.</param>
private void onAssemblyAdded(AssemblyProvider provider)
{
DispatchedAction(() =>
{
var assemblyItem = createAssemblyItem(provider);
assemblyItem.MappingChanged += onAssemblyMappingChanged;
_gui.Assemblies.AddItem(provider, assemblyItem);
});
}
private static void RegisterPlugins(ContainerBuilder builder)
{
var assemblies = AssemblyProvider.GetAssemblies().ToArray();
builder.RegisterAssemblyTypes(assemblies).As <IPromotionEntryCodes>().InstancePerLifetimeScope();
builder.RegisterAssemblyTypes(assemblies).As <IProductConverter>().InstancePerLifetimeScope();
builder.RegisterAssemblyTypes(assemblies).As <IAdConverter>().InstancePerLifetimeScope();
builder.RegisterAssemblyTypes(assemblies).As <IProductsAppender>().InstancePerLifetimeScope();
builder.RegisterAssemblyTypes(assemblies).As <IAdsAppender>().InstancePerLifetimeScope();
}
public IEnumerable <T> GetAll <T>() where T : IComposable
{
return(AssemblyProvider
.GetAll()
.SelectMany(a => a.Types)
.Where(t => t.IsClass && !t.IsAbstract && !t.IsInterface && typeof(T).IsAssignableFrom(t))
.Select(t => (T)Instantiator.Instantiate(t))
.ToList()
.AsReadOnly());
}
/// <summary>
/// Handler fired whenever component is removed.
/// </summary>
/// <param name="assembly">Assembly where component has been defined.</param>
/// <param name="removedComponent">Information about removed component.</param>
private void _onComponentRemoved(AssemblyProvider assembly, ComponentInfo removedComponent)
{
_assemblyComponents.Remove(assembly, removedComponent);
_components.Remove(removedComponent.ComponentType);
if (ComponentRemoved != null)
{
ComponentRemoved(removedComponent);
}
}
/// <summary>
/// Try to resolve static (generic/non-generic) method.
/// </summary>
/// <param name="method">Method that is resolved.</param>
/// <param name="definingAssembly">Assembly where method is defined.</param>
/// <returns>Resolved method if available, <c>null</c> otherwise.</returns>
private GeneratorBase tryStaticResolve(MethodID method, out AssemblyProvider definingAssembly)
{
var result = tryStaticExplicitResolve(method, out definingAssembly);
if (result == null)
{
result = tryStaticGenericResolve(method, out definingAssembly);
}
return(result);
}
/// <summary>
/// Get components defined within given assembly and its referenced assemblies.
/// </summary>
/// <param name="assembly">Assembly where components are searched.</param>
/// <returns>Components defined within assembly.</returns>
internal IEnumerable <ComponentInfo> GetReferencedComponents(AssemblyProvider assembly)
{
var result = new List <ComponentInfo>();
foreach (var reference in resolveKeys(assembly.References))
{
result.AddRange(GetComponents(reference));
}
return(result);
}
public ResourceContentProviderTests()
{
var assemblyProvider = new AssemblyProvider
{
Assemblies = new[]
{
typeof(ResourceContentProviderTests).GetTypeInfo().Assembly
}
};
_underTest = new ResourceContentProvider(assemblyProvider, new StackTraceProvider(), new MethodDetailsFilter(assemblyProvider));
}
/// <summary>
/// Gets the type assembly.
/// </summary>
/// <param name="assemblyProvider">The assembly provider.</param>
/// <returns>TypeAssembly.</returns>
internal TypeAssembly GetTypeAssembly(AssemblyProvider assemblyProvider)
{
if (assemblyProvider == null)
{
return(null);
}
TypeAssembly typeAssembly;
_assemblies.TryGetValue(assemblyProvider, out typeAssembly);
return(typeAssembly);
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultAssemblyProvider"/> class.
/// </summary>
public DefaultAssemblyProvider()
{
var localAssemblies = AppDomain.CurrentDomain.GetAssemblies()
.Where(x => x.GetTypes()
.Where(t => string.IsNullOrEmpty(t.Namespace) == false)
.Where(t => t.Namespace.StartsWith(nameof(ConnectedDevelopment), StringComparison.OrdinalIgnoreCase))
.Any() == true)
.ToList();
var provider = new AssemblyProvider(localAssemblies);
_provider = provider;
}
/// <summary>
/// Unregister given assembly if needed from storage.
/// </summary>
/// <param name="assembly">Unregistered assembly.</param>
private void unregisterAssembly(AssemblyProvider assembly)
{
if (_assemblies.Remove(assembly))
{
_assemblyPathIndex.Remove(assembly.FullPath);
_assemblyKeyIndex.Remove(assembly.Key);
if (OnUnRegistered != null)
{
OnUnRegistered(assembly);
}
}
}
/// <summary>
/// Configure by letting Bifrost discover anything that implements the discoverable configuration interfaces
/// </summary>
/// <returns></returns>
public static Configure DiscoverAndConfigure(Action <AssembliesConfigurationBuilder> assembliesConfigurationBuilderCallback = null, IEnumerable <ICanProvideAssemblies> additionalAssemblyProviders = null)
{
IContractToImplementorsMap contractToImplementorsMap;
var assembliesConfigurationBuilder = BuildAssembliesConfigurationIfCallbackDefined(assembliesConfigurationBuilderCallback);
contractToImplementorsMap = new ContractToImplementorsMap();
var executingAssembly = typeof(Configure).GetTypeInfo().Assembly;
contractToImplementorsMap.Feed(executingAssembly.GetTypes());
var assemblySpecifiers = new AssemblySpecifiers(contractToImplementorsMap, new TypeFinder(), assembliesConfigurationBuilder.RuleBuilder);
assemblySpecifiers.SpecifyUsingSpecifiersFrom(executingAssembly);
var assemblyProviders = new List <ICanProvideAssemblies>
{
#if (NET461)
new AppDomainAssemblyProvider(),
#endif
//new DefaultAssemblyProvider()
new FileSystemAssemblyProvider(new FileSystem())
};
if (additionalAssemblyProviders != null)
{
assemblyProviders.AddRange(additionalAssemblyProviders);
}
var assembliesConfiguration = new AssembliesConfiguration(assembliesConfigurationBuilder.RuleBuilder);
var assemblyProvider = new AssemblyProvider(
assemblyProviders,
new AssemblyFilters(assembliesConfiguration),
new AssemblyUtility(),
assemblySpecifiers,
contractToImplementorsMap);
var assemblies = assemblyProvider.GetAll();
var canCreateContainerType = DiscoverCanCreateContainerType(assemblies);
ThrowIfCanCreateContainerNotFound(canCreateContainerType);
ThrowIfCanCreateContainerDoesNotHaveDefaultConstructor(canCreateContainerType);
var canCreateContainerInstance = Activator.CreateInstance(canCreateContainerType) as ICanCreateContainer;
var container = canCreateContainerInstance.CreateContainer();
var configure = With(container, BindingLifecycle.Transient, assembliesConfiguration, assemblyProvider, contractToImplementorsMap);
configure.EntryAssembly = canCreateContainerType.GetTypeInfo().Assembly;
configure.Initialize();
return(configure);
}
/// <summary>
/// Adds specified assembly to the AppDomain.
/// </summary>
/// <param name="testAssembly">The test assembly.</param>
/// <returns>TestingAssembly.</returns>
public TestingAssembly AddAssembly(AssemblyProvider testAssembly)
{
afterRuntimeAction(() =>
{
addRootAssembly(testAssembly);
var runtime = testAssembly as RuntimeAssembly;
if (runtime != null)
{
runtime.BuildAssembly();
}
});
return(this);
}
/// <summary>
/// Add root assembly which composition points are displayed to the user. It
/// will be present within AppDomain until explicit unload.
/// </summary>
/// <param name="assembly">Added assembly.</param>
internal void AddRoot(AssemblyProvider assembly)
{
if (!_rootAssemblies.Add(assembly))
{
//assembly is already contained
return;
}
registerAssembly(assembly);
if (OnRootAdd != null)
{
OnRootAdd(assembly);
}
}
/// <summary>
/// Resolve method generator with exact method ID (no generic method searches).
/// </summary>
/// <param name="method">Resolved method.</param>
/// <param name="definingAssembly">Assembly where method is defined.</param>
/// <returns>Generator for resolved method, or null, if there is no available generator.</returns>
private GeneratorBase tryStaticExplicitResolve(MethodID method, out AssemblyProvider definingAssembly)
{
foreach (var assembly in _assemblies.Providers)
{
var generator = assembly.GetMethodGenerator(method);
if (generator != null)
{
definingAssembly = assembly;
return(generator);
}
}
definingAssembly = null;
return(null);
}
public void DeepClone()
{
var item = new AssemblyProvider().GetAssemblies();
Person person = new Person
{
Name = "小明",
Gender = Gender.Boy
};
var newPerson = person.DeepClone(person);
newPerson.Name = "小明哥";
var newPerson2 = person.ShallowClone <Person>();
Check.True(person.Name != newPerson.Name, "方法有误");
Check.True(person.Name == newPerson2.Name, "方法有误");
}
/// <summary>
/// Handler called on the host path changed.
/// </summary>
/// <param name="path">The path.</param>
void onHostPathChanged(string path)
{
_vs.SafeRunAction(() =>
{
//unload old assembly if available
if (_hostAssembly != null)
{
var unloadTransaction = _appDomain.Transactions.StartNew("Unloading host assembly");
try
{
if (HostAssemblyUnLoaded != null)
{
HostAssemblyUnLoaded(_hostAssembly);
}
_appDomain.Loader.UnloadRoot(_hostAssembly.FullPath);
_hostAssembly = null;
}
finally
{
unloadTransaction.Commit();
}
}
if (path == null)
{
return;
}
var loadTransaction = _appDomain.Transactions.StartNew("Unloading host assembly");
try
{
//load assembly according to new path
_hostAssembly = _appDomain.Loader.LoadRoot(path);
if (_hostAssembly != null && HostAssemblyLoaded != null)
{
HostAssemblyLoaded(_hostAssembly);
}
}
finally
{
loadTransaction.Commit();
}
}, "Changing host assembly path");
}
