public void VerifySignatureTestSetup()
{
file = new Mock <FileWrapper>();
file.Setup(f => f.ReadAllBytes(It.IsAny <string>()))
.Returns <string>(givenFile => files[givenFile]);
console = new Mock <ConsoleWrapper>();
Container container = ContainerProvider.GetContainer();
container.Register <FileWrapper>(() => file.Object);
container.Register <ConsoleWrapper>(() => console.Object);
var asymmetricKeyPairGenerator = new AsymmetricKeyPairGenerator(new SecureRandomGenerator());
var primeMapper = new Rfc3526PrimeMapper();
var curveNameMapper = new FieldToCurveNameMapper();
rsaKeyProvider = new RsaKeyProvider(asymmetricKeyPairGenerator);
dsaKeyProvider = new DsaKeyProvider(asymmetricKeyPairGenerator);
ecKeyProvider = new EcKeyProvider(asymmetricKeyPairGenerator, curveNameMapper);
elGamalKeyProvider = new ElGamalKeyProvider(asymmetricKeyPairGenerator, primeMapper);
signatureProvider = new SignatureProvider(new SignatureAlgorithmIdentifierMapper(), new SecureRandomGenerator(), new SignerUtilitiesWrapper());
pkcs8PemFormatter = new Pkcs8PemFormattingProvider(new AsymmetricKeyProvider(new OidToCipherTypeMapper(), new KeyInfoWrapper(), rsaKeyProvider, dsaKeyProvider, ecKeyProvider, elGamalKeyProvider));
base64 = new Base64Wrapper();
encoding = new EncodingWrapper();
random = new SecureRandomGenerator();
}
private void btnStart_Click(object sender, EventArgs e)
{
if (this.btnStart.Text == "START")
{
var container = new SimpleInjector.Container();
container.Register <IChatServices, ChatServices>();
container.Register <IMessagesServices, MessagesServices>();
container.Register <IUsersByChatServices, UsersByChatServices>();
container.Register <IUsersServices, UsersServices>();
container.RegisterSingleton <PresenceContext>();
container.Verify();
//PresenceServiceInitializer.configure(container);
this.btnStart.Text = "STOP";
}
else
{
//PresenceServiceInitializer.getInstance().Stop();
this.btnStart.Text = "START";
}
}
public PersistenceAdapter(PersistenceAdapterSettings settings)
{
_container = new Container();
_container.Register <CosmosClient>(() =>
new CosmosClient(settings.AccountEndpoint, settings.AccountKey));
_container.Register <ICourseLoader, CourseLoaderCosmosDb>();
}
public static void RegisterTypes(SimpleInjector.Container container, string database)
{
container.Register <DialogEngine>();
container.RegisterInstance <IServiceProvider>(container);
container.RegisterSingleton <IApiAiAppServiceFactory, ApiAiAppServiceFactory>();
container.RegisterSingleton <IHttpClientFactory, HttpClientFactory>();
container.RegisterSingleton <ISolicitud, SolicitudManager>();
container.RegisterSingleton <IIntencion, IntencionManager>();
container.RegisterSingleton <ISesion, SesionManager>();
container.RegisterSingleton <IChatLog, ChatLogManager>();
container.RegisterSingleton <ICurso, CursoManager>();
container.RegisterSingleton <IActividad, ActividadManager>();
if (database.Equals("ORACLE"))
{
container.Register <ISesionData, Upecito.Data.Oracle.Implementacion.SesionData>();
container.Register <ISolicitudData, Upecito.Data.Oracle.Implementacion.SolicitudData>();
container.Register <IIntencionData, Upecito.Data.Oracle.Implementacion.IntencionData>();
}
if (database.Equals("MSSQLSERVER"))
{
container.Register <ISesionData, Upecito.Data.MSSQLSERVER.Implementacion.SesionData>();
container.Register <ISolicitudData, Upecito.Data.MSSQLSERVER.Implementacion.SolicitudData>();
container.Register <IIntencionData, Upecito.Data.MSSQLSERVER.Implementacion.IntencionData>();
container.Register <IChatLogData, Upecito.Data.MSSQLSERVER.Implementacion.ChatLogData>();
container.Register <ICursoData, Upecito.Data.MSSQLSERVER.Implementacion.CursoData>();
container.Register <IActividadData, Upecito.Data.MSSQLSERVER.Implementacion.ActividadData>();
}
}
internal static void InsertIn(SimpleInjector.Container c)
{
c.Register <SheetEntryRepository>();
c.Register <CategoryRepository>();
c.Register <SheetRepository>();
c.Register <AppOwnerRepository>();
}
public ShowStorageAdapter(ShowStorageAdapterSettings settings)
{
_container = new SimpleInjectorContainer();
_container.Register <CosmosClient>(() =>
new CosmosClient(settings.AccountEndpoint, settings.AccountKey));
_container.Register <IShowStore, ShowStoreCosmosDb>();
}
public MainWindow()
{
var container = new Container();
container.Register <IConfigService, ConfigService>();
container.Register <IScreenColorService, ScreenColorService>();
container.Register <IMonitorService, MonitorService>();
container.Verify();
_configService = container.GetInstance <IConfigService>();
_temperatureService = container.GetInstance <IScreenColorService>();
_monitorService = container.GetInstance <IMonitorService>();
Monitors = new ObservableCollection <Monitor>(_monitorService.GetMonitors());
SelectedMonitor = Monitors.FirstOrDefault();
bool exists = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location)).Length > 1;
if (exists) //If this program already has an instance
{
try
{
NamedPipeClientStream pipeStream = new NamedPipeClientStream(".", "instance", PipeDirection.Out, PipeOptions.None);
pipeStream.Connect();
Environment.Exit(0);
}
catch (TimeoutException oEx)
{
Debug.WriteLine(oEx.Message);
}
}
else //If the program is not already running
{
_pipeServer = new NamedPipeServerStream("instance", PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
_pipeServer.BeginWaitForConnection(WaitForConnectionCallBack, _pipeServer);
}
AssignKeyToConfigCommand = new RelayCommand(AssignKeyToConfig);
SaveConfigCommand = new RelayCommand(SaveConfig);
DeleteConfigCommand = new RelayCommand(DeleteConfig);
MoveConfigUpCommand = new RelayCommand(MoveConfigUp);
MoveConfigDownCommand = new RelayCommand(MoveConfigDown);
RefreshMonitorsCommand = new RelayCommand(RefreshMonitors);
_notifyIcon.Icon = Properties.Resources.icon;
_notifyIcon.Click += NotifyIconOnClick;
_notifyIcon.Visible = true;
SystemEvents.SessionSwitch += SystemEventsOnSessionSwitch;
SystemEvents.UserPreferenceChanging += SystemEvents_UserPreferenceChanging;
SystemEvents.PaletteChanged += SystemEvents_PaletteChanged;
SystemEvents.DisplaySettingsChanged += SystemEvents_DisplaySettingsChanged;
InitializeComponent();
}
public static void RegisterServices(SimpleInjector.Container container)
{
//Repo
container.Register <INewsRepository, NewsRepository>();
container.Register <ISearchResultRepository, SearchResultRepository>();
//Services
container.Register <INewsService, NewsService>();
}
internal static IDependencyContainer GetSimpleInjectorDependencyResolver()
{
var container = new Container();
container.Register <ILogger, ConsoleLogger>();
container.Register <ExamplePublisher>();
return(new SimpleInjectorDependencyResolver(container));
}
public static void RegisterServices(SimpleInjector.Container container, SimpleInjector.Lifestyle lifestyle)
{
// registrando os container
//app
container.Register <Imposto.Application.Interfaces.INotaFiscalAppAction, Imposto.Application.AppActions.NotaFiscalAppAction>(lifestyle);
//data
container.Register <Imposto.Core.Interfaces.Repositorios.INotaFiscal, Imposto.Data.Repositorio.NotaFiscalRepositorio>(lifestyle);
}
public static void RegisterDALEntityFramework6(SimpleInjector.Container container, string connectionString)
{
// register repositories
container.Register(typeof(ICompanyRepository), typeof(DAL.EntityFramework6.Repositories.CompanyRepository), SimpleInjector.Lifestyle.Scoped);
container.Register(typeof(IStoreRepository), typeof(DAL.EntityFramework6.Repositories.StoreRepository), SimpleInjector.Lifestyle.Scoped);
// register infrastructure
container.Register(typeof(DAL.EntityFramework6.Infrastructure.CompanyStoresContext), () => new DAL.EntityFramework6.Infrastructure.CompanyStoresContext(connectionString), SimpleInjector.Lifestyle.Scoped);
container.Register(typeof(IUnitOfWork), typeof(DAL.EntityFramework6.Infrastructure.UnitOfWork), SimpleInjector.Lifestyle.Scoped);
}
public override void Register(SimpleInjector.Container container)
{
new AssembliesItix()
.GetAssemblies()
.ForEach(assembly =>
{
container.Register(typeof(CommandHandler <>), new[] { assembly });
container.Register(typeof(QueryHandler <>), new[] { assembly });
});
}
public static void Bootstrap(HttpConfiguration config)
{
var container = new SimpleInjector.Container();
container.Register<IReportRepository<SummaryReport>>( ()=> new ReportRepository<SummaryReport>(), SimpleInjector.Lifestyle.Transient);
container.Register<ISummaryReport>(() => new SummaryReport(container.GetInstance<IReportRepository<SummaryReport>>()), SimpleInjector.Lifestyle.Transient);
container.RegisterDecorator(typeof(ISummaryReport), typeof(SummaryLogDecorator));
container.Verify();
config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
}
static void StartSyslogServer()
{
#region SimpleInjector
var container = new SimpleInjector.Container();
container.Register <IMessageParser, MessageParser>();
container.Register <IMessageStorage>(() => new MemoryStorage(10000));
container.Verify();
#endregion
UDPListener listener = new UDPListener(8888);
listener.StartListener(container.GetInstance <IMessageStorage>(), container.GetInstance <IMessageParser>());
}
protected void Application_Start()
{
var container = new SimpleInjector.Container();
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
container.Register <IEFUnitOfWork, EFUnitOfWork>();
container.Register <IDapperUnitOfWork, DapperUnitOfWork>();//editamos
GlobalConfiguration.Configure(WebApiConfig.Register);
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize;
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.None;
GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);
GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
}
public static IQueryProcessor Create(TypiconDBContext dbContext)
{
var container = new SimpleInjector.Container();
container.Register <ITypiconSerializer, TypiconSerializer>();
container.RegisterSingleton <IJobRepository>(() => new JobRepository());
container.Register(typeof(IQueryHandler <,>), typeof(QueryProcessor).Assembly, typeof(TypiconEntityModel).Assembly);
container.Register <IQueryProcessor, QueryProcessor>();
container.RegisterInstance(dbContext);
var processor = container.GetInstance <IQueryProcessor>();
return(processor);
}
public void Main(string[] args)
{
GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency;
var simpleInjectorContainer = new SimpleInjector.Container();
var autofacBuilder = new ContainerBuilder();
foreach (var type in typeof(Greeter).Assembly.GetTypes())
{
autofacBuilder.RegisterType(type);
simpleInjectorContainer.Register(type);
}
simpleInjectorContainer.Verify();
var container = autofacBuilder.Build();
Console.WriteLine("Starting sample performance test");
TimeIt(() => ClassWithDeps.InlinedConstructor(), "Inlined .NET (base line)");
TimeIt(() => ClassWithDeps.Factory(), "Compile Injector (this library)");
TimeIt(() => container.Resolve<ClassWithDeps>(), "Autofac");
TimeIt(() => simpleInjectorContainer.GetInstance<ClassWithDeps>(), "SimpleInjector");
Console.WriteLine("Done");
}
static void Main(string[] args)
{
var busConfiguration = new EndpointConfiguration("test");
var container = new SimpleInjector.Container();
container.Options.DefaultScopedLifestyle = new ExecutionContextScopeLifestyle();
container.Register(() => new MyService {
Id = "Created outside"
}, SimpleInjector.Lifestyle.Scoped);
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.UseContainer <SimpleInjectorBuilder>(customizations: cust =>
{
// which has a higher version than referenced assembly
// Assembly 'NServiceBus.SimpleInjector' uses 'SimpleInjector, Version=3.2.7.0, Culture=neutral, PublicKeyToken=984cb50dea722e99' which has a higher version than referenced assembly 'SimpleInjector' with identity 'SimpleInjector, Version=3.2.3.0, Culture=neutral, PublicKeyToken=984cb50dea722e99'
cust.UseExistingContainer(container);
});
var bus = Endpoint.Create(busConfiguration).Result.Start().Result;
{
bus.SendLocal(new CreateOrder {
});
}
Console.ReadLine();
}
/// <summary>Extension method for SimpleInjector to enable Fluent API. Used in place of the
/// <see cref="SimpleInjector.Container.Register{TService, TImplementation}"/> method.</summary>
/// <param name="container"></param>
/// <param name="lifestyle"></param>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TImplementation"></typeparam>
/// <returns></returns>
public static SimpleInjector.Container RegisterType <TSource, TImplementation>(this SimpleInjector.Container container, SimpleInjector.Lifestyle lifestyle)
where TSource : class
where TImplementation : class, TSource
{
container.Register <TSource, TImplementation>(lifestyle);
return(container);
}
public void SimpleInjector()
{
var container = new SimpleInjector.Container();
foreach (var type in _types)
{
container.Register(type, type);
}
int length = 0;
if (Scenario == ResolveScenario.ResolveOne)
{
length = 1;
}
else if (Scenario == ResolveScenario.ResolveHalf)
{
length = _types.Length / 2;
}
else if (Scenario == ResolveScenario.ResolveAll)
{
length = _types.Length;
}
for (var i = 0; i < length; i++)
{
container.GetInstance(_types[i]);
}
container.Dispose();
}
public void Init()
{
_container.Register <IFileHelper, FileHelper>();
new DataRegister().Register(_container);
new BusinessRegister().Register(_container);
_container.Verify();
}
/// <summary>
/// Registers the set of services in the specified <paramref name="container" />.
/// </summary>
/// <param name="container">The container the set of services is registered into.</param>
public void RegisterServices(Container container)
{
container.Register <IThemeType, ThemeType>();
container.Register <IGameType, GameType>();
container.RegisterSingleton <IDatabase, Database>();
container.InterceptWith <PropertyChangedInterceptor <IDatabase> >(x => x == typeof(IDatabase), true);
var tracker = new Jot.Tracker(new JsonStore());
tracker.Configure <Database>().PersistOn(PropChanged);
container.RegisterInitializer(d =>
{
tracker.Track(d.Instance);
}, ctx => ctx.Registration.ImplementationType == typeof(Database));
container.Register <IStorageProvider, Storage>();
}
public ViewModelLocator()
{
_container = new Container();
_container.Register <IDataService, DataService>();
_container.Register <MainViewModelMock>();
//bool designTime = DesignerProperties.GetIsInDesignMode(new DependencyObject());
//if (designTime)
//{
// _container.Register<MainViewModelMock>();
//}
//else
//{
// _container.Register<MainViewModel>();
//}
}
static int Main(string[] args)
{
var container = new SimpleInjector.Container();
container.Register <AppDbContext>();
container.Register <IRepository, EfRepository>();
container.Register <PersonsCli>();
return(new AppRunner <PersonsCli>()
.UseErrorHandler((ctx, ex) =>
{
ctx.Console.Error.WriteLine(ex.Message);
return 1;
}) // catches all exceptions and displays their message
.UseSimpleInjector(container)
.UseTypoSuggestions()
.Run(args));
}
public Provisioning_VSToolsPackage()
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering constructor for: {0}", this.ToString()));
try
{
//init IoC
Container = IoCBootstrapper.GetContainer(false);
Container.Register <Services.ILogService, Services.ProjectLogService>(SimpleInjector.Lifestyle.Singleton);
Container.Register <Services.IProjectService, Services.ProjectService>(SimpleInjector.Lifestyle.Transient);
Container.Verify();
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError("Provisioning_VSToolsPackage failed: " + ex.Message);
}
}
static void Main(string[] args)
{
var container = new SimpleInjector.Container();
container.Register <IOrder, PurchaseOrder>();
var shoppinCart = container.GetInstance <ShoppingCart>();
shoppinCart.CheckOut();
}
static SimpleInjector.Container ConfigureIoC()
{
var container = new SimpleInjector.Container();
container.Options.AllowOverridingRegistrations = true;
Logger.Msg("IoC container created.");
container.RegisterSingle <ILogger>(Logger);
container.Register <IBuilder, Builder>();
container.Register <IFileSystem, WindowsFileSystem>();
container.Register <ICountingFileSystem, CountingFileSystem>();
container.Register <IFileFilter, FileFilter>();
container.RegisterSingle <Settings>(Settings);
Logger.Msg("Default Lithogen types registered.");
string[] plugins = Directory.GetFiles(Settings.PluginsDirectory, "*.dll", SearchOption.TopDirectoryOnly);
if (plugins.Length > 0)
{
foreach (string plugin in plugins)
{
Logger.Msg("Registering plugins from " + plugin);
var pluginTypes = from type in Assembly.LoadFile(plugin).GetExportedTypes()
where !type.IsAbstract && !type.IsGenericTypeDefinition
select type;
foreach (Type pluginType in pluginTypes)
{
foreach (Type t in OverridableTypes)
{
if (t.IsAssignableFrom(pluginType))
{
container.Register(t, pluginType);
Logger.Msg("Registered type {0} against interface {1}.", pluginType.FullName, t.Name);
}
}
}
}
Logger.Msg("All plugin types registered.");
}
container.Verify();
Logger.Msg("IoC container verified.");
return(container);
}
public void TestDepartmentCreateErrorView()
{
var container = new SimpleInjector.Container();
container.Register <IHotelRepository, HotelRepository>();
container.RegisterDecorator(typeof(IHotelRepository), typeof(DefaultController));
var hotelService = container.GetInstance <IHotelRepository>();
var hotelList = hotelService.fetchHotels();
}
private static void Bootstrap()
{
_container = new SimpleInjector.Container();
Core.Configuracao.Dependencias.Resolve(new Container(_container));
_container.Register <Form>();
_container.GetRegistration(typeof(Form)).Registration.SuppressDiagnosticWarning(
SimpleInjector.Diagnostics.DiagnosticType.DisposableTransientComponent, "Relaxa, eu cuido desse!");
_container.Verify();
}
public void Preview()
{
RunEtlStepResults.Clear();
var types = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes()).EtlSteps().ToList();
var container = new SimpleInjector.Container();
types.ForEach(x => container.Register(x));
var pipeline = EtlProcessFactory.CreateEtlPipeline(container, this.EtlSteps.ToList());
PipelineExecutor.RunPipeline(pipeline, context => { }, context => { RunEtlStepResults.Add(context); });
}
private static void Startup()
{
//http://simpleinjector.readthedocs.io/en/latest/using.html
//The goal of Simple Injector is to provide .NET application developers with an easy, flexible, and fast Inversion of Control library that promotes best practice to steer developers towards the pit of success.
// Create the container as usual.Creating and configuring a Container is done by newing up an instance and calling the Register overloads to register each of your services:
//http://simpleinjector.readthedocs.io/en/latest/windowsformsintegration.html
container = new SimpleInjector.Container();
// Register your types, for instance:
container.Register <IStudents, Students>();
container.Register <ICourses, Courses>();
container.Register <IMarksData, MarksData>();
container.Register <Form1>();
// Registering a list of instances that will be created by the container.
// Supplying a collection of types is the preferred way of registering collections.
// container.RegisterCollection<IDiceRolls>(new[] { typeof(DiceRolls), typeof(DiceRoll3) });
// Optionally verify the container.
// container.Verify();
}
public static IServiceCollection AddBusinessLogic(this IServiceCollection services,
SimpleInjector.Container container)
{
var typesToRegister =
container.GetTypesToRegister(typeof(IHandler <,>), typeof(DependencyInjection).Assembly);
foreach (var type in typesToRegister)
{
container.Register(type);
}
return(services);
}
private static void OnStartup(string[] args)
{
// TODO free console for UI execution
// Bootstrap container
container = new SimpleInjector.Container();
container.RegisterSingleton<IPlatformFacade, WindowsPlatform>();
container.RegisterSingleton<IWindowManagerService, WindowManagerService>();
container.RegisterSingleton<IKeyMapService, KeyMapService>();
container.RegisterSingleton<INotificationService, NotificationService>();
container.RegisterSingleton<IMainWindow, MainWindow>();
// Register default command set
var commands =
AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(s => s.GetTypes())
.Where(p => p != typeof(ICommand) && typeof(ICommand).IsAssignableFrom(p))
.ToList();
container.RegisterCollection<ICommand>(commands);
container.Register(
typeof(ICommandHandler<>),
container.GetTypesToRegister(typeof(ICommandHandler<>), new[] { Assembly.GetExecutingAssembly() })
.Where(t => t.IsPublic));
// Register handlers
var commandHandlers =
commands.Select(command => container.GetInstance(typeof(ICommandHandler<>).MakeGenericType(command)));
container.RegisterSingleton<ICommandService>(
() => new CommandService(container.GetAllInstances<ICommand>(), commandHandlers));
container.Verify();
mainForm = container.GetInstance<IMainWindow>() as Form;
// Parse arguments and run the app
var getopt = new GetOpt(Options);
char returnChar = ' ';
int optionIndex = 0;
string optionArg = null;
bool startWindowManager = true;
try
{
do
{
// parse the args
switch (returnChar)
{
case 'h':
Console.Write(getopt.Description);
return;
case 'v':
Console.WriteLine(Application.ProductVersion);
return;
case 'f': // parse alternate rc file
configFile = optionArg;
break;
case 'c': // send a command
startWindowManager = false;
break;
case 'r': // reset all windows to decorated regular state, in case things screw up :(
startWindowManager = false;
WindowManagerService.Reset();
break;
}
returnChar = getopt.Parse(args, ref optionIndex, out optionArg);
}
while (returnChar != ' ');
}
catch (GetOpt.InvalidOptionException e)
{
Console.WriteLine(Properties.Resources.Option_Help_Error);
Console.WriteLine(e);
return;
}
if (startWindowManager)
{
// Start the services
((ServiceBase)container.GetInstance<IKeyMapService>()).Start();
((ServiceBase)container.GetInstance<IWindowManagerService>()).Start();
((ServiceBase)container.GetInstance<INotificationService>()).Start();
// set the internal variables
// set the data structures
// read rc file
////CommandManager.Execute((int)CommandManager.OtherCommands.source, new string[] { _configFile });
var keyMapService = container.GetInstance<IKeyMapService>();
// Top keymap does not require the window on focus, they are global hot keys
// Prefix key must reside here
keyMapService.AddKeyMap("top");
keyMapService.SetTopKey("top", Keys.Control | Keys.B);
// Root keymap is the default keymap invoked via Prefix key with readkey command
// All other default shortcuts reside here
keyMapService.AddKeyMap("root");
var commandService = container.GetInstance<ICommandService>();
commandService.Run("definekey top T readkey root");
// Set default variables
// commandService.Run()
////keyMapService.SetTopKey("root", Keys.Control | Keys.T);
Application.Run(mainForm);
}
else
{
// check if an instance already runs
// send the commands
// throw output to console or to the bar
}
}
