/// <summary>
/// Construct an instance of the <see cref="RegistrationSourceAddedEventArgs"/> class.
/// </summary>
/// <param name="componentRegistry">The registry to which the source was added.</param>
/// <param name="registrationSource">The source that was added.</param>
/// <exception cref="ArgumentNullException"></exception>
public RegistrationSourceAddedEventArgs(IComponentRegistry componentRegistry, IRegistrationSource registrationSource)
{
if (componentRegistry == null) throw new ArgumentNullException("componentRegistry");
if (registrationSource == null) throw new ArgumentNullException("registrationSource");
_componentRegistry = componentRegistry;
_registrationSource = registrationSource;
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
var implementationType = registration.Activator.LimitType;
foreach (var autoWireType in autoWireTypes)
{
var constructors = implementationType.GetConstructorsWithDependency(autoWireType);
if (constructors.Any())
{
registration.Preparing += (sender, e) =>
{
var parameter = new TypedParameter(autoWireType,
e.Context.Resolve(autoWireType, new TypedParameter(typeof(Type), implementationType)));
e.Parameters = e.Parameters.Concat(new[] { parameter });
};
}
else
{
var props = implementationType.GetPropertiesWithDependency(autoWireType);
if (props.Any())
{
registration.Activated += (s, e) =>
{
foreach (var prop in props)
{
prop.SetValue(e.Instance,
e.Context.Resolve(autoWireType));
}
};
}
}
}
foreach (var serviceType in typebasedServiceTypes)
{
var constructorInjectors = BuildConstructorServiceInjectors(implementationType, serviceType).ToArray();
if (constructorInjectors.Any())
{
registration.Preparing += (s, e) =>
{
foreach (var ci in constructorInjectors)
ci(e);
};
return;
}
// build an array of actions on this type to assign loggers to member properties
var injectors = BuildPropertyServiceInjectors(implementationType, serviceType).ToArray();
if (injectors.Any())
{
registration.Activated += (s, e) =>
{
foreach (var injector in injectors)
injector(e.Context, e.Instance);
};
}
}
}
public CopyOnWriteRegistry(IComponentRegistry readRegistry, Func<IComponentRegistry> createWriteRegistry)
{
if (readRegistry == null) throw new ArgumentNullException("readRegistry");
if (createWriteRegistry == null) throw new ArgumentNullException("createWriteRegistry");
_readRegistry = readRegistry;
_createWriteRegistry = createWriteRegistry;
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
registration.Preparing += (sender, args) =>
{
args.Parameters = args.Parameters.Union( new[] { new NamedParameter(@"basePoint", _basePoint) } );
};
}
public void Configure(IComponentRegistry componentRegistry)
{
componentRegistry.Registered += (s, e) =>
{
e.ComponentRegistration.Preparing += OnComponentPreparing;
};
}
public void Configure(IComponentRegistry componentRegistry)
{
var builder = new ContainerBuilder();
if (_atomicStorageFactory == null)
{
AtomicIsInMemory(strategyBuilder => { });
}
if (_streamingRoot == null)
{
StreamingIsInFiles(Directory.GetCurrentDirectory());
}
if (_tapeStorage == null)
{
TapeIsInMemory();
}
var core = new AtomicRegistrationCore(_atomicStorageFactory);
var source = new AtomicRegistrationSource(core);
builder.RegisterSource(source);
builder.RegisterInstance(new NuclearStorage(_atomicStorageFactory));
builder
.Register(
c => new AtomicStorageInitialization(new[] {_atomicStorageFactory}, c.Resolve<ISystemObserver>()))
.As<IEngineProcess>().SingleInstance();
builder.RegisterInstance(_streamingRoot);
builder.RegisterInstance(_tapeStorage);
builder.RegisterInstance(new TapeStorageInitilization(new[] {_tapeStorage})).As<IEngineProcess>();
builder.Update(componentRegistry);
}
protected override void AttachToComponentRegistration(
IComponentRegistry componentRegistry,
IComponentRegistration registration)
{
registration.Preparing += (sender, args) =>
log.Debug($@"Resolving concrete type {args.Component.Activator.LimitType}");
}
protected override void AttachToComponentRegistration(IComponentRegistry registry, IComponentRegistration registration)
{
registration.Preparing += (s, e) =>
{
e.Parameters = new [] { loggerParameter }.Concat(e.Parameters);
};
}
/// <summary>
/// Create a root lifetime scope for the provided components.
/// </summary>
/// <param name="tag">The tag applied to the <see cref="ILifetimeScope"/>.</param>
/// <param name="componentRegistry">Components used in the scope.</param>
public LifetimeScope(IComponentRegistry componentRegistry, object tag)
: this()
{
_componentRegistry = Enforce.ArgumentNotNull(componentRegistry, "componentRegistry");
_root = this;
_tag = Enforce.ArgumentNotNull(tag, "tag");
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
var type = registration.Activator.LimitType; // AF2.0+
// .Descriptor.BestKnownImplementationType; // AF1.2+
// we hook preparing to inject the logger into the constructor
registration.Preparing += OnComponentPreparing;
// build the list of actions for type and assign loggers to properties
var injectors = BuildLogPropertyInjectors(type);
// no logger properties, no need to hook up the event
// ReSharper disable PossibleMultipleEnumeration
if (!injectors.Any())
// ReSharper restore PossibleMultipleEnumeration
return;
// we hook acticating to inject the logger into the known public properties
registration.Activating += (s, e) =>
{
// ReSharper disable PossibleMultipleEnumeration
foreach (var injector in injectors)
// ReSharper restore PossibleMultipleEnumeration
injector(e.Context, e.Instance);
};
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry,
IComponentRegistration registration)
{
registration.Preparing += RegistrationOnPreparing;
registration.Activating += RegistrationOnActivating;
base.AttachToComponentRegistration(componentRegistry, registration);
}
protected override void AttachToRegistrationSource(IComponentRegistry componentRegistry, IRegistrationSource registrationSource)
{
base.AttachToRegistrationSource(componentRegistry, registrationSource);
var message = new RegistrationSourceAddedMessage(_modelMapper.GetRegistrationSourceModel(registrationSource));
Send(message);
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
registration.Activating += (sender, e) =>
{
if (typeof (IMessageConsumer).IsAssignableFrom(e.Instance.GetType()))
consumerInterceptor.ItemCreated(e.Instance.GetType(), e.Component.Lifetime.GetType().Equals(typeof(CurrentScopeLifetime)));
};
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
registration.Preparing += (sender, args) => args.Parameters = args.Parameters.Concat(new[]
{
new ResolvedParameter((info, context) => info.ParameterType == typeof (ILog),
(info, context) => _logFactory(info.Member.DeclaringType))
});
}
/// <summary>
/// Construct an instance of the <see cref="RegistrationSourceAddedEventArgs"/> class.
/// </summary>
/// <param name="componentRegistry">The registry to which the source was added.</param>
/// <param name="registrationSource">The source that was added.</param>
/// <exception cref="ArgumentNullException"></exception>
public RegistrationSourceAddedEventArgs(IComponentRegistry componentRegistry, IRegistrationSource registrationSource)
{
if (componentRegistry == null) throw new ArgumentNullException(nameof(componentRegistry));
if (registrationSource == null) throw new ArgumentNullException(nameof(registrationSource));
ComponentRegistry = componentRegistry;
RegistrationSource = registrationSource;
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
Type implementationType = registration.Activator.LimitType;
if (DynamicProxyContext.From(registration) != null && implementationType.FullName == "Orchard.Car.Services.CarInfoService")
{
registration.InterceptedBy<SimpleInterceptor>();
}
}
public void Configure(IComponentRegistry componentRegistry)
{
// This is necessary as generic dependencies are currently not resolved, see issue: http://orchard.codeplex.com/workitem/18141
var builder = new ContainerBuilder();
builder.RegisterGeneric(typeof(Resolve<>)).As(typeof(IResolve<>));
builder.Update(componentRegistry);
}
/// <summary>
/// Initializes a new instance of the <see cref="ComponentRegisteredEventArgs"/> class.
/// </summary>
/// <param name="registry">The container into which the registration
/// was made.</param>
/// <param name="componentRegistration">The component registration.</param>
public ComponentRegisteredEventArgs(IComponentRegistry registry, IComponentRegistration componentRegistration)
{
if (registry == null) throw new ArgumentNullException(nameof(registry));
if (componentRegistration == null) throw new ArgumentNullException(nameof(componentRegistration));
ComponentRegistry = registry;
ComponentRegistration = componentRegistration;
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
// Handle constructor parameters.
registration.Preparing += OnComponentPreparing;
// Handle properties.
registration.Activated += (sender, e) => InjectLoggerProperties(e.Instance);
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
// Use the event args to log detailed info
registration.Preparing += (sender, args) =>
Debug.WriteLine(
"Resolving concrete type {0}, Id {1}",
args.Component.Activator.LimitType, args.Component.Id.ToString());
}
/// <summary>
/// Create a lifetime scope for the provided components and nested beneath a parent.
/// </summary>
/// <param name="tag">The tag applied to the <see cref="ILifetimeScope"/>.</param>
/// <param name="componentRegistry">Components used in the scope.</param>
/// <param name="parent">Parent scope.</param>
protected LifetimeScope(IComponentRegistry componentRegistry, LifetimeScope parent, object tag)
: this(componentRegistry, tag)
{
if (parent == null) throw new ArgumentNullException(nameof(parent));
_parent = parent;
RootLifetimeScope = _parent.RootLifetimeScope;
}
/// <summary>
/// Override to attach module-specific functionality to a
/// component registration.
/// </summary>
/// <remarks>This method will be called for all existing <i>and future</i> component
/// registrations - ordering is not important.</remarks>
/// <param name="componentRegistry">The component registry.</param>
/// <param name="registration">The registration to attach functionality to.</param>
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
if (registration == null)
{
throw new ArgumentNullException("registration");
}
foreach (var property in MetadataHelper.GetMetadata(registration.Activator.LimitType))
registration.Metadata.Add(property);
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
base.AttachToComponentRegistration(componentRegistry, registration);
if (registration.Activator.LimitType.IsAssignableTo<IHandle>())
{
registration.Activated += RegistrationOnActivated;
}
}
/// <summary>
/// Apply the module to the component registry.
/// </summary>
/// <param name="componentRegistry">Component registry to apply configuration to.</param>
public void Configure(IComponentRegistry componentRegistry)
{
if (componentRegistry == null) throw new ArgumentNullException("componentRegistry");
var moduleBuilder = new ContainerBuilder();
Load(moduleBuilder);
moduleBuilder.Update(componentRegistry);
AttachToRegistrations(componentRegistry);
AttachToSources(componentRegistry);
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
var implementationType = registration.Activator.LimitType;
var property = FindProperty(implementationType);
if (property != null) {
registration.InterceptedBy<ISecurityModuleInterceptor>();
}
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration) {
if (!registration.Services.Contains(new TypedService(typeof(ICommandHandler))))
return;
var builder = new CommandHandlerDescriptorBuilder();
var descriptor = builder.Build(registration.Activator.LimitType);
registration.Metadata.Add(typeof(CommandHandlerDescriptor).FullName, descriptor);
}
void IModule.Configure(IComponentRegistry componentRegistry)
{
ApplyProxyFactory(_config);
_builder.RegisterInstance(_config.BuildSessionFactory());
// Session is created for the entire message batch
_builder.Register(ComposeSession)
.InstancePerMatchingLifetimeScope(DispatchLifetimeScopeTags.MessageEnvelopeScopeTag);
_builder.Update(componentRegistry);
}
/// <summary>
/// Apply the module to the component registry.
/// </summary>
/// <param name = "componentRegistry">
/// Component registry to apply configuration to.
/// </param>
public void Configure(IComponentRegistry componentRegistry)
{
foreach (var registration in componentRegistry.Registrations)
{
this.AttachToComponentRegistration(registration);
}
componentRegistry.Registered +=
(sender, e) => this.AttachToComponentRegistration(e.ComponentRegistration);
}
/// <summary>
/// Create a root lifetime scope for the provided components.
/// </summary>
/// <param name="tag">The tag applied to the <see cref="ILifetimeScope"/>.</param>
/// <param name="componentRegistry">Components used in the scope.</param>
public LifetimeScope(IComponentRegistry componentRegistry, object tag)
: this()
{
if (componentRegistry == null) throw new ArgumentNullException(nameof(componentRegistry));
if (tag == null) throw new ArgumentNullException(nameof(tag));
ComponentRegistry = componentRegistry;
RootLifetimeScope = this;
Tag = tag;
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
base.AttachToComponentRegistration(componentRegistry, registration);
var includedTypes = _modelMapper.GetReferencedTypes(registration);
foreach (var includedType in includedTypes)
SendTypeModelIfNeeded(includedType);
var message = new ComponentAddedMessage(_modelMapper.GetComponentModel(registration));
Send(message);
}
public static void RegisterEventStoreStorage(this IComponentRegistry registry)
{
Guard.AgainstNull(registry, nameof(registry));
registry.AttemptRegister <IScriptProviderConfiguration, ScriptProviderConfiguration>();
registry.AttemptRegister <IScriptProvider, ScriptProvider>();
registry.AttemptRegister <IConcurrencyExceptionSpecification, ConcurrencyExceptionSpecification>();
registry.AttemptRegister <IDatabaseContextCache, ThreadStaticDatabaseContextCache>();
registry.AttemptRegister <IDatabaseContextFactory, DatabaseContextFactory>();
registry.AttemptRegister <IDbConnectionFactory, DbConnectionFactory>();
registry.AttemptRegister <IDbCommandFactory, DbCommandFactory>();
registry.AttemptRegister <IDatabaseGateway, DatabaseGateway>();
registry.AttemptRegister <IQueryMapper, QueryMapper>();
registry.AttemptRegister <IPrimitiveEventRepository, PrimitiveEventRepository>();
registry.AttemptRegister <IPrimitiveEventQueryFactory, PrimitiveEventQueryFactory>();
registry.AttemptRegister <IKeyStoreQueryFactory, KeyStoreQueryFactory>();
registry.AttemptRegister <IKeyStore, KeyStore>();
registry.AttemptRegister <IEventTypeStore, EventTypeStore>();
registry.AttemptRegister <IEventTypeStoreQueryFactory, EventTypeStoreQueryFactory>();
}
protected override void RegisterComponents(IComponentRegistry registry, IDataFacility facility)
{
registry.Register <IDbContextDataProvider <TDbContext> >()
.Add <DbContextDataProvider <TTag, TDbContext> >()
.PerScope()
.IfNoneRegistered();
registry.Register <IDataProvider>()
.Add(c => c.Resolve <IDbContextDataProvider <TDbContext> >())
.PerScope()
.IfNotRegistered();
registry.Register <ITransactionManager>()
.Add(c => c.Resolve <IDbContextDataProvider <TDbContext> >().TransactionManager)
.PerScope()
.IfNotRegistered();
foreach (Action <IComponentRegistry, IDataFacility> registrationCallback in _registrationCallbacks)
{
registrationCallback(registry, facility);
}
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
base.AttachToComponentRegistration(componentRegistry, registration);
registration.Activated += (sender, args) =>
{
if (args == null)
{
return;
}
foreach (var i in args.Instance.GetType().GetInterfaces().Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IHandle <>)))
{
var messageType = i.GetGenericArguments().FirstOrDefault();
var method = i.GetMethod("Handle", new[] { messageType });
if (messageType != null)
{
args.Context.Resolve <IMessageAggregator>()
.Messages.Where(m => m.GetType() == messageType)
.Subscribe(m => method.Invoke(args.Instance, new object[] { m }));
}
}
};
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
var implementationType = registration.Activator.LimitType;
// build an array of actions on this type to assign loggers to member properties
var injectors = BuildLoggerInjectors(implementationType).ToArray();
// if there are no logger properties, there's no reason to hook the activated event
if (!injectors.Any())
{
return;
}
// otherwise, whan an instance of this component is activated, inject the loggers on the instance
registration.Activated += (s, e) =>
{
foreach (var injector in injectors)
{
injector(e.Context, e.Instance);
}
};
}
public static CodeLensFeature Create(
IComponentRegistry components,
EditorSession editorSession)
{
var codeLenses =
new CodeLensFeature(
editorSession,
components.Get <IMessageHandlers>(),
components.Get <ILogger>());
codeLenses.Providers.Add(
new ReferencesCodeLensProvider(
editorSession));
codeLenses.Providers.Add(
new PesterCodeLensProvider(
editorSession));
editorSession.Components.Register <ICodeLenses>(codeLenses);
return(codeLenses);
}
public void WhenContainerIsBuilt_OnRegisteredHandlersAreInvoked()
{
var builder = new ContainerBuilder();
var marker = "marker";
IComponentRegistry registry = null;
IComponentRegistration cr = null;
builder.RegisterType <object>()
.WithMetadata(marker, marker)
.OnRegistered(e =>
{
registry = e.ComponentRegistry;
cr = e.ComponentRegistration;
});
var container = builder.Build();
Assert.Same(container.ComponentRegistry, registry);
Assert.Same(marker, cr.Metadata[marker]);
}
static void ScanAssemblies(IEnumerable <Assembly> assemblies, IComponentRegistry cr, IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> rb)
{
rb.ActivatorData.Filters.Add(t =>
rb.RegistrationData.Services.OfType <IServiceWithType>().All(swt =>
swt.ServiceType.IsAssignableFrom(t)));
foreach (var t in assemblies
.SelectMany(a => a.GetTypes())
.Where(t =>
t.IsClass &&
!t.IsAbstract &&
!t.IsGenericTypeDefinition &&
!t.IsDelegate() &&
rb.ActivatorData.Filters.All(p => p(t))))
{
var scanned = RegistrationBuilder.ForType(t)
.FindConstructorsWith(rb.ActivatorData.ConstructorFinder)
.UsingConstructor(rb.ActivatorData.ConstructorSelector)
.WithParameters(rb.ActivatorData.ConfiguredParameters)
.WithProperties(rb.ActivatorData.ConfiguredProperties);
scanned.RegistrationData.CopyFrom(rb.RegistrationData, false);
foreach (var action in rb.ActivatorData.ConfigurationActions)
{
action(t, scanned);
}
if (scanned.RegistrationData.Services.Any())
{
RegistrationBuilder.RegisterSingleComponent(cr, scanned);
}
}
foreach (var postScanningCallback in rb.ActivatorData.PostScanningCallbacks)
{
postScanningCallback(cr);
}
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
base.AttachToComponentRegistration(componentRegistry, registration);
if (registration.Activator.LimitType == typeof(TService))
{
registration.Preparing += (sender, e) =>
{
e.Parameters = e.Parameters.Union(
new[]
{
new ResolvedParameter(
(p, i) => p.ParameterType == typeof(HttpClient),
(p, i) => {
HttpClient client = i.Resolve <IHttpClientFactory>().CreateClient();
this._clientConfigurator(client);
return(client);
}
)
});
};
}
}
/// <summary>
/// Register a component in the component registry. This helper method is necessary
/// in order to execute OnRegistered hooks and respect PreserveDefaults.
/// </summary>
/// <remarks>Hoping to refactor this out.</remarks>
/// <param name="cr">Component registry to make registration in.</param>
/// <param name="builder">Registration builder with data for new registration.</param>
public static void RegisterSingleComponent <TLimit, TActivatorData, TSingleRegistrationStyle>(
IComponentRegistry cr,
IRegistrationBuilder <TLimit, TActivatorData, TSingleRegistrationStyle> builder)
where TSingleRegistrationStyle : SingleRegistrationStyle
where TActivatorData : IConcreteActivatorData
{
if (cr == null)
{
throw new ArgumentNullException(nameof(cr));
}
var registration = CreateRegistration(builder);
cr.Register(registration, builder.RegistrationStyle.PreserveDefaults);
var registeredEventArgs = new ComponentRegisteredEventArgs(cr, registration);
foreach (var rh in builder.RegistrationStyle.RegisteredHandlers)
{
rh(cr, registeredEventArgs);
}
}
/// <summary>
/// Creates an instance of all types implementing the `IComponentRegistryBootstrap` interface and calls the `Register`
/// method.
/// </summary>
/// <param name="registry">The `IComponentRegistry` instance to pass register the components in.</param>
/// <param name="registryConfiguration">The `IComponentRegistryConfiguration` instance that contains the registry configuration.</param>
/// <param name="bootstrapConfiguration">The `IBootstrapConfiguration` instance that contains the bootstrapping configuration.</param>
public static void RegistryBoostrap(this IComponentRegistry registry,
IComponentRegistryConfiguration registryConfiguration, IBootstrapConfiguration bootstrapConfiguration)
{
Guard.AgainstNull(registry, "registry");
var completed = new List <Type>();
var reflectionService = new ReflectionService();
foreach (var assembly in bootstrapConfiguration.Assemblies)
{
foreach (var type in reflectionService.GetTypes <IComponentRegistryBootstrap>(assembly))
{
if (completed.Contains(type))
{
continue;
}
type.AssertDefaultConstructor(string.Format(InfrastructureResources.DefaultConstructorRequired,
"IComponentRegistryBootstrap", type.FullName));
((IComponentRegistryBootstrap)Activator.CreateInstance(type)).Register(registry);
completed.Add(type);
}
}
foreach (var component in registryConfiguration.Components)
{
registry.Register(component.DependencyType, component.ImplementationType, component.Lifestyle);
}
foreach (var collection in registryConfiguration.Collections)
{
registry.RegisterCollection(collection.DependencyType, collection.ImplementationTypes,
collection.Lifestyle);
}
}
#pragma warning restore CA2213
public void Init(IPluginInterface pluginInterface, IComponentRegistry componentRegistry)
{
this.pluginInterface = pluginInterface;
Style.PluginInterface = pluginInterface;
if (!GdiAvailabilityTest.Test())
{
pluginInterface.Logger.Error(T._("Die Bibliothek libgdiplus wurde nicht gefunden! Die Bildfahrplanfunktionen stehen nicht zur Verfügung. Zur Installation siehe Installatiosnhinweise unter https://fahrplan.manuelhu.de/download/."));
return;
}
dpf = new DynamicPreview();
componentRegistry.Register <IPreviewAction>(dpf);
pluginInterface.AppClosing += (s, e) => dpf.Close();
#if !DEBUG
if (pluginInterface.Settings.Get <bool>("feature.enable-full-graph-editor"))
{
#endif
pluginInterface.FileStateChanged += PluginInterface_FileStateChanged;
graphItem = ((MenuBar)pluginInterface.Menu).CreateItem(T._("B&ildfahrplan"));
showItem = graphItem.CreateItem(T._("&Anzeigen"), enabled: false, clickHandler: ShowItem_Click);
graphItem.Items.Add(new SeparatorMenuItem());
printItem = graphItem.CreateItem(T._("&Drucken"), enabled: false, clickHandler: PrintItem_Click);
exportItem = graphItem.CreateItem(T._("&Exportieren"), enabled: false, clickHandler: ExportItem_Click);
graphItem.Items.Add(new SeparatorMenuItem());
configItem = graphItem.CreateItem(T._("Darste&llung ändern"), enabled: false, clickHandler: (s, ev) => ShowForm(new ConfigForm(pluginInterface.Timetable, pluginInterface)));
virtualRoutesItem = graphItem.CreateItem(T._("&Virtuelle Strecken"), enabled: false, clickHandler: (s, ev) => ShowForm(new VirtualRouteForm(pluginInterface)));
trainColorItem = graphItem.CreateItem(T._("&Zugdarstellung ändern"), enabled: false, clickHandler: (s, ev) => ShowForm(new TrainStyleForm(pluginInterface)));
stationStyleItem = graphItem.CreateItem(T._("&Stationsdarstellung ändern"), enabled: false, clickHandler: (s, ev) => ShowForm(new StationStyleForm(pluginInterface)));
overrideItem = graphItem.CreateCheckItem(T._("Verwende nur &Plandarstellung"), isChecked: pluginInterface.Settings.Get <bool>("bifpl.override-entity-styles"),
changeHandler: OverrideItem_CheckedChanged);
#if !DEBUG
}
#endif
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
registration.Preparing += (sender, args) =>
{
bool Match(ParameterInfo info, IComponentContext context)
{
return(typeof(Microsoft.Extensions.Logging.ILogger).IsAssignableFrom(info.ParameterType));
}
object Provide(ParameterInfo info, IComponentContext context)
{
Type loggerType = typeof(XUnitLogger <>).MakeGenericType(info.Member.DeclaringType);
ConstructorInfo constructor = loggerType.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, new[] { typeof(ILogger) }, null);
Debug.Assert(constructor != null);
object instance = constructor.Invoke(new object[] { this.logger.ForContext(info.Member.DeclaringType) });
return(instance);
}
args.Parameters = args.Parameters.Union(new[] { new ResolvedParameter(Match, Provide) });
};
}
public static IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> RegisterOwinApplicationContainer(this ContainerBuilder builder)
{
return(builder.Register(ctx =>
{
ILifetimeScope scope = ctx.Resolve <ILifetimeScope>().BeginLifetimeScope();
IComponentRegistry registry = scope.ComponentRegistry;
ContainerBuilder newBuilder = new ContainerBuilder();
newBuilder.Register(c => new RuntimeRegistrationDelegate(func =>
{
Tuple <Type, object> registerResult = func(scope as IServiceProvider);
ContainerBuilder innerNewBuilder = new ContainerBuilder();
innerNewBuilder.Register(_ => registerResult.Item2)
.As(registerResult.Item1)
.ExternallyOwned();
innerNewBuilder.Update(registry);
})).As <RuntimeRegistrationDelegate>().InstancePerLifetimeScope();
newBuilder.Update(registry);
return scope as IServiceProvider;
}).As <IServiceProvider>() as IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle>);
}
/// <summary>
/// Releases all managed resources.
/// </summary>
/// <param name="calledFromFinalizer">Specifies if this method is called from finalizer or not</param>
private void Dispose(bool calledFromFinalizer)
{
if (!_disposed)
{
_disposed = true;
if (_componentRegistry != null)
{
foreach (ComponentRegistration regEntry in _componentRegistry.GetRegistrations())
{
CleanUpComponentInstance(regEntry);
}
_componentRegistry.Clear();
_componentRegistry = null;
}
if (!calledFromFinalizer)
{
GC.SuppressFinalize(this);
}
}
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry,
IComponentRegistration registration)
{
var implementationType = registration.Activator.LimitType;
// 根据此类型构建一个actions数组用于把logger赋值给成员属性
var injectors = BuildLoggerInjectors(implementationType).ToArray();
// 如果没有logger属性，就没有需要活动事件钩子的理由
if (!injectors.Any())
{
return;
}
// 否则，如果激活一个该组件的实例，则在实例上注入loggers
registration.Activated += (s, e) =>
{
foreach (var injector in injectors)
{
injector(e.Context, e.Instance);
}
};
}
public override void Update(GameTime gameTime)
{
// Get running worlds.
IReadOnlyList <IWorld> worlds = worldManager.GetWorldsInState(WorldState.Running);
// Iterate through worlds.
foreach (IWorld world in worlds)
{
// Check if the world has the sprite font component.
if (!world.ComponentManager.ContainsRegistry <TextRenderComponent>())
{
continue;
}
// Get component registries.
IComponentRegistry <PositionComponent> positionComponents =
(IComponentRegistry <PositionComponent>)world.ComponentManager.GetRegistry <PositionComponent>();
IComponentRegistry <TextRenderComponent> spriteFontComponents =
(IComponentRegistry <TextRenderComponent>)world.ComponentManager.GetRegistry <TextRenderComponent>();
// Begin sprite batch.
spriteBatch.Begin();
// Iterate through sprite font components and render.
foreach (TextRenderComponent component in spriteFontComponents)
{
// Get position.
PositionComponent position = positionComponents.Get(component.EntityID);
// Render text.
spriteBatch.DrawString(component.Font, component.Text, new Vector2(position.X, position.Y), component.Colour);
}
// End sprite batch.
spriteBatch.End();
}
}
public override void Update(GameTime gameTime)
{
// Check if there events to process.
if (scoreEvents.Count == 0)
{
return;
}
// Get HUD world.
IWorld world = worldManager.GetWorld((int)WorldID.HudWorld);
// Get text render component registry.
IComponentRegistry <TextRenderComponent> textRenders =
(IComponentRegistry <TextRenderComponent>)world.ComponentManager.GetRegistry <TextRenderComponent>();
foreach (ScoreEvent score in scoreEvents)
{
// Update score and text.
if (score.Player == 1)
{
player1Score += score.Amount;
TextRenderComponent component = textRenders.Get(player1Text);
component.Text = player1Score.ToString();
textRenders.Set(component);
}
else
{
player2Score += score.Amount;
TextRenderComponent component = textRenders.Get(player2Text);
component.Text = player2Score.ToString();
textRenders.Set(component);
}
}
// Clear list.
scoreEvents.Clear();
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
if (!DataSettings.DatabaseIsInstalled())
{
return;
}
var baseType = typeof(WebApiEntityController <,>);
var type = registration.Activator.LimitType;
Type implementingType;
if (!type.IsSubClass(baseType, out implementingType))
{
return;
}
var repoProperty = FindRepositoryProperty(type, implementingType.GetGenericArguments()[0]);
var serviceProperty = FindServiceProperty(type, implementingType.GetGenericArguments()[1]);
if (repoProperty != null || serviceProperty != null)
{
registration.Activated += (sender, e) =>
{
if (repoProperty != null)
{
var repo = e.Context.Resolve(repoProperty.PropertyType);
repoProperty.SetValue(e.Instance, repo, null);
}
if (serviceProperty != null)
{
var service = e.Context.Resolve(serviceProperty.PropertyType);
serviceProperty.SetValue(e.Instance, service, null);
}
};
}
}
public static DocumentSymbolFeature Create(
IComponentRegistry components,
EditorSession editorSession)
{
var documentSymbols =
new DocumentSymbolFeature(
editorSession,
components.Get <IMessageHandlers>(),
components.Get <ILogger>());
documentSymbols.Providers.Add(
new ScriptDocumentSymbolProvider(
editorSession.PowerShellContext.LocalPowerShellVersion.Version));
documentSymbols.Providers.Add(
new PsdDocumentSymbolProvider());
documentSymbols.Providers.Add(
new PesterDocumentSymbolProvider());
editorSession.Components.Register <IDocumentSymbols>(documentSymbols);
return(documentSymbols);
}
public void Init(IPluginInterface pluginInterface, IComponentRegistry componentRegistry)
{
this.pluginInterface = pluginInterface;
if (pluginInterface.Settings.Get <bool>("dump.record"))
{
var defaultPath = pluginInterface.GetTemp("..");
var basePath = pluginInterface.Settings.Get("dump.path", defaultPath);
if (basePath == "")
{
basePath = defaultPath;
}
basePath = Path.GetFullPath(basePath);
if (!Directory.Exists(basePath))
{
Directory.CreateDirectory(basePath);
}
listener = new DebugListener();
listener.StartSession(pluginInterface, basePath);
}
pluginInterface.ExtensionsLoaded += PluginInterfaceOnExtensionsLoaded;
}
public static void RegisterEventProcessing(this IComponentRegistry registry)
{
Guard.AgainstNull(registry, nameof(registry));
if (!registry.IsRegistered <IProjectionConfiguration>())
{
registry.AttemptRegisterInstance <IProjectionConfiguration>(ProjectionSection.Configuration(new ConnectionConfigurationProvider()));
}
registry.AttemptRegister <IScriptProviderConfiguration, ScriptProviderConfiguration>();
registry.AttemptRegister <IScriptProvider, ScriptProvider>();
registry.AttemptRegister <IDatabaseContextCache, ThreadStaticDatabaseContextCache>();
registry.AttemptRegister <IDatabaseContextFactory, DatabaseContextFactory>();
registry.AttemptRegister <IDbConnectionFactory, DbConnectionFactory>();
registry.AttemptRegister <IDbCommandFactory, DbCommandFactory>();
registry.AttemptRegister <IDatabaseGateway, DatabaseGateway>();
registry.AttemptRegister <IQueryMapper, QueryMapper>();
registry.AttemptRegister <IProjectionRepository, ProjectionRepository>();
registry.AttemptRegister <IProjectionQueryFactory, ProjectionQueryFactory>();
registry.AttemptRegister <EventProcessingObserver, EventProcessingObserver>();
registry.AttemptRegister <EventProcessingModule, EventProcessingModule>();
}
protected void Boostrap(IComponentRegistry registry)
{
registry.RegisterInstance <ITransactionScopeFactory>(new DefaultTransactionScopeFactory(false, IsolationLevel.Unspecified, TimeSpan.Zero));
#if (NETCOREAPP2_1 || NETSTANDARD2_0)
DbProviderFactories.RegisterFactory("System.Data.SqlClient", System.Data.SqlClient.SqlClientFactory.Instance);
var connectionConfigurationProvider = new Mock <IConnectionConfigurationProvider>();
connectionConfigurationProvider.Setup(m => m.Get(It.IsAny <string>())).Returns(
(string name) =>
name.Equals("EventStoreProjection")
? new ConnectionConfiguration(
"EventStoreProjection",
"System.Data.SqlClient",
"Data Source=.\\sqlexpress;Initial Catalog=ShuttleProjection;Integrated Security=SSPI;")
: new ConnectionConfiguration(
name,
"System.Data.SqlClient",
"Data Source=.\\sqlexpress;Initial Catalog=Shuttle;Integrated Security=SSPI;"));
registry.AttemptRegisterInstance(connectionConfigurationProvider.Object);
registry.RegisterInstance <IProjectionConfiguration>(new ProjectionConfiguration
{
EventProjectionConnectionString =
connectionConfigurationProvider.Object.Get("EventStoreProjection").ConnectionString,
EventProjectionProviderName =
connectionConfigurationProvider.Object.Get("EventStoreProjection").ProviderName,
EventStoreConnectionString = connectionConfigurationProvider.Object.Get("Shuttle").ConnectionString,
EventStoreProviderName = connectionConfigurationProvider.Object.Get("Shuttle").ProviderName
});
#else
registry.AttemptRegister <IConnectionConfigurationProvider, ConnectionConfigurationProvider>();
#endif
}
private void Build(IComponentRegistry componentRegistry, bool excludeDefaultModules)
{
if (componentRegistry == null)
{
throw new ArgumentNullException(nameof(componentRegistry));
}
if (_wasBuilt)
{
throw new InvalidOperationException(ContainerBuilderResources.BuildCanOnlyBeCalledOnce);
}
_wasBuilt = true;
if (!excludeDefaultModules)
{
RegisterDefaultAdapters(componentRegistry);
}
foreach (var callback in _configurationCallbacks)
{
callback(componentRegistry);
}
}
/// <summary>
/// Create a lifetime scope for the provided components and nested beneath a parent.
/// </summary>
/// <param name="tag">The tag applied to the <see cref="ILifetimeScope"/>.</param>
/// <param name="componentRegistry">Components used in the scope.</param>
/// <param name="parent">Parent scope.</param>
protected LifetimeScope(IComponentRegistry componentRegistry, LifetimeScope parent, object tag)
: this(componentRegistry, tag)
{
_parent = Enforce.ArgumentNotNull(parent, "parent");
_root = _parent.RootLifetimeScope;
}
/// <summary>
/// Create a root lifetime scope for the provided components.
/// </summary>
/// <param name="componentRegistry">Components used in the scope.</param>
public LifetimeScope(IComponentRegistry componentRegistry)
: this(componentRegistry, RootTag)
{
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry,
IComponentRegistration registration)
{
registration.Activated += GetTempDataFromMvcControllers;
}
public static IComponentRegistration GetRegistration <T>(this IComponentRegistry registry)
{
return(GetRegistration(registry, typeof(T)));
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry,
IComponentRegistration registration)
{
registration.Preparing += OnComponentPreparing;
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
registration.Preparing += ConfigureLoggerParameter;
}
public ComponentRegisteredEventArgs(IComponentRegistry registry, IComponentRegistration componentRegistration)
{
this._componentRegistry = Enforce.ArgumentNotNull <IComponentRegistry>(registry, "registry");
this._componentRegistration = Enforce.ArgumentNotNull <IComponentRegistration>(componentRegistration, "componentRegistration");
}
