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";
}
}
static void Main(string[] args)
{
string serviceName = typeof(Program).Assembly.GetName().Name;
Console.Title = serviceName;
Console.WriteLine($"{serviceName} running...");
#region Register Dependencies
var container = new SimpleInjector.Container();
container.RegisterServices();
container.Verify();
#endregion
var consumer = container.GetInstance <IConsumer <BariguiEvent> >();
var responseConsumer = container.GetInstance <IConsumer <BariguiEventResponse> >();
var bus = container.GetInstance <IEventBus>();
consumer.Consume();
responseConsumer.Consume();
Task.Run(() =>
{
while (true)
{
bus.Publish(new BariguiEvent("Hello World!", serviceName)).Wait();
Thread.Sleep(5000);
}
});
Console.WriteLine("Listening for messages. Hit <return> to quit.");
Console.ReadLine();
}
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");
}
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 void Init()
{
_container.Register <IFileHelper, FileHelper>();
new DataRegister().Register(_container);
new BusinessRegister().Register(_container);
_container.Verify();
}
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>());
}
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);
}
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 static BaseJobExecutorShell CreateAndStartEngine2()
{
var container = new SimpleInjector.Container();
container.Register <IService2Contract, CounterWriter>();
container.Verify();
var engine = new GlutenFree.OddJob.Execution.Akka.HardInjectedJobExecutorShell <JobQueueLayerActor, JobWorkerActor, JobQueueCoordinator>(
() => new JobQueueLayerActor(new SQLiteJobQueueManager(SQLiteSampleHelper.ConnFactoryFunc(),
GenerateMappings.TableConfigurations["counter"], new NullOnMissingTypeJobTypeResolver())),
() => new JobWorkerActor(new DefaultJobExecutor(new SimpleInjectorContainerFactory(container))),
() => new JobQueueCoordinator(), new StandardConsoleEngineLoggerConfig("DEBUG"));
engine.StartJobQueue("counter", 20, 3);
return(engine);
}
static void Main(string[] args)
{
#region Register Dependencies
var container = new SimpleInjector.Container();
container.RegisterServices();
container.Verify();
#endregion
var consumer = container.GetInstance <IConsumer>();
consumer.ConsumeMessages();
Console.WriteLine("Sair...");
Console.ReadLine();
}
public static SimpleInjector.Container RegisterServices()
{
var container = new SimpleInjector.Container();
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
container.Register <IDatabaseService, DatabaseService>(SimpleInjector.Lifestyle.Scoped);
container.Register <IGetMoviesListQuery, GetMoviesListQuery>(SimpleInjector.Lifestyle.Scoped);
container.Register <IGetMovieQuery, GetMovieQuery>(SimpleInjector.Lifestyle.Scoped);
container.Register <IAddMovieCommand, AddMovieCommand>(SimpleInjector.Lifestyle.Scoped);
container.Register <IChangeMovieCommand, ChangeMovieCommand>(SimpleInjector.Lifestyle.Scoped);
container.Register <IRemoveMovieCommand, RemoveMovieCommand>(SimpleInjector.Lifestyle.Scoped);
container.Verify();
return(container);
}
// This code configures Web API. The Startup class is specified as a type
// parameter in the WebApp.Start method.
public void Configuration(IAppBuilder appBuilder)
{
//System.Threading.Thread.Sleep(70000);//.
string connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["Fingrid.Messaging"].ConnectionString;
Container = new SimpleInjector.Container();
//Container.Options.DefaultScopedLifestyle = new ExecutionContextScopeLifestyle();
Container.Options.DefaultScopedLifestyle = new SimpleInjector.Lifestyles.AsyncScopedLifestyle();
Container.RegisterAllDependencies(connectionString);
Container.Verify();
try
{
//GlobalConfiguration.Configuration.DependencyResolver =
// new SimpleInjector.Integration.WebApi.SimpleInjectorWebApiDependencyResolver(Container);
//Fingrid.Infrastructure.Common.Logging.ILogger logger = Container.GetInstance<Fingrid.Infrastructure.Common.Logging.ILogger>();
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration()
{
DependencyResolver = new SimpleInjector.Integration.WebApi.SimpleInjectorWebApiDependencyResolver(Container)
};
//config.EnableCors();
// Enable attribute based routing
// http://www.asp.net/web-api/overview/web-api-routing-and-actions/attribute-routing-in-web-api-2
config.MapHttpAttributeRoutes();
//config.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional }
//);
appBuilder.UseWebApi(config);
}
catch (Exception)
{
//logger.LogError(ex);
throw;
}
}
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);
}
}
public static void Main(string[] args)
{
string serviceName = typeof(Program).Assembly.GetName().Name;
#region Register Dependencies
var container = new SimpleInjector.Container();
container.RegisterServices();
container.Verify();
#endregion
var consumer = container.GetInstance <IConsumer>();
consumer.Connect();
consumer.SendMessages(serviceName, "Hello World");
consumer.Disconnect();
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
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);
}
static void Main(string[] args)
{
// Configuración inicial del Injector de Dependencias.
try
{
Container = new SimpleInjector.Container();
var configIOC = new ConfiguracionIOC();
configIOC.Configurar(Container);
Container.Verify();
}
catch (Exception ex)
{
Console.WriteLine(string.Format("Ocurrio un error al verificar las dependencias.\n" +
"Revise la configuración, recompile y vuelva a ejecutar la aplicación.\n" +
"Detalle del error: {0}", ex));
throw;
}
Container.GetInstance <ClienteGenerador>().Iniciar();
}
private static SimpleInjector.Container InitCore(IEnumerable<Action<SimpleInjector.Container>> additionalRegistrations = null)
{
SimpleInjector.Container container = new SimpleInjector.Container();
InitCrossCutting(container);
InitDAL(container);
if (additionalRegistrations != null)
{
container.Options.AllowOverridingRegistrations = true;
foreach (var additionalRegistration in additionalRegistrations)
{
additionalRegistration(container);
}
}
container.Verify();
return container;
}
private static SimpleInjector.Container InitCore(IEnumerable <Action <SimpleInjector.Container> > additionalRegistrations = null)
{
SimpleInjector.Container container = new SimpleInjector.Container();
InitCrossCutting(container);
InitDAL(container);
if (additionalRegistrations != null)
{
container.Options.AllowOverridingRegistrations = true;
foreach (var additionalRegistration in additionalRegistrations)
{
additionalRegistration(container);
}
}
container.Verify();
return(container);
}
static void Main(string[] args)
{
string serviceName = typeof(Program).Assembly.GetName().Name;
Console.Title = serviceName;
Console.WriteLine($"{serviceName} running...");
#region Register Dependencies
var container = new SimpleInjector.Container();
container.RegisterServices();
container.Verify();
#endregion
var consumer = container.GetInstance <IConsumer <BariguiEvent> >();
consumer.Consume();
Console.WriteLine("Listening for messages. Hit <return> to quit.");
Console.ReadLine();
}
static Program()
{
var storageEnv = Environment.ExpandEnvironmentVariables($"%{StorageEnv}%");
var globalContext = new GlobalContext
{
StoragePath = storageEnv,
SymlinkPath = Path.Combine(storageEnv, "current"),
Is64Bit = Environment.Is64BitOperatingSystem
};
globalContext.ActiveVersionTrackerFilePath = Path.Combine(globalContext.StoragePath, "last-used");
Container = new Container();
Container.RegisterInstance(globalContext);
Container.RegisterSingleton <NodeJsWebApi>();
Container.RegisterSingleton <NodeJs>();
Container.RegisterSingleton <AvailCommand>();
Container.RegisterSingleton <ListCommand>();
Container.RegisterSingleton <InstallCommand>();
Container.RegisterSingleton <UninstallCommand>();
Container.RegisterSingleton <UseCommand>();
Container.Verify();
}
private App()
{
if (!Debugger.IsAttached)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
}
_mutex = new Mutex(false, $"h3x4d3c1m4l BrightLight - {Environment.UserName}", out bool createdNew);
if (!createdNew)
{
// app already running
MessageBox.Show("BrightLight is already running!", "BrightLight - Already running", MessageBoxButton.OK, MessageBoxImage.Information);
Environment.Exit(0);
}
InitializeComponent();
AppBuilder.Configure <AvaloniaApp>().UseWin32().UseDirect2D1().SetupWithoutStarting();
var test = new SearchWindow(new MainViewModel(new RunUsingWpfDispatcherHelper(Dispatcher)));
Container = new Container();
Container.RegisterInstance(Dispatcher);
Container.RegisterSingleton <IRunOnUiThreadHelper, RunUsingWpfDispatcherHelper>();
Container.RegisterSingleton <MainViewModel>();
Container.RegisterSingleton <SettingsViewModel>();
Container.RegisterSingleton <SearchWindow>();
Container.RegisterSingleton <SettingsWindow>();
Container.RegisterSingleton <TaskbarIcon>();
Container.RegisterSingleton(() => Settings.LoadOrDefault());
Container.Verify();
_showHotKey = new HotKey(Key.Space, KeyModifier.Ctrl | KeyModifier.Shift, key =>
{
Container.GetInstance <MainViewModel>().Reset();
Container.GetInstance <SearchWindow>().Show();
});
}
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
}
}
static Program()
{
container.RegisterSingleton <IAppConfig, AppConfig>();
container.RegisterSingleton <ILog, Log>();
container.Verify();
}
