private void GetListByType(DefaultTypes type, out List <SoundEffect> searchList) { switch (type) { case DefaultTypes.UseItem: searchList = Items; break; case DefaultTypes.Death: searchList = Deaths; break; case DefaultTypes.Win: searchList = Wins; break; case DefaultTypes.Damage: searchList = Damage; break; default: searchList = Clips; break; } }
/// <summary> /// Adds an instance of <see cref="Logger"/> retrieved from <see cref="LoggerFactory"/> and an /// instance of <see cref="ILoggerProvider"/> that uses that logger to the specified /// <see cref="IServiceCollection"/> as singletons. /// </summary> /// <param name="builder">The IWebHostBuilder being extended.</param> /// <param name="rockLibLoggerName">The name of the RockLib logger used for logging.</param> /// /// <param name="defaultTypes"> /// An object that defines the default types to be used when a type is not explicitly specified by a /// configuration section. /// </param> /// <param name="valueConverters"> /// An object that defines custom converter functions that are used to convert string configuration /// values to a target type. /// </param> /// <param name="setConfigRoot"> /// Whether to set the value of the <see cref="Config.Root"/> property to the <see cref="IConfiguration"/> /// containing the merged configuration of the application and the <see cref="IWebHost"/>. /// </param> /// <param name="registerAspNetCoreLogger"> /// Whether to register a RockLib <see cref="ILoggerProvider"/> with the DI system. /// </param> /// <returns>IWebHostBuilder for chaining</returns> /// <remarks> /// This method has a side-effect of calling the <see cref="Config.SetRoot(IConfiguration)"/> /// method, passing it the instance of <see cref="IConfiguration"/> obtained from the local /// <see cref="IServiceProvider"/>. /// </remarks> public static IWebHostBuilder UseRockLibLogging(this IWebHostBuilder builder, string rockLibLoggerName = Logger.DefaultName, DefaultTypes defaultTypes = null, ValueConverters valueConverters = null, bool setConfigRoot = true, bool registerAspNetCoreLogger = false) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (setConfigRoot) { builder.SetConfigRoot(); } builder.ConfigureServices(services => { services.AddLoggerFromLoggerFactory(rockLibLoggerName, defaultTypes, valueConverters); if (registerAspNetCoreLogger) { services.AddRockLibLoggerProvider(); } }); return(builder); }
/// <summary> /// Creates a new instance of <see cref="ILogger"/> with a name matching the <paramref name="name"/> /// parameter that is backed by the value of the <paramref name="configuration"/> parameter. /// </summary> /// <param name="configuration"> /// An instance of <see cref="IConfiguration"/> that defines the loggers that can be retrieved. The /// configuration can define a single logger object or a list of logger objects. /// </param> /// <param name="name">The name of the logger to create.</param> /// <param name="defaultTypes"> /// An object that defines the default types to be used when a type is not explicitly specified by a /// configuration section. /// </param> /// <param name="valueConverters"> /// An object that defines custom converter functions that are used to convert string configuration /// values to a target type. /// </param> /// <param name="resolver"> /// An object that can retrieve constructor parameter values that are not found in configuration. This /// object is an adapter for dependency injection containers, such as Ninject, Unity, Autofac, or /// StructureMap. Consider using the <see cref="Resolver"/> class for this parameter, as it supports /// most depenedency injection containers. /// </param> /// <param name="reloadOnConfigChange"> /// Whether to create an instance of <see cref="ILogger"/> that automatically reloads itself when its /// configuration changes. Default is true. /// </param> /// <returns>A new logger with a matching name.</returns> /// <exception cref="KeyNotFoundException"> /// If a logger with a name specified by the <paramref name="name"/> parameter is not defined in /// the value of the <paramref name="configuration"/> parameter. /// </exception> public static ILogger CreateLogger(this IConfiguration configuration, string name = Logger.DefaultName, DefaultTypes defaultTypes = null, ValueConverters valueConverters = null, IResolver resolver = null, bool reloadOnConfigChange = true) { if (defaultTypes == null) { defaultTypes = new DefaultTypes(); } if (!defaultTypes.TryGet(typeof(ILogger), out var dummy)) { defaultTypes.Add(typeof(ILogger), typeof(Logger)); } if (configuration.IsList()) { foreach (var child in configuration.GetChildren()) { if (name.Equals(child.GetSectionName(), StringComparison.OrdinalIgnoreCase)) { return(reloadOnConfigChange ? child.CreateReloadingProxy <ILogger>(defaultTypes, valueConverters, resolver) : child.Create <ILogger>(defaultTypes, valueConverters, resolver)); } } } else if (name.Equals(configuration.GetSectionName(), StringComparison.OrdinalIgnoreCase)) { return(reloadOnConfigChange ? configuration.CreateReloadingProxy <ILogger>(defaultTypes, valueConverters, resolver) : configuration.Create <ILogger>(defaultTypes, valueConverters, resolver)); } throw new KeyNotFoundException($"No loggers were found matching the name '{name}'."); }
public void DefaultTypesFunctionsProperly() { if (!Config.IsLocked) { var dummy = Config.Root; } var defaultTypes = new DefaultTypes { { typeof(ILogger), typeof(TestLogger) }, { typeof(ITestDependency), typeof(TestDependencyB) } }; var fakeBuilder = new FakeWebHostBuilder() { ServiceCollection = new ServiceCollection() }; fakeBuilder.UseRockLibLogging("TestLogger1", defaultTypes: defaultTypes, registerAspNetCoreLogger: true); var logger = fakeBuilder.ServiceCollection[1].ImplementationFactory.Invoke(null); logger.Should().BeOfType <TestLogger>(); var testLogger = (TestLogger)logger; testLogger.Dependency.Should().BeOfType <TestDependencyB>(); }
/// <summary> /// Adds a singleton <see cref="ILogger"/> service, created with <see cref="LoggerFactory"/>, to the specified /// <see cref="IServiceCollection"/>. /// </summary> /// <param name="services">The <see cref="IServiceCollection"/> to add the service to.</param> /// <param name="rockLibLoggerName">The name of the RockLib logger used for logging.</param> /// <param name="defaultTypes"> /// An object that defines the default types to be used when a type is not explicitly specified by a /// configuration section. /// </param> /// <param name="valueConverters"> /// An object that defines custom converter functions that are used to convert string configuration /// values to a target type. /// </param> /// <param name="addLoggerProvider"> /// Whether to also add a singleton <see cref="ILoggerProvider"/> service with a <see cref="RockLibLoggerProvider"/> /// implementation to the service collection. /// </param> /// <param name="reloadOnConfigChange"> /// Whether instances of <see cref="ILogger"/> created by the service collection will reload when their /// configuration changes. /// </param> /// <returns>The same <see cref="IServiceCollection"/>.</returns> public static IServiceCollection AddRockLibLoggerSingleton(this IServiceCollection services, string rockLibLoggerName = Logger.DefaultName, DefaultTypes defaultTypes = null, ValueConverters valueConverters = null, bool addLoggerProvider = false, bool reloadOnConfigChange = true) { if (services == null) { throw new ArgumentNullException(nameof(services)); } if (services.Any(s => s.ServiceType == typeof(ILogger))) { throw new ArgumentException("RockLib.Logging.ILogger has already been added to the service collection.", nameof(services)); } services.AddSingleton(serviceProvider => { var resolver = new Resolver(type => serviceProvider.GetService(type)); return(LoggerFactory.Create(rockLibLoggerName, defaultTypes, valueConverters, resolver, reloadOnConfigChange)); }); if (addLoggerProvider) { services.AddRockLibLoggerProviderSingleton(); } return(services); }
public virtual JsonResult AgreementTypeOptions() { var comboBox = new ComboBoxOptions { strict = false, buttonTitle = "Show examples", source = DefaultTypes.Select(text => new AutoCompleteOption { label = text, value = text, }), }; var configuration = _queryProcessor.Execute(new GetMyInstitutionalAgreementConfigurationQuery(User)); if (configuration != null) { comboBox.source = configuration.AllowedTypeValues.OrderBy(o => o.Text).Select(o => o.Text) .Select(t => new AutoCompleteOption { label = t, value = t, }); comboBox.strict = !configuration.IsCustomTypeAllowed; if (comboBox.strict) { comboBox.buttonTitle = "Select one"; } } return(Json(comboBox, JsonRequestBehavior.AllowGet)); }
public void ValueConvertersFunctionsProperly() { var defaultTypes = new DefaultTypes { { typeof(ILogger), typeof(TestLogger) } }; Point ParsePoint(string value) { var split = value.Split(','); return(new Point(int.Parse(split[0]), int.Parse(split[1]))); } var valueConverters = new ValueConverters { { typeof(Point), ParsePoint } }; var fakeBuilder = new FakeWebHostBuilder(); fakeBuilder.UseRockLibLogging("TestLogger2", defaultTypes: defaultTypes, valueConverters: valueConverters, registerAspNetCoreLogger: true); var logger = fakeBuilder.ServiceCollection[1].ImplementationFactory.Invoke(null); logger.Should().BeOfType <TestLogger>(); var testLogger = (TestLogger)logger; testLogger.Location.X.Should().Be(2); testLogger.Location.Y.Should().Be(3); }
public void PlaySFX(string soundName, DefaultTypes type = DefaultTypes.Any, float volume = 1f) { AudioClip clip = GetSound(soundName, type); if (clip) { SFX.PlayOneShot(clip, volume); } }
public void PlayRandomSFX(DefaultTypes type, float volume = 1f) { AudioClip clip = GetRandomSound(type); if (clip) { SFX.PlayOneShot(clip, volume); } }
/// <summary> /// Creates an instance of <see cref="DiagnosticsSettings"/> from the specified configuration. /// </summary> /// <see cref="EventTypeFilter"/>. /// <param name="configuration"> /// A configuration object that contains the values for a <see cref="DiagnosticsSettings"/> object. /// </param> /// <returns> /// A <see cref="DiagnosticsSettings"/> object created from the values found in the /// <paramref name="configuration"/> parameter. /// </returns> /// <remarks> /// This method creates the instance of <see cref="DiagnosticsSettings"/> by applying the /// <see cref="ConfigurationObjectFactory.Create{T}(IConfiguration, DefaultTypes, ValueConverters)"/> /// extension method to the <paramref name="configuration"/> parameter and passing /// it a <see cref="DefaultTypes"/> argument with two mappings: the default type for /// the abstract <see cref="TraceListener"/> class is <see cref="DefaultTraceListener"/>, /// and the default type for the abstract <see cref="TraceFilter"/> class is /// </remarks> public static DiagnosticsSettings CreateDiagnosticsSettings(this IConfiguration configuration) { var defaultTypes = new DefaultTypes { { typeof(TraceListener), typeof(DefaultTraceListener) }, { typeof(TraceFilter), typeof(EventTypeFilter) } }; return(configuration.Create <DiagnosticsSettings>(defaultTypes)); }
public void TryGetByDeclaringTypeAndMemberNameReturnsFalseWhenThereNotIsAMatch() { var defaultTypes = new DefaultTypes(); Assert.False(defaultTypes.TryGet(typeof(Foo), "bar", out Type defaultFooBar)); Assert.Null(defaultFooBar); Assert.False(defaultTypes.TryGet(typeof(Foo), "baz", out Type defaultFooBaz)); Assert.Null(defaultFooBaz); }
public void TryGetByTargetTypeReturnsFalseWhenThereNotIsAMatch() { var defaultTypes = new DefaultTypes(); Assert.False(defaultTypes.TryGet(typeof(IBar), out Type defaultFooBar)); Assert.Null(defaultFooBar); Assert.False(defaultTypes.TryGet(typeof(IBaz), out Type defaultFooBaz)); Assert.Null(defaultFooBaz); }
public void GivenNoMatchingMembers_ThrowsArgumentException() { var defaultTypes = new DefaultTypes(); var actual = Assert.Throws <ArgumentException>(() => defaultTypes.Add(typeof(Foo), "qux", typeof(Qux))); #if DEBUG var expected = Exceptions.NoMatchingMembers(typeof(Foo), "qux"); Assert.Equal(expected.Message, actual.Message); #endif }
public void GivenDefaultTypeIsNotAssignableToTargetType_ThrowsArgumentException() { var defaultTypes = new DefaultTypes(); var actual = Assert.Throws <ArgumentException>(() => defaultTypes.Add(typeof(IBar), typeof(Qux))); #if DEBUG var expected = Exceptions.DefaultTypeIsNotAssignableToTargetType(typeof(IBar), typeof(Qux)); Assert.Equal(expected.Message, actual.Message); #endif }
public void GivenAbstractDefaultType2_ThrowsArgumentException() { var defaultTypes = new DefaultTypes(); var actual = Assert.Throws <ArgumentException>(() => defaultTypes.Add(typeof(IBar), typeof(AbstractBar))); #if DEBUG var expected = Exceptions.DefaultTypeCannotBeAbstract(typeof(AbstractBar)); Assert.Equal(expected.Message, actual.Message); #endif }
/// <summary> /// Creates an instance of the <see cref="ISender"/> interface identified by /// its name from the 'senders' section of the <paramref name="configuration"/> parameter. /// </summary> /// <param name="configuration"> /// A configuration object that contains the specified sender in its 'senders' section. /// </param> /// <param name="name">The name that identifies which sender from configuration to create.</param> /// <param name="defaultTypes"> /// An object that defines the default types to be used when a type is not explicitly specified by a /// configuration section. /// </param> /// <param name="valueConverters"> /// An object that defines custom converter functions that are used to convert string configuration /// values to a target type. /// </param> /// <param name="resolver"> /// An object that can retrieve constructor parameter values that are not found in configuration. This /// object is an adapter for dependency injection containers, such as Ninject, Unity, Autofac, or /// StructureMap. Consider using the <see cref="Resolver"/> class for this parameter, as it supports /// most depenedency injection containers. /// </param> /// <param name="reloadOnConfigChange"> /// Whether to create an instance of <see cref="ISender"/> that automatically reloads itself when its /// configuration changes. Default is true. /// </param> /// <returns>A new instance of the <see cref="ISender"/> interface.</returns> public static ISender CreateSender(this IConfiguration configuration, string name, DefaultTypes defaultTypes = null, ValueConverters valueConverters = null, IResolver resolver = null, bool reloadOnConfigChange = true) { if (name == null) { throw new ArgumentNullException(nameof(name)); } return(configuration.CreateScenario <ISender>("senders", name, defaultTypes, valueConverters, resolver, reloadOnConfigChange)); }
private static void AddLoggerFromLoggerFactory(this IServiceCollection services, string rockLibLoggerName, DefaultTypes defaultTypes, ValueConverters valueConverters) { services.AddSingleton <ILogProcessor, BackgroundLogProcessor>(); services.AddTransient(serviceProvider => { var resolver = new Resolver(t => serviceProvider.GetService(t)); return(LoggerFactory.Create(rockLibLoggerName, defaultTypes, valueConverters, resolver, reloadOnConfigChange: false)); }); }
public void TryGetByTargetTypeReturnsTrueWhenThereIsAMatch() { var defaultTypes = new DefaultTypes() .Add(typeof(IBar), typeof(Bar)) .Add(typeof(IBaz), typeof(Baz)); Assert.True(defaultTypes.TryGet(typeof(IBar), out Type defaultFooBar)); Assert.Equal(typeof(Bar), defaultFooBar); Assert.True(defaultTypes.TryGet(typeof(IBaz), out Type defaultFooBaz)); Assert.Equal(typeof(Baz), defaultFooBaz); }
public void TryGetByDeclaringTypeAndMemberNameReturnsTrueWhenThereIsAMatch() { var defaultTypes = new DefaultTypes() .Add(typeof(Foo), "bar", typeof(Bar)) .Add(typeof(Foo), "baz", typeof(Baz)); Assert.True(defaultTypes.TryGet(typeof(Foo), "bar", out Type defaultFooBar)); Assert.Equal(typeof(Bar), defaultFooBar); Assert.True(defaultTypes.TryGet(typeof(Foo), "baz", out Type defaultFooBaz)); Assert.Equal(typeof(Baz), defaultFooBaz); }
public void GivenDefaultTypeIsNotAssignableToMemberType_ThrowsArgumentException() { var defaultTypes = new DefaultTypes(); var actual = Assert.Throws <ArgumentException>(() => defaultTypes.Add(typeof(Foo), "bar", typeof(Qux))); #if DEBUG var expected = Exceptions.DefaultTypeNotAssignableToMembers(typeof(Foo), "bar", typeof(Qux), new List <Member> { new Member("Bar", typeof(IBar), MemberType.Property) }); Assert.Equal(expected.Message, actual.Message); #endif }
public void TypeSpecifiedByDefaultType() { var config = GetNonTypeSpecifiedConfig(); var garplies = 0; var reloading = 0; var reloaded = 0; var defaultTypes = new DefaultTypes().Add(typeof(IFoo), typeof(Foo)); IFoo foo = new ProxyFoo(config.GetSection("foo"), defaultTypes, new ValueConverters(), null, null); ConfigReloadingProxy <IFoo> proxyFoo = (ConfigReloadingProxy <IFoo>)foo; Foo initialFoo = (Foo)proxyFoo.Object; foo.Qux = "xyz"; foo.Garply += (s, e) => { garplies++; }; proxyFoo.Reloading += (s, e) => { reloading++; }; proxyFoo.Reloaded += (s, e) => { reloaded++; }; initialFoo.OnGarply(); Assert.Equal(123, foo.Bar); Assert.Equal("xyz", foo.Qux); Assert.Equal(1, garplies); Assert.False(initialFoo.IsDisposed); Assert.Equal(0, reloading); Assert.Equal(0, reloaded); ChangeNonTypeSpecifiedConfig(config); Assert.True(initialFoo.IsDisposed); Assert.Equal(1, reloading); Assert.Equal(1, reloaded); Foo changedFoo = (Foo)proxyFoo.Object; changedFoo.OnGarply(); Assert.Equal(456, foo.Bar); Assert.Equal("xyz", foo.Qux); Assert.Equal(2, garplies); Assert.False(changedFoo.IsDisposed); ((IDisposable)foo).Dispose(); Assert.True(changedFoo.IsDisposed); }
private AudioClip GetSound(string soundName, DefaultTypes type = DefaultTypes.Any) { List <SoundEffect> searchList = new List <SoundEffect>(); GetListByType(type, out searchList); foreach (SoundEffect sfx in searchList) { if (sfx.Name.ToLower().Trim().Equals(soundName.ToLower().Trim())) { return(sfx.File); } } Debug.LogError("Sound not found - " + soundName); return(null); }
private AudioClip GetRandomSound(DefaultTypes type) { List <SoundEffect> searchList = new List <SoundEffect>(); GetListByType(type, out searchList); if (searchList.Count > 0) { System.Random rng = new System.Random(); int random = rng.Next(0, searchList.Count); return(searchList[random].File); } Debug.LogError("Random sound not found for type - " + type); return(null); }
/// <summary> /// Gets a cached instance of <see cref="ILogger"/> with a name matching the <paramref name="name"/> /// parameter that is backed by the value of the <paramref name="configuration"/> parameter. /// </summary> /// <param name="configuration"> /// An instance of <see cref="IConfiguration"/> that defines the loggers that can be retrieved. The /// configuration can define a single logger object or a list of logger objects. /// </param> /// <param name="name">The name of the logger to retrieve.</param> /// <param name="defaultTypes"> /// An object that defines the default types to be used when a type is not explicitly specified by a /// configuration section. /// </param> /// <param name="valueConverters"> /// An object that defines custom converter functions that are used to convert string configuration /// values to a target type. /// </param> /// <param name="resolver"> /// An object that can retrieve constructor parameter values that are not found in configuration. This /// object is an adapter for dependency injection containers, such as Ninject, Unity, Autofac, or /// StructureMap. Consider using the <see cref="Resolver"/> class for this parameter, as it supports /// most depenedency injection containers. /// </param> /// <param name="reloadOnConfigChange"> /// Whether to create an instance of <see cref="ILogger"/> that automatically reloads itself when its /// configuration changes. Default is true. /// </param> /// <returns>A logger with a matching name.</returns> /// <exception cref="KeyNotFoundException"> /// If a logger with a name specified by the <paramref name="name"/> parameter is not defined in /// the value of the <paramref name="configuration"/> parameter. /// </exception> public static ILogger GetCachedLogger(this IConfiguration configuration, string name = Logger.DefaultName, DefaultTypes defaultTypes = null, ValueConverters valueConverters = null, IResolver resolver = null, bool reloadOnConfigChange = true) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } if (name == null) { throw new ArgumentNullException(nameof(name)); } var configCache = _cache.GetValue(configuration, c => new ConcurrentDictionary <string, ILogger>()); return(configCache.GetOrAdd(name, n => configuration.CreateLogger(n, defaultTypes, valueConverters, resolver, reloadOnConfigChange))); }
public void DefaultTypesFunctionsProperly() { var config = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary <string, string> { { "RockLib.Logging:Name", "foo" } }).Build(); var defaultTypes = new DefaultTypes { { typeof(ILogger), typeof(TestLogger) } }; var section = config.GetSection("RockLib.Logging"); var logger = section.CreateLogger("foo", defaultTypes: defaultTypes, reloadOnConfigChange: false); logger.Should().BeOfType <TestLogger>(); }
public virtual ActionResult Add() { var model = new InstitutionalAgreementConfigurationForm(); // find the configuration for the currently signed in user's default affiliation var configuration = _queryProcessor.Execute(new GetMyInstitutionalAgreementConfigurationQuery(User)); // if configuration exists, cannot add if (configuration != null) { model = Mapper.Map <InstitutionalAgreementConfigurationForm>(configuration); } else { // when configuration does not exist, get the default affiliation for the currently signed in user var person = GetConfigurationSupervisor(); if (person == null) { return(HttpNotFound()); } // allow the viewmodel to disclose the establishment official name model.ForEstablishmentOfficialName = person.DefaultAffiliation.Establishment.OfficialName; // add default options DefaultTypes.ForEach(option => model.AllowedTypeValues.Add( new InstitutionalAgreementTypeValueForm { IsAdded = true, Text = option })); DefaultStatuses.ForEach(option => model.AllowedStatusValues.Add( new InstitutionalAgreementStatusValueForm { IsAdded = true, Text = option })); DefaultContactTypes.ForEach(option => model.AllowedContactTypeValues.Add( new InstitutionalAgreementContactTypeValueForm { IsAdded = true, Text = option })); // add a default empty allowed options AddEmptyAllowedOptions(model); } return(View(model)); }
public void CanAddByTargetType() { // Register a default type by target type when you want all properties of the // target type to have the same default type. // Call the Add method for each default type that needs to be registered. var first = new DefaultTypes(); first.Add(typeof(IBar), typeof(Bar)); first.Add(typeof(IBaz), typeof(Baz)); // The Add method returns 'this', so you can chain them together: var second = new DefaultTypes() .Add(typeof(IBar), typeof(Bar)) .Add(typeof(IBaz), typeof(Baz)); // List initialization syntax works also. var third = new DefaultTypes { { typeof(IBar), typeof(Bar) }, { typeof(IBaz), typeof(Baz) } }; // All three instances represent the same thing. Verify that their // contents are the same. // DefaultTypes implements IEnumerable<KeyValuePair<string, Type>> var firstList = first.ToList(); var secondList = second.ToList(); var thirdList = third.ToList(); Assert.Equal(firstList.Count, secondList.Count); Assert.Equal(secondList.Count, thirdList.Count); for (int i = 0; i < firstList.Count; i++) { Assert.Equal(firstList[i].Key, secondList[i].Key); Assert.Equal(firstList[i].Value, secondList[i].Value); Assert.Equal(secondList[i].Key, thirdList[i].Key); Assert.Equal(secondList[i].Value, thirdList[i].Value); } }
public void DefaultTypesFunctionsProperly() { var config = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary <string, string> { { "RockLib.Messaging:Senders:Name", "foo" }, { "RockLib.Messaging:Receivers:Name", "foo" } }).Build(); var defaultTypes = new DefaultTypes { { typeof(ISender), typeof(TestSender) }, { typeof(IReceiver), typeof(TestReceiver) } }; var messagingSection = config.GetSection("RockLib.Messaging"); using var sender = messagingSection.CreateSender("foo", defaultTypes: defaultTypes, reloadOnConfigChange: false); using var receiver = messagingSection.CreateReceiver("foo", defaultTypes: defaultTypes, reloadOnConfigChange: false); sender.Should().BeOfType <TestSender>(); receiver.Should().BeOfType <TestReceiver>(); }
public void MissingConstructorParametersAreSuppliedByTheResolver() { var config = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary <string, string> { { "waldo", "123" } }) .Build(); var garply = new Garply(); var defaultTypes = new DefaultTypes().Add(typeof(IGrault), typeof(Grault)); var resolver = new Resolver(t => garply, t => t == typeof(IGarply)); var grault = config.CreateReloadingProxy <IGrault>(defaultTypes, resolver: resolver); Assert.Same(garply, grault.Garply); Assert.Equal(123, grault.Waldo); ChangeConfig(config, new KeyValuePair <string, string>("waldo", "456")); Assert.Same(garply, grault.Garply); Assert.Equal(456, grault.Waldo); }
public void GivenNullDefaultType2_ThrowsArgumentNullException() { var defaultTypes = new DefaultTypes(); Assert.Throws <ArgumentNullException>(() => defaultTypes.Add(typeof(IBar), null)); }