public void Send <T>(T command) where T : ICommand
{
var handler = InjectContainer.GetInstance <ICommandHandler <T> >();
if (handler != null)
{
try
{
handler.Execute(command);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
handler.Dispose();
}
}
else
{
//Cannot find command handler for type
throw new InvalidOperationException(string.Format("无法找到类型的命令处理程序 '{0}'", typeof(T).FullName));
}
}
private void InjectService()
{
InjectContainer.RegisterType <IPasswordHasher, PlainTextPasswordHasher>();
InjectContainer.RegisterType <IIdentityReadDBConnectionStringProvider, AppsettingRepositoryReadDBConnectionStringProvider>();
InjectContainer.RegisterType <IIdentityWriteDBConnectionStringProvider, AppsettingRepositoryWriteDBConnectionStringProvider>();
InjectContainer.RegisterType <IIdentityReportDataAccessor, IdentityReportDataAccessor>();
}
public void CannotResolveAbstractClass()
{
var container = new InjectContainer();
container.Register<IInterface1, AbstractClass1>();
Assert.That(() => container.Resolve<AbstractClass1>(), Throws.InstanceOf<ResolutionFailedException>());
}
public void CannotResolveInterface()
{
var container = new InjectContainer();
container.Register<IInterface1, IInherited1>();
Assert.That(() => container.Resolve<IInterface1>(), Throws.InstanceOf<ResolutionFailedException>());
}
public void CanCreatePrivateNestedClass()
{
var container = new InjectContainer();
var instance = container.Resolve<PrivateClass>();
Assert.IsNotNull(instance);
}
public void CanCreateOnePublicConstructorClassWithMultiPrivateConstructors()
{
var container = new InjectContainer();
var instance = container.Resolve<MultiplePrivateOnePublicConstructorClass>();
Assert.IsNotNull(instance);
}
static void Main(string[] args)
{
InjectContainer.RegisterType <IDomainRepository, DomainRepository>();
InjectContainer.RegisterType <IEventStorage, SQLServerEventStorage>();
InjectContainer.RegisterInstance <IEventPublisher>(new RabbitMQEventPublisher("amqp://localhost:5672"));
InjectContainer.RegisterType <IEventDBConnectionStringProvider, AppSettingEventDBConnectionStringProvider>();
//这一部分需要重构到配置文件中
InjectContainer.RegisterType <IInventoryReadDBConnectionStringProvider, AppsettingInventoryReadDBConnectionStringProvider>();
InjectContainer.RegisterType <IInventoryWriteDBConnectionStringProvider, AppsettingInventoryWriteDBConnectionStringProvider>();
InjectContainer.RegisterType <IInventoryReportDataAccessor, InventoryReportDataAccessor>();
InjectContainer.RegisterType <IRentalReadDBConnectionStringProvider, AppsettingRentalReadDBConnectionStringProvider>();
InjectContainer.RegisterType <IRentalWriteDBConnectionStringProvider, AppsettingRentalWriteDBConnectionStringProvider>();
InjectContainer.RegisterType <IRentalReportDataAccessor, RentalReportDataAccessor>();
InjectContainer.RegisterType <ICommandTracker, SignalRCommandTracker>();
var handlers = BuildHandlerConfigurations();
HandlerRegister register = new HandlerRegister();
foreach (var handler in handlers)
{
Console.WriteLine($"Starting handler '{handler.Name}'");
RegisterCommandHandlers(handler.LibraryName);
RegisterEventHandlers(handler.LibraryName);
register.RegisterAndStart(handler.LibraryName);
Console.WriteLine($"Started handler '{handler.Name}'");
}
}
public DbContext()
{
var conn = InjectContainer.GetInstance <IEventDBConnectionStringProvider>().ConnectionString;
var client = new MongoClient(conn);
_db = client.GetDatabase("LibraryEventStorage");
}
public static void Register()
{
InjectContainer.RegisterType <ICommonService, CommonService>();
InjectContainer.RegisterType <ILogHelper, LogHelper>();
InjectContainer.RegisterType <IFileService, FileService>();
}
public void CanCreateConcreteArgumentClass()
{
var container = new InjectContainer();
var instance = container.Resolve<ConcreteParameterClass>();
Assert.IsNotNull(instance);
Assert.IsNotNull(instance.Arg);
}
private void InjectService()
{
InjectContainer.RegisterInstance <ICommandPublisher>(new RabbitMQCommandPublisher("amqp://localhost:5672"));
InjectContainer.RegisterType <IInventoryReadDBConnectionStringProvider, AppsettingInventoryReadDBConnectionStringProvider>();
InjectContainer.RegisterType <IInventoryWriteDBConnectionStringProvider, AppsettingInventoryWriteDBConnectionStringProvider>();
InjectContainer.RegisterType <IInventoryReportDataAccessor, InventoryReportDataAccessor>();
InjectContainer.RegisterType <ICommandTracker, SignalRCommandTracker>();
}
private void InjectService()
{
InjectContainer.RegisterType <ILogDBConnectionStringProvider, AppsettingLogDBConnectionStringProvider>();
InjectContainer.RegisterType <ILogger, Logger>();
InjectContainer.RegisterType <IConsulAPIUrlProvider, AppsettingConsulAPIUrlProvider>();
InjectContainer.RegisterType <IServiceDiscovery, ConsulServiceDiscovery>();
}
public QueryService()
{
Reader = InjectContainer.GetInstance <IConfigurationReader>();
DataAccessor = InjectContainer.GetInstance <IQueryDataAccessor>(new Dictionary <string, object>()
{
{ "connectionString", Reader.ConnectionString }
});
}
private static void LogError(Events.DomainEvent domainEvent, System.Exception exception)
{
var errorLogCommand = new AddErrorLogCommand();
errorLogCommand.ErrorObject = domainEvent;
errorLogCommand.Exception = exception;
InjectContainer.GetInstance <ICommandBus>().Send(errorLogCommand);
}
private void InjectService()
{
InjectContainer.RegisterType <IRabbitMQUrlProvider, AppsettingRabbitMQUrlProvider>();
InjectContainer.RegisterType <ICommandPublisher, RabbitMQCommandPublisher>();
InjectContainer.RegisterType <IInventoryReadDBConnectionStringProvider, AppsettingInventoryReadDBConnectionStringProvider>();
InjectContainer.RegisterType <IInventoryWriteDBConnectionStringProvider, AppsettingInventoryWriteDBConnectionStringProvider>();
InjectContainer.RegisterType <IInventoryReportDataAccessor, InventoryReportDataAccessor>();
InjectContainer.RegisterType <ICommandTracker, SignalRCommandTracker>();
}
public CommandHandlerBase()
{
this.Reader = InjectContainer.GetInstance <IConfigurationReader>();
this.DataAccessor = InjectContainer.GetInstance <IDomainDataAccessor>(new Dictionary <string, object>()
{
{ "connectionString", Reader.ConnectionString }
});
this.ExecuteDateTime = Utility.GetCurrentDateTime();
}
public static void ApplicationStart()
{
// Use Project's Web.config Connection Strings
DevExpress.XtraReports.Web.ReportDesigner.DefaultReportDesignerContainer
.RegisterDataSourceWizardConfigFileConnectionStringsProvider();
// Register inject assembilies
InjectContainer.RegisterAssembiles(AppDomain.CurrentDomain.GetAssemblies()
.Where(i => i.FullName.StartsWith("DReporting", StringComparison.InvariantCultureIgnoreCase)));
}
protected virtual void BeforeInject()
{
InjectContainer.RegisterType <IConfigurationReader, ConfigurationReader>();
InjectContainer.RegisterInstance <ILogHelper>(new Log4netHelper());
#if DEBUG
InjectContainer.RegisterInstance <IStringEncrypter>(new PlainTextEncrypter());
#else
InjectContainer.RegisterInstance <IStringEncrypter>(new StringEncrypter());
#endif
}
private static void Injection()
{
var mappings = GetConfiguration().GetSection("diMappings").GetChildren();
foreach (IConfigurationSection mapping in mappings)
{
var source = Assembly.Load(mapping["sAssembly"]).GetType(mapping["interface"]);
var target = Assembly.Load(mapping["tAssembly"]).GetType(mapping["implementation"]);
InjectContainer.RegisterType(source, target);
}
}
private void InjectService()
{
InjectContainer.RegisterType <IRabbitMQUrlProvider, AppsettingRabbitMQUrlProvider>();
InjectContainer.RegisterType <ICommandPublisher, RabbitMQCommandPublisher>();
InjectContainer.RegisterType <IRentalReadDBConnectionStringProvider, AppsettingRentalReadDBConnectionStringProvider>();
InjectContainer.RegisterType <IRentalWriteDBConnectionStringProvider, AppsettingRentalWriteDBConnectionStringProvider>();
InjectContainer.RegisterType <IRentalReportDataAccessor, RentalReportDataAccessor>();
InjectContainer.RegisterType <ICommandTracker, SignalRCommandTracker>();
InjectContainer.RegisterType <IConsulAPIUrlProvider, AppsettingConsulAPIUrlProvider>();
InjectContainer.RegisterType <IServiceDiscovery, ConsulServiceDiscovery>();
}
private void InjectService()
{
InjectContainer.RegisterType <IRabbitMQUrlProvider, AppsettingRabbitMQUrlProvider>();
InjectContainer.RegisterType <IPasswordHasher, PlainTextPasswordHasher>();
InjectContainer.RegisterType <IIdentityReadDBConnectionStringProvider, AppsettingRepositoryReadDBConnectionStringProvider>();
InjectContainer.RegisterType <IIdentityWriteDBConnectionStringProvider, AppsettingRepositoryWriteDBConnectionStringProvider>();
InjectContainer.RegisterType <IIdentityReportDataAccessor, IdentityReportDataAccessor>();
InjectContainer.RegisterType <IConsulAPIUrlProvider, AppsettingConsulAPIUrlProvider>();
InjectContainer.RegisterType <IServiceDiscovery, ConsulServiceDiscovery>();
InjectContainer.RegisterType <ICommandPublisher, RabbitMQCommandPublisher>();
}
public void RegisterAndStart(string libraryName)
{
var connectionString = InjectContainer.GetInstance <IEventDBConnectionStringProvider>().ConnectionString;
Console.WriteLine($"Handler starting...");
Console.WriteLine($"Event DB Connection String: {connectionString}");
RegisterAndStartCommandHandlers(libraryName);
RegisterAndStartEventHandlers(libraryName);
Console.WriteLine($"Handler started.");
}
public void Initialize()
{
var container = new InjectContainer();
container.Register <IMoleculeService, MoleculeService>();
container.Register <IMoleculeRepository, MoleculeRepository>();
container.Register <ILogService, LogService>();
container.Register <ILogRepository, LogRepository>();
container.Register <IAtomService, AtomService>();
container.Register <ILinkService, LinkService>();
_linkService = container.Resolve <ILinkService>();
}
public void SelfRegister()
{
var serviceDiscovery = InjectContainer.GetInstance <IServiceDiscovery>();
serviceDiscovery.RegisterService(new Infrastructure.Operation.Core.Models.Service
{
Port = 5000,
ServiceName = "IdentityService",
Tag = "Microservice API"
});
Console.WriteLine("Register to consul successfully.");
}
public void Initialize()
{
var container = new InjectContainer();
container.Register<IMoleculeService, MoleculeService>();
container.Register<IMoleculeRepository, MoleculeRepository>();
container.Register<ILogService, LogService>();
container.Register<ILogRepository, LogRepository>();
container.Register<IAtomService, AtomService>();
container.Register<ILinkService, LinkService>();
container.Register<IReplacementReactionService, ReplacementReactionService>();
container.Register<IAddictionReactionService, AddictionReactionService>();
_replacementReactionService = container.Resolve<IReplacementReactionService>();
}
private void Connect()
{
var window = InjectContainer.ResolveView <MainWindow>() as Window;
if (AuthenticationService.Login(Login.Text, Password.Password))
{
window?.Show();
Close();
}
else
{
Error.Text = "Login ou mot de passe incorrect !";
}
}
private static void GetServices()
{
var container = new InjectContainer();
container.Register <IMoleculeService, MoleculeService>();
container.Register <IMoleculeRepository, MoleculeRepository>();
container.Register <ILogService, LogService>();
container.Register <ILogRepository, LogRepository>();
container.Register <IAtomService, AtomService>();
container.Register <ILinkService, LinkService>();
container.Register <IReplacementReactionService, ReplacementReactionService>();
container.Register <IAddictionReactionService, AddictionReactionService>();
moleculeService = container.Resolve <IMoleculeService>();
}
public void Subscribe <T>(T domainEvent) where T : DomainEvent
{
this.channel.QueueDeclare(queue: domainEvent.EventKey,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
var consumer = new EventingBasicConsumer(channel);
IEventHandler <T> instance = InjectContainer.GetInstance <IEventHandler <T> >();
if (instance == null)
{
return;
}
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
var cmd = JsonConvert.DeserializeObject <T>(message);
Console.WriteLine("[x] Receive New Event: {0}", domainEvent.EventKey);
Console.WriteLine("[x] Event Parameters: {0}", message);
try
{
//执行命令操作
instance.Handle(cmd);
//tracker.Finish(cmd.CommandUniqueId, cmd.EventKey);
}
catch (Exception ex)
{
//tracker.Error(cmd.CommandUniqueId, cmd.EventKey, "100001", ex.Message);
}
Console.WriteLine("[x] Event Handler Completed");
channel.BasicAck(ea.DeliveryTag, false);
};
channel.BasicConsume(queue: domainEvent.EventKey, autoAck: false, consumer: consumer);
}
private static void RegisterEventHandlers(string libraryName)
{
Func <Type, bool> isEventHandler = i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEventHandler <>);
var commandHandlers = Assembly.Load(libraryName).GetExportedTypes()
.Where(t => t.GetInterfaces().Any(isEventHandler))
.ToList();
var registerSource = commandHandlers.Select(h =>
{
return(new { FromType = h.GetInterfaces().First(isEventHandler), ToType = h });
}).ToList();
foreach (var r in registerSource)
{
InjectContainer.RegisterType(r.FromType, r.ToType);
}
}
public void RegisterAndStartCommandHandlers(string libraryName)
{
var assembly = Assembly.Load(libraryName);
var allCommands = assembly.GetExportedTypes().Where(p => p.GetInterface("ICommand") != null);
foreach (var command in allCommands)
{
var register = new RabbitMQCommandSubscriber(InjectContainer.GetInstance <IRabbitMQUrlProvider>());
var registerMethod = register.GetType().GetMethod("Subscribe");
var cmd = Activator.CreateInstance(command);
Console.WriteLine($"Found command {command.FullName}.");
registerMethod.MakeGenericMethod(command).Invoke(register, new object[1] {
cmd
});
}
}
private void RegisterCommandHandlers()
{
Func <Type, bool> isCommandHandler = i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(ICommandHandler <>);
var commandHandlers = typeof(ICommandHandler <>).Assembly.GetExportedTypes()
.Where(t => t.GetInterfaces().Any(isCommandHandler))
.ToList();
var registerSource = commandHandlers.Select(h =>
{
return(new { FromType = h.GetInterfaces().First(isCommandHandler), ToType = h });
}).ToList();
foreach (var r in registerSource)
{
Logger.LogDebug(typeof(CommandBus), String.Format("Register Command Handler: {0}", r.ToType.FullName));
InjectContainer.RegisterType(r.FromType, r.ToType);
}
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var unity = new UnityContainer();
unity.RegisterType <IRepository, MemoryRepository>();
CacheContext.SetRepository(unity.Resolve <IRepository>());
unity.RegisterType <IMainWindowModel, MainWindowViewModel>();
unity.RegisterType <IDataExporter, ExcelDataExporter>();
InjectContainer.RegisterView <PlanningView>(unity.Resolve <PlanningView>());
InjectContainer.RegisterView <ListOfEmployeesView>(unity.Resolve <ListOfEmployeesView>());
InjectContainer.RegisterView <AddEmployeeView>(unity.Resolve <AddEmployeeView>());
InjectContainer.RegisterView <EmployeesView>(unity.Resolve <EmployeesView>());
InjectContainer.RegisterView <MainWindow>(unity.Resolve <MainWindow>());
var mainWindow = unity.Resolve <AuthenticationWindow>(); // Creating Main window
mainWindow.Show();
}
static void Main()
{
var container = new InjectContainer();
container.Register <IMoleculeService, MoleculeService>();
container.Register <IMoleculeRepository, MoleculeRepository>();
container.Register <ILogService, LogService>();
container.Register <ILogRepository, LogRepository>();
container.Register <IAtomService, AtomService>();
container.Register <ILinkService, LinkService>();
container.Register <IReplacementReactionService, ReplacementReactionService>();
container.Register <IAddictionReactionService, AddictionReactionService>();
var moleculeService = container.Resolve <IMoleculeService>();
var logService = container.Resolve <ILogService>();
var linkService = container.Resolve <ILinkService>();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MoleculeSearchForm(moleculeService, logService, linkService));
}
public void RegisterAndStartEventHandlers(string libraryName)
{
var assembly = Assembly.Load(libraryName);
var allEvents = assembly.GetExportedTypes().Where(p => p.GetInterface("IDomainEvent") != null);
foreach (var @event in allEvents)
{
var register = new RabbitMQEventSubscriber(InjectContainer.GetInstance <IRabbitMQUrlProvider>(), InjectContainer.GetInstance <ICommandTracker>());
if (register != null)
{
var registerMethod = register.GetType().GetMethod("Subscribe");
var cmd = Activator.CreateInstance(@event);
Console.WriteLine($"Found event {@event.FullName}.");
registerMethod.MakeGenericMethod(@event).Invoke(register, new object[1] {
cmd
});
}
}
}
public void Subscribe <T>(T command) where T : ICommand
{
this.channel.QueueDeclare(queue: command.CommandKey,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
var consumer = new EventingBasicConsumer(channel);
ICommandHandler <T> instance = InjectContainer.GetInstance <ICommandHandler <T> >();
if (instance == null)
{
Console.WriteLine($"The command handler for {typeof(T).FullName} is not prepared.");
}
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
var cmd = JsonConvert.DeserializeObject <T>(message);
Console.WriteLine("[x] Receive New Task: {0}", cmd.CommandKey);
Console.WriteLine("[x] Task Parameters: {0}", message);
//执行命令操作
instance.Execute(cmd);
Console.WriteLine("[x] Task Completed");
channel.BasicAck(ea.DeliveryTag, false);
};
channel.BasicConsume(queue: command.CommandKey, autoAck: false, consumer: consumer);
}
public void ResolveAbstractTypeThrows()
{
var container = new InjectContainer();
Assert.That(() => container.Resolve<AbstractClass1>(), Throws.InstanceOf<ResolutionFailedException>());
}
public void ResolveCircularReferenceThrows()
{
var container = new InjectContainer();
container.Register<IInterface1, CircularReference1>();
container.Register<IInterface2, CircularReference2>();
Assert.That(() => container.Resolve<IInterface1>(), Throws.InstanceOf<ResolutionFailedException>());
}
public void ResolveNonConcreteTypeThrows()
{
var container = new InjectContainer();
Assert.That(() => container.Resolve<IInterface1>(), Throws.InstanceOf<ResolutionFailedException>());
}
public void ResolveNullTypeThrows()
{
var container = new InjectContainer();
Assert.That(() => container.Resolve(null), Throws.ArgumentNullException);
}
public void ResolveStaticTypeThrows()
{
var container = new InjectContainer();
Assert.That(() => container.Resolve(typeof(StaticClass)), Throws.InstanceOf<ResolutionFailedException>());
}
public void CanRegisterTypeAsSingleton()
{
var container = new InjectContainer();
container.Register<IInterface1, Class1>();
var instance1 = container.Resolve<IInterface1>();
var instance2 = container.Resolve<IInterface1>();
Assert.AreSame(instance1, instance2);
}
public void RegisterInstanceWithNullInstanceThrows()
{
var container = new InjectContainer();
Assert.That(() => container.Register<object>(null), Throws.ArgumentNullException);
}
public void ResolvesConstructorParameters()
{
var container = new InjectContainer();
container.Register<IInterfaceWithProperty, Class1WithProperty>();
container.Register<IInterface2, Class2>();
var instance = container.Resolve<IInterfaceWithProperty>();
Assert.IsNotNull(instance);
Assert.IsNotNull(instance.Arg);
}
public void CreatingNoPublicConstructorClassThrows()
{
var container = new InjectContainer();
Assert.That(() => container.Resolve<NoConstructorClass>(), Throws.InstanceOf<ResolutionFailedException>());
}
public void RegisteredTypeDoesntInheritThrows()
{
var container = new InjectContainer();
Assert.That(() => container.Register(typeof(IInterface1), typeof(Class2)), Throws.ArgumentException);
}
public void RegisterInstanceNullThrows()
{
var container = new InjectContainer();
Assert.That(() => container.Register(null, new object()), Throws.ArgumentNullException);
}
public void CanResolveConcreteClassWithoutRegistering()
{
var container = new InjectContainer();
var instance = container.Resolve<Class1>();
Assert.IsNotNull(instance);
}
public void ResolvesInstanceAsSingleton()
{
var container = new InjectContainer();
var instance = new Class1();
container.Register<IInterface1>(instance);
var instance1 = container.Resolve<IInterface1>();
var instance2 = container.Resolve<IInterface1>();
Assert.AreSame(instance, instance1);
Assert.AreSame(instance, instance2);
}
public void RegisterTypeWithNullTypeThrows()
{
var container = new InjectContainer();
Assert.That(() => container.Register(typeof(object), null), Throws.ArgumentNullException);
}
public void RegisterSameTypeThrows()
{
var container = new InjectContainer();
container.Register<IInterface1, Class1>();
Assert.That(() => container.Register<IInterface1, Class1>(), Throws.ArgumentException);
}
