public static MethodDefinition Execute(PropertyDefinition property_definition, MethodDefinition notify_method, DependencyMap map) { log.Trace("\t\t\t\t\tAdding collection notification method for " + property_definition.Name); // Create method TypeReference return_type = property_definition.Module.Import(typeof (void)); MethodDefinition collection_notification = new MethodDefinition(property_definition.Name + "CollectionNotification", Mono.Cecil.MethodAttributes.Private | Mono.Cecil.MethodAttributes.HideBySig, return_type); // Add parameters TypeReference sender_type = property_definition.Module.Import(typeof(object)); TypeReference args_type = property_definition.Module.Import(typeof(NotifyCollectionChangedEventArgs)); ParameterDefinition sender = new ParameterDefinition("sender", Mono.Cecil.ParameterAttributes.None, sender_type); ParameterDefinition args = new ParameterDefinition("args", Mono.Cecil.ParameterAttributes.None, args_type); collection_notification.Parameters.Add(sender); collection_notification.Parameters.Add(args); // Add notifications for dependent properties ILProcessor processor = collection_notification.Body.GetILProcessor(); foreach (var target in map.GetDependenciesFor(property_definition.Name)) { log.Trace("\t\t\t\t\t\tAdding dependency " + target); processor.Emit(OpCodes.Ldarg_0); processor.Emit(OpCodes.Ldstr, target); processor.Emit(OpCodes.Call, notify_method); } processor.Emit(OpCodes.Ret); // Add method to class property_definition.DeclaringType.Methods.Add(collection_notification); return collection_notification; }
public void ShouldBeAbleToCreateSingletonsThatDependOnOtherSingletons() { var map = new DependencyMap(); map.AddSingletonService(typeof(IVehicle), typeof(Vehicle)); map.AddSingletonService(typeof(IPerson), typeof(Person)); var compiler = map.ContainerCompiler; var outputAssembly = compiler.Compile("MicroContainer", "Hiro.Containers", "Hiro.CompiledContainers", map); outputAssembly.Write("singletonOutputAssembly.dll"); var container = map.CreateContainer(); var vehicle = container.GetInstance<IVehicle>(); Assert.IsNotNull(vehicle); var person = container.GetInstance<IPerson>(); Assert.IsNotNull(person); for (var i = 0; i < 1000; i++) { var currentInstance = container.GetInstance<IVehicle>(); Assert.AreSame(vehicle, currentInstance); var driver = currentInstance.Driver; Assert.AreSame(driver, person); } }
public void Load(DependencyMap map) { _invoked = true; // Add a sample implementation map.AddService<IList<int>, List<int>>(); }
public static void Execute(PropertyDefinition property_definition, MethodDefinition notify_method, DependencyMap map) { // Check if notifications are already call, if so bail out foreach (var instruction in property_definition.SetMethod.Body.Instructions) { if (instruction.OpCode == OpCodes.Call) { var method = instruction.Operand as MethodDefinition; if (method != null && method == notify_method) { log.Trace("\t\t\t\t\tBailing out, notification found in property"); return; } } } // Add notifications var ret = property_definition.SetMethod.Body.Instructions.Last(i => i.OpCode == OpCodes.Ret); ILProcessor processor = property_definition.SetMethod.Body.GetILProcessor(); // NotifyPropertyChanged(property) processor.InsertBefore(ret, processor.Create(OpCodes.Ldarg_0)); processor.InsertBefore(ret, processor.Create(OpCodes.Ldstr, property_definition.Name)); processor.InsertBefore(ret, processor.Create(OpCodes.Call, notify_method)); // Add notifications for dependent properties foreach (var target in map.GetDependenciesFor(property_definition.Name)) { log.Trace("\t\t\t\t\tAdding dependency " + target); processor.InsertBefore(ret, processor.Create(OpCodes.Ldarg_0)); processor.InsertBefore(ret, processor.Create(OpCodes.Ldstr, target)); processor.InsertBefore(ret, processor.Create(OpCodes.Call, notify_method)); } }
public async Task RunAsync(params string[] args) { _log = LogManager.GetCurrentClassLogger(); _log.Info("Starting NadekoBot v" + StatsService.BotVersion); //create client Client = new ShardedDiscordClient(new DiscordSocketConfig { AudioMode = Discord.Audio.AudioMode.Outgoing, MessageCacheSize = 10, LogLevel = LogSeverity.Warning, TotalShards = Credentials.TotalShards, ConnectionTimeout = int.MaxValue }); //initialize Services CommandService = new CommandService(); Localizer = new Localization(); Google = new GoogleApiService(); CommandHandler = new CommandHandler(Client, CommandService); Stats = new StatsService(Client, CommandHandler); //setup DI var depMap = new DependencyMap(); depMap.Add<ILocalization>(Localizer); depMap.Add<ShardedDiscordClient>(Client); depMap.Add<CommandService>(CommandService); depMap.Add<IGoogleApiService>(Google); //setup typereaders CommandService.AddTypeReader<PermissionAction>(new PermissionActionTypeReader()); CommandService.AddTypeReader<Command>(new CommandTypeReader()); CommandService.AddTypeReader<Module>(new ModuleTypeReader()); CommandService.AddTypeReader<IGuild>(new GuildTypeReader()); //connect await Client.LoginAsync(TokenType.Bot, Credentials.Token).ConfigureAwait(false); await Client.ConnectAsync().ConfigureAwait(false); await Client.DownloadAllUsersAsync().ConfigureAwait(false); _log.Info("Connected"); //load commands and prefixes using (var uow = DbHandler.UnitOfWork()) { ModulePrefixes = new ConcurrentDictionary<string, string>(uow.BotConfig.GetOrCreate().ModulePrefixes.ToDictionary(m => m.ModuleName, m => m.Prefix)); } // start handling messages received in commandhandler await CommandHandler.StartHandling().ConfigureAwait(false); await CommandService.LoadAssembly(this.GetType().GetTypeInfo().Assembly, depMap).ConfigureAwait(false); #if !GLOBAL_NADEKO await CommandService.Load(new Music(Localizer, CommandService, Client, Google)).ConfigureAwait(false); #endif Ready = true; Console.WriteLine(await Stats.Print().ConfigureAwait(false)); }
public void ShouldBeAbleToRegisterAnonymousServicesWithDependencyMapUsingGenerics() { var dependencyMap = new DependencyMap(); dependencyMap.AddService<IVehicle, Vehicle>(); Assert.IsTrue(dependencyMap.Contains(new Dependency(typeof(IVehicle)))); Assert.IsTrue(dependencyMap.Contains(typeof(IVehicle))); }
public void Circle() { DependencyMap<string> map = new DependencyMap<string>(); map.Add("A", "B"); map.Add("B", "C"); map.Add("C", "A"); map.SortDependencies(); }
public void ShouldBeAbleToInstantiateGenericTypes() { var map = new DependencyMap(); map.AddService(typeof(IList<>), typeof(List<>)); var container = map.CreateContainer(); var list = container.GetInstance<IList<int>>(); Assert.IsNotNull(list); }
public override void Prepare() { var map = new DependencyMap(); RegisterBasic(map); RegisterPropertyInjection(map); this.container = map.CreateContainer(); }
public void ShouldBeAbleToUseGenericsToGetAnonymousServiceInstances() { var map = new DependencyMap(); map.AddService(typeof(IPerson), typeof(Person)); var container = map.CreateContainer(); IPerson person = container.GetInstance<IPerson>(); Assert.IsNotNull(person); }
public override void Prepare() { var map = new DependencyMap(); RegisterDummies(map); RegisterStandard(map); RegisterComplex(map); this.container = map.CreateContainer(); }
public void ShouldBeAbleToAddItemsToDependencyMap() { var ctor = typeof(Vehicle).GetConstructor(new Type[0]); var dependency = new Dependency(typeof(IVehicle), string.Empty); var constructorImplementation = new ConstructorCall(ctor); var dependencyMap = new DependencyMap(); dependencyMap.AddService(dependency, constructorImplementation); Assert.IsTrue(dependencyMap.Contains(dependency)); }
private static void RegisterComplex(DependencyMap map) { map.AddSingletonService<IFirstService, FirstService>(); map.AddSingletonService<ISecondService, SecondService>(); map.AddSingletonService<IThirdService, ThirdService>(); map.AddService<ISubObjectOne, SubObjectOne>(); map.AddService<ISubObjectTwo, SubObjectTwo>(); map.AddService<ISubObjectThree, SubObjectThree>(); map.AddService<IComplex, Complex>(); }
public override void Prepare() { var map = new DependencyMap(); map.AddSingletonService<ISingleton, Singleton>(); map.AddService<ITransient, Transient>(); map.AddService<ICombined, Combined>(); this.container = map.CreateContainer(); }
public void WorstCase() { DependencyMap<string> map = new DependencyMap<string>(); map.Add("A", "B"); map.Add("B", "C"); map.Add("C", "D"); map.Add("D", "E"); map.Add("E", null); CheckSort("EDCBA", map); }
public void DegenerateCase() { DependencyMap<string> map = new DependencyMap<string>(); map.Add("A", null); map.Add("B", null); map.Add("C", null); map.Add("D", null); map.Add("E", null); CheckSort("ABCDE", map); }
public void ShouldBeAbleToGetCurrentListOfDependencies() { var map = new DependencyMap(); for (int i = 0; i < 10; i++) { var dependency = new Mock<IDependency>(); var implementation = new Mock<IImplementation>(); map.AddService(dependency.Object, implementation.Object); Assert.IsTrue(map.Dependencies.Contains(dependency.Object)); } }
private static void RegisterStandard(DependencyMap map) { map.AddSingletonService<ISingleton1, Singleton1>(); map.AddSingletonService<ISingleton2, Singleton2>(); map.AddSingletonService<ISingleton3, Singleton3>(); map.AddService<ITransient1, Transient1>(); map.AddService<ITransient2, Transient2>(); map.AddService<ITransient3, Transient3>(); map.AddService<ICombined1, Combined1>(); map.AddService<ICombined2, Combined2>(); map.AddService<ICombined3, Combined3>(); }
public void Typical() { DependencyMap<string> map = new DependencyMap<string>(); map.Add("A", "C"); // Forward reference map.Add("B", "E"); // Forward reference map.Add("D", null); // No dependency map.Add("C", "B"); // Backward reference map.Add("E", null); // No dependency map.Add("F", "G"); // Dependent on something outside map CheckSort("DEFBCA", map); }
private static void RegisterDummies(DependencyMap map) { map.AddService<IDummyOne, DummyOne>(); map.AddService<IDummyTwo, DummyTwo>(); map.AddService<IDummyThree, DummyThree>(); map.AddService<IDummyFour, DummyFour>(); map.AddService<IDummyFive, DummyFive>(); map.AddService<IDummySix, DummySix>(); map.AddService<IDummySeven, DummySeven>(); map.AddService<IDummyEight, DummyEight>(); map.AddService<IDummyNine, DummyNine>(); map.AddService<IDummyTen, DummyTen>(); }
public void ShouldBeAbleToCombineDependencyMaps() { var firstMap = new DependencyMap(); var secondMap = new DependencyMap(); firstMap.AddService(typeof(IPerson), typeof(Person)); secondMap.AddService(typeof(IVehicle), typeof(Vehicle)); DependencyMap combinedMap = firstMap + secondMap; var container = combinedMap.CreateContainer(); Assert.IsNotNull(container.GetInstance<IVehicle>()); Assert.IsNotNull(container.GetInstance<IPerson>()); }
public void ShouldBeAbleToAddTypedFunctorToDependencyMap() { var expectedInstance = new Foo(); Func<IMicroContainer, IFoo> functor = c => expectedInstance; var map = new DependencyMap(); map.AddService(functor); var container = map.CreateContainer(); var foo = container.GetInstance<IFoo>(); Assert.AreSame(expectedInstance, foo); }
public void ShouldBeAbleToAddExistingServiceInstanceToContainer() { var map = new DependencyMap(); var person = new Person(); // Create a blank container var container = map.CreateContainer(); container.AddService<IPerson>(null, person); // The container should return the added instance var result = container.GetInstance<IPerson>(); Assert.AreSame(person, result); }
public Hiro() { var map = new DependencyMap(); map.AddSingletonService<Game, Game>(); map.AddService<Player, Player>(); map.AddService<Gun, Gun>(); map.AddService<Bullet, Bullet>(); Func<IMicroContainer, Bullet> createBullet = c => c.GetInstance<Bullet>(); Func<IMicroContainer, Func<Bullet>> createBulletFunctor = c => () => createBullet(c); map.AddService(createBulletFunctor); container = map.CreateContainer(); }
public void ShouldBeAbleToAddNamedUntypedFunctorToDependencyMap() { var expectedInstance = new Foo(); Func<IMicroContainer, object> functor = c => expectedInstance; var serviceType = typeof(IFoo); var map = new DependencyMap(); map.AddService("myFoo", serviceType, functor); var container = map.CreateContainer(); var foo = container.GetInstance<IFoo>("myFoo"); Assert.IsNotNull(foo); Assert.AreSame(expectedInstance, foo); }
public void ShouldBeAbleToInjectGenericConstructor() { var map = new DependencyMap(); map.AddService<UnitOfWorkScopeBase<UserUnitOfWork>, SimpleUnitOfWorkScope<UserUnitOfWork>>(); map.AddSingletonService<LightSpeedContext<UserUnitOfWork>, LightSpeedContext<UserUnitOfWork>>(); var container = map.CreateContainer(); var service = container.GetInstance<UnitOfWorkScopeBase<UserUnitOfWork>>(); Assert.IsNotNull(service); }
public void ShouldBeAbleToCombineDependencyMaps() { var firstMap = new DependencyMap(); var secondMap = new DependencyMap(); firstMap.AddService(typeof(IPerson), typeof(Person)); secondMap.AddService(typeof(IVehicle), typeof(Vehicle)); DependencyMap combinedMap = firstMap + secondMap; var container = combinedMap.CreateContainer(); Assert.IsNotNull(container.GetInstance <IVehicle>()); Assert.IsNotNull(container.GetInstance <IPerson>()); }
private static void ConfigureClass(Type type, IRegistry registry, FireOptions fireOption, DependencyMap dependencyMap) { var inst = new LooseConstructorInstance(context => { var ctorArgs = type .GetGreediestCtor() .GetParameters() .Select(p => context.GetInstance(p.ParameterType)); return Notifiable.MakeForClass(type, fireOption, ctorArgs.ToArray(), new ProxyGenerator(), dependencyMap); }); registry.For(type).Use(inst); }
public void ShouldBeAbleToAddNamedTypedFunctorToDependencyMap() { var expectedInstance = new Foo(); Func <IMicroContainer, IFoo> functor = c => expectedInstance; var map = new DependencyMap(); map.AddService("myFoo", functor); var container = map.CreateContainer(); var foo = container.GetInstance <IFoo>("myFoo"); Assert.AreSame(expectedInstance, foo); }
public void DependencyMap_Ctor2_Asbtract_Test() { //arrange Type type = typeof(abs_foo); IDependencyMap dependencyMap; Mock <IDIContainer> mockContainer = new Mock <IDIContainer>(); //act dependencyMap = new DependencyMap(mockContainer.Object, type, InstanceType.Local); //assert Assert.AreEqual(type.GetDependencyId(), dependencyMap.SourceDependencyId); Assert.AreEqual(true, dependencyMap.IsAbstractOrInterface); Assert.IsNull(dependencyMap.PrimaryDependencyHolder); }
/// <summary> /// Adds a named service to the dependency map. /// </summary> /// <remarks>This service will be created once per web session.</remarks> /// <param name="map">The target dependency map.</param> /// <param name="serviceName">The service name.</param> /// <param name="serviceType">The service type.</param> /// <param name="implementingType">The implementing type.</param> public static void AddPerSessionService(this DependencyMap map, string serviceName, Type serviceType, Type implementingType) { // Add the SessionCache by default if (!map.Contains(typeof(ICache))) { map.AddService <ICache, SessionCache>(); } // The cached instantiation class will use the cache in the container // to cache service instances var dependency = new Dependency(serviceType, serviceName); var implementation = new CachedInstantiation(new TransientType(implementingType, map, new ConstructorResolver())); map.AddService(dependency, implementation); }
private void RemoveNonSourcesFromRoots(IList roots, DependencyMap precedents) { var arr = new Reference[roots.Count]; roots.CopyTo(arr, 0); for (int i = 0; i <= arr.Length - 1; i++) { Reference root = arr[i]; if (precedents.ContainsTail(root)) { roots.Remove(root); } } }
public void ShouldBeAbleToInjectGenericConstructor() { var map = new DependencyMap(); map.AddService <UnitOfWorkScopeBase <UserUnitOfWork>, SimpleUnitOfWorkScope <UserUnitOfWork> >(); map.AddSingletonService <LightSpeedContext <UserUnitOfWork>, LightSpeedContext <UserUnitOfWork> >(); var container = map.CreateContainer(); var service = container.GetInstance <UnitOfWorkScopeBase <UserUnitOfWork> >(); Assert.IsNotNull(service); }
public void ShouldBeAbleToInstantiateNamedGenericType() { var map = new DependencyMap(); map.AddService("List", typeof(IEnumerable<>), typeof(List<>)); map.AddService("Queue", typeof(IEnumerable<>), typeof(Queue<>)); var container = map.CreateContainer(); var list = container.GetInstance<IEnumerable<int>>("List"); Assert.IsNotNull(list); var queue = container.GetInstance<IEnumerable<int>>("Queue"); Assert.IsNotNull(queue); Assert.IsFalse(queue.GetType() != list.GetType()); }
public void ShouldUseConstructorParameterNameToInjectNamedServiceInstanceIfTheNamedServiceExists() { var map = new DependencyMap(); map.AddService <IVehicle, Vehicle>("Vehicle"); map.AddService <IVehicle, Truck>("Truck"); map.AddService <Garage, Garage>(); var container = map.CreateContainer(); var garage = container.GetInstance <Garage>(); Assert.IsNotNull(garage.Vehicle); Assert.IsInstanceOfType(typeof(Vehicle), garage.Vehicle); }
public void ShouldBeAbleToReturnTheSameSingletonInstance() { var map = new DependencyMap(); map.AddSingletonService(typeof(IPerson), typeof(Person)); var container = map.CreateContainer(); var result = container.GetInstance(typeof(IPerson), null); for (var i = 0; i < 100; i++) { var currentResult = container.GetInstance(typeof(IPerson), null); Assert.AreSame(result, currentResult); } }
public void ShouldInjectPropertyIfDependencyMapHasAPropertyInjectorAssignedToTheInjectorProperty() { var map = new DependencyMap(); map.Injector = new PropertyInjector(); map.AddService<IVehicle, Vehicle>(); map.AddService<IPerson, Person>(); var container = map.CreateContainer(); var result = (IVehicle)container.GetInstance(typeof(IVehicle), null); Assert.IsNotNull(result); Assert.IsNotNull(result.Driver); Assert.IsTrue(result.Driver is Person); }
public void ShouldBeAbleToAddExistingServiceInstanceToContainer() { var map = new DependencyMap(); var person = new Person(); // Create a blank container var container = map.CreateContainer(); container.AddService <IPerson>(null, person); // The container should return the added instance var result = container.GetInstance <IPerson>(); Assert.AreSame(person, result); }
public void ShouldBeAbleToInstantiateGenericSingletonTypes() { var map = new DependencyMap(); map.AddSingletonService(typeof(IList <>), typeof(List <>)); var container = map.CreateContainer(); var list = container.GetInstance <IList <int> >(); Assert.IsNotNull(list); var otherList = container.GetInstance <IList <int> >(); Assert.AreSame(list, otherList); }
public void ShouldBeAbleToCompileContainerUsingATypeWithMultipleConstructors() { var map = new DependencyMap(); map.AddService(typeof(IVehicle), typeof(Vehicle)); map.AddService(typeof(IPerson), typeof(Person)); var container = Compile(map); var result = container.GetInstance(typeof(IVehicle), null); var vehicle = (IVehicle)result; Assert.IsNotNull(vehicle); Assert.IsNotNull(vehicle.Driver); }
public async Task Start() { // As we are not using 4.6 we must include the Discord.Net WebSocketProvider. client = new DiscordSocketClient(new DiscordSocketConfig { WebSocketProvider = Discord.Net.Providers.WS4Net.WS4NetProvider.Instance, LogLevel = LogSeverity.Verbose }); // Writes detailed log to the console client.Log += (l) => Task.Run(() => Console.WriteLine($"[{l.Severity}] {l.Source}: {l.Exception?.ToString() ?? l.Message}")); // Variable for token var token = "MjY0MjAwODI2NDI2MzU5ODA4.C3NZWg.hLb2Z8U66zcef7fgC43yAra6Ydo"; // Use token to login, and then use asyncconnect to connect to discord await client.LoginAsync(TokenType.Bot, token); await client.ConnectAsync(); // Create a new dependency map var map = new DependencyMap(); map.Add(client); // Recall command handler and add the dependency map to it handler = new CommandHandler(); await handler.Install(map); // Hooking into events client.UserJoined += async(e) => { try { ulong channelid = 266188297339011082; e.Discord.GetChannel(channelid); Console.WriteLine("Channel Found"); } catch { Console.WriteLine("Channel not found, or error with code"); } }; // Block the closing of the program until it is closed await Task.Delay(-1); }
public Hiro() { var map = new DependencyMap(); map.AddSingletonService <Game, Game>(); map.AddService <Player, Player>(); map.AddService <Gun, Gun>(); map.AddService <Bullet, Bullet>(); Func <IMicroContainer, Bullet> createBullet = c => c.GetInstance <Bullet>(); Func <IMicroContainer, Func <Bullet> > createBulletFunctor = c => () => createBullet(c); map.AddService(createBulletFunctor); container = map.CreateContainer(); }
public void ShouldBeAbleToAddUntypedFunctorToDependencyMap() { var expectedInstance = new Foo(); Func <IMicroContainer, object> functor = c => expectedInstance; var serviceType = typeof(IFoo); var map = new DependencyMap(); map.AddService(serviceType, functor); var container = map.CreateContainer(); var foo = container.GetInstance <IFoo>(); Assert.IsNotNull(foo); Assert.AreSame(expectedInstance, foo); }
public void InnerDependenciesSucceeds() { DependencyMap injector = new DependencyMap(); injector.Register <IInterface, AnotherClass>(); var actualClass = (AnotherClass)injector.Resolve(typeof(IInterface)); AssertResolution(actualClass, typeof(AnotherClass)); Assert.True(actualClass.Blah == null); injector.Register <ITestInterface, TestClass>(); actualClass = (AnotherClass)injector.Resolve(typeof(IInterface)); Assert.True( actualClass.Blah.GetType() == typeof(TestClass), $"Expected {typeof(TestClass).Name}\nWas {actualClass.Blah.GetType().Name}" ); }
public async Task Start() { client = new DiscordSocketClient(); await client.LoginAsync(TokenType.Bot, "TOKEN HERE"); await client.ConnectAsync(); var map = new DependencyMap(); map.Add(client); handler = new CommandHandler(); await handler.Install(map); await Task.Delay(-1); }
public void DependencyResolutionSucceeds() { DependencyMap injector = new DependencyMap(); injector.Register <ITestInterface, TestClass>(); injector.Register(typeof(AnotherClass)); object actualClass = injector.Resolve(typeof(ITestInterface)); object anotherClass = injector.Resolve(typeof(AnotherClass)); AssertResolution(actualClass, typeof(TestClass)); AssertResolution(anotherClass, typeof(AnotherClass)); actualClass = injector.Resolve <ITestInterface>(); anotherClass = injector.Resolve <AnotherClass>(); AssertResolution(actualClass, typeof(TestClass)); AssertResolution(anotherClass, typeof(AnotherClass)); }
public async Task Start() { client = new DiscordSocketClient(); commands = new CommandService(); string token = "bot token here"; map = new DependencyMap(); await InstallCommands(); await client.LoginAsync(TokenType.Bot, token); await client.ConnectAsync(); await Task.Delay(-1); }
public void ShouldInjectPropertyIfDependencyMapHasAPropertyInjectorAssignedToTheInjectorProperty() { var map = new DependencyMap(); map.Injector = new PropertyInjector(); map.AddService <IVehicle, Vehicle>(); map.AddService <IPerson, Person>(); var container = map.CreateContainer(); var result = (IVehicle)container.GetInstance(typeof(IVehicle), null); Assert.IsNotNull(result); Assert.IsNotNull(result.Driver); Assert.IsTrue(result.Driver is Person); }
public async Task RunAsync(params string[] args) { PrettyConsole.NewLine("=== DEA ==="); PrettyConsole.NewLine(); Client = new DiscordSocketClient(new DiscordSocketConfig() { LogLevel = LogSeverity.Error, MessageCacheSize = 10, TotalShards = Credentials.ShardCount, //AlwaysDownloadUsers = true, }); Client.Log += (l) => Task.Run(() => PrettyConsole.Log(l.Severity, l.Source, l.Exception?.ToString() ?? l.Message)); CommandService = new CommandService(new CommandServiceConfig() { CaseSensitiveCommands = false, DefaultRunMode = RunMode.Sync }); var sw = Stopwatch.StartNew(); //Connection await Client.LoginAsync(TokenType.Bot, Credentials.Token).ConfigureAwait(false); await Client.StartAsync().ConfigureAwait(false); //await Client.DownloadAllUsersAsync().ConfigureAwait(false); sw.Stop(); PrettyConsole.Log(LogSeverity.Info, "Successfully connected", $"Elapsed time: {sw.Elapsed.TotalSeconds.ToString()} seconds."); var Map = new DependencyMap(); ConfigureServices(Map); await new MessageRecieved().InitializeAsync(Client, Map); new Ready(Client); PrettyConsole.Log(LogSeverity.Info, "Events and mapping successfully initialized", $"Client ready."); using (var db = new DEAContext()) { await db.Database.EnsureCreatedAsync(); } PrettyConsole.Log(LogSeverity.Info, "Database creation ensured", $"Ready for use."); }
public void ShouldInjectDefaultServiceImplementationIntoTargetProperty() { var map = new DependencyMap(); var dependency = new Dependency(typeof(IVehicle)); var injector = new PropertyInjectionCall(new TransientType(typeof(Vehicle), map, new ConstructorResolver())); map.AddService(dependency, injector); map.AddService(typeof(IPerson), typeof(Person)); var container = map.CreateContainer(); var result = (IVehicle)container.GetInstance(typeof(IVehicle), null); Assert.IsNotNull(result); Assert.IsNotNull(result.Driver); Assert.IsTrue(result.Driver is Person); }
public void ShouldCallInitializeOnSingletonTypeThatImplementsIInitializeOnceAndOnlyOnce() { var map = new DependencyMap(); map.AddSingletonService <IInitialize, SampleInitialize>(); var container = map.CreateContainer(); var result = (SampleInitialize)container.GetInstance <IInitialize>(); for (var i = 0; i < 100; i++) { result = (SampleInitialize)container.GetInstance <IInitialize>(); } Assert.AreSame(container, result.Container); Assert.IsTrue(result.NumberOfTimesInitialized == 1); }
public async Task Run(string[] args) { // Init vars CTS = new CancellationTokenSource(); CT = CTS.Token; // Setup objects _client = new DiscordSocketClient(new DiscordSocketConfig() { AlwaysDownloadUsers = true, LogLevel = LogSeverity.Debug, MessageCacheSize = 250 }); // Setup event handlers _client.Log += ClientLog; _client.JoinedGuild += ClientJoinGuild; // Login and start bot // For a locally running bot, it's fine to use an environment variable, for ease of use // If you distribute your bot, using a config.json is recommended. // Since we will showcase more options, we will use a config.json // To use an env variable, you can do something like this: Properties.Resources.ResourceManager.GetString("BOT_TOKEN") // Our ConfigManager is static, see ConfigManager.cs // For your config.json file, make sure Copy to output directory is set to Always await ConfigManager.Read(); // First login, then start // Similar order reverse: StopAsync, LogoutAsync await _client.LoginAsync(TokenType.Bot, ConfigManager.properties.Token); await _client.StartAsync(); var map = new DependencyMap(); map.Add(_client); handler = new CommandHandler(); await handler.Install(map); Console.Title = "Example Bot - " + ConfigManager.properties.Version; // Block program until it's closed or task is canceled await Task.Delay(-1, CT); }
private async Task DoBotStuff() { map = new DependencyMap(); commands = new CommandService(); client = new DiscordSocketClient(); await ConfigureEventHandlers(); await InstallCommands(); Console.WriteLine("Logging In"); await client.LoginAsync(Discord.TokenType.Bot, Constants.DiscordToken); Console.WriteLine("Logged In"); Console.WriteLine("Connecting"); await client.StartAsync(); Console.WriteLine("Connected. Awaiting Instruction"); }
public void ShouldReturnImplementationsFromDependencyMapFromImplementationsThatHaveNoMissingDependencies() { var map = new DependencyMap(); var dependency = new Dependency(typeof(IVehicle), string.Empty); var implementation = new Mock <IImplementation>(); implementation.Expect(impl => impl.GetMissingDependencies(map)).Returns(new IDependency[0]); bool addIncompleteImplementations = false; map.AddService(dependency, implementation.Object); var results = map.GetImplementations(dependency, addIncompleteImplementations); Assert.IsTrue(results.Count() > 0); Assert.IsTrue(results.Contains(implementation.Object)); implementation.VerifyAll(); }
public void ShouldBeAbleToInstantiateNamedGenericType() { var map = new DependencyMap(); map.AddService("List", typeof(IEnumerable <>), typeof(List <>)); map.AddService("Queue", typeof(IEnumerable <>), typeof(Queue <>)); var container = map.CreateContainer(); var list = container.GetInstance <IEnumerable <int> >("List"); Assert.IsNotNull(list); var queue = container.GetInstance <IEnumerable <int> >("Queue"); Assert.IsNotNull(queue); Assert.IsFalse(queue.GetType() != list.GetType()); }
/// <summary> /// Creates a new Cell /// </summary> public Cell() { //GUI InitializeComponent(); BorderBrush = new SolidColorBrush(Colors.Black); BorderThickness = new Thickness(0.25); CellText.MouseDoubleClick += Cell_MouseDoubleClick; CellText.LostFocus += CellText_LostFocus; CellText.GotFocus += CellText_GotFocus; CellText.KeyDown += CellText_KeyDown; Focusable = true; //!GUI CellFormula = ""; CellDisplay = ""; Dependencies = new DependencyMap(this); }
private async Task HandleCommand(SocketMessage s) { // Don't handle the command if it is a system message var msg = s as SocketUserMessage; if (msg == null) // Check if the received message is from a user. { return; } var map = new DependencyMap(); // Create a new dependecy map. map.Add(_cmds); // Add the command service to the dependency map map.Add(_timer); // Add our services to the dependency map var context = new SocketCommandContext(_client, msg); // Create a new command context. int argPos = 0; // Check if the message has either a string or mention prefix. if (msg.HasStringPrefix(BotConfiguration.Load().Prefix, ref argPos) || msg.HasMentionPrefix(_client.CurrentUser, ref argPos)) { if (_logcommands) // only if logging is enabled in config and it's a bot message { try { _da.LogCommand(context.Guild.Name, msg.Channel.Name, msg.Author.Username, msg.Content, msg.Timestamp.ToLocalTime().ToString()); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } } // Try and execute a command with the given context. var result = await _cmds.ExecuteAsync(context, argPos, map); if (!result.IsSuccess) // If execution failed, reply with the error message. { await context.Channel.SendMessageAsync(result.ToString()); } } }
public HiroUseCase() { var map = new DependencyMap(); map.AddService(typeof(IWebService), typeof(WebService)); map.AddService(typeof(IAuthenticator), typeof(Authenticator)); map.AddService(typeof(IStockQuote), typeof(StockQuote)); map.AddService(typeof(IDatabase), typeof(Database)); map.AddService(typeof(IErrorHandler), typeof(ErrorHandler)); map.AddService(typeof(ILogger), typeof(Logger)); IContainerCompiler compiler = new ContainerCompiler(); var assembly = compiler.Compile(map); var loadedAssembly = assembly.ToAssembly(); var containerType = loadedAssembly.GetTypes()[0]; container = (IMicroContainer)Activator.CreateInstance(containerType); }
public void ShouldCallGetInstanceMethodOnNextContainer() { var map = new DependencyMap(); var container = map.CreateContainer(); Assert.IsNotNull(container); var mockContainer = new Mock <IMicroContainer>(); mockContainer.Expect(m => m.GetInstance(It.IsAny <System.Type>(), It.IsAny <string>())).Returns(42); container.NextContainer = mockContainer.Object; Assert.AreSame(container.NextContainer, mockContainer.Object); var result = container.GetInstance(typeof(int), "abcdefg"); Assert.AreEqual(42, result); mockContainer.VerifyAll(); }
public void ShouldBeAbleToCompileContainerWithParameterlessConstructor() { var targetConstructor = typeof(Vehicle).GetConstructor(new System.Type[0]); var dependency = new Dependency(typeof(IVehicle), string.Empty); var implementation = new ConstructorCall(targetConstructor); var map = new DependencyMap(); map.AddService(dependency, implementation); var container = Compile(map); Assert.IsTrue(container.Contains(typeof(IVehicle), string.Empty)); var result = container.GetInstance(typeof(IVehicle), string.Empty); Assert.IsNotNull(result); }