public static IExchangeRateService GetExchangeRateService(InternalConfiguration configuration)
{
var exchangeRateMultipleRepository = new ExchangeRateMultipleExternalService(configuration);
var exchangeRateSingleRepository = new ExchangeRateSingleExternalService(configuration);
return(new ExchangeRateService(configuration, exchangeRateSingleRepository, exchangeRateMultipleRepository));
}
static ConfigurationManager()
{
if (Config == null)
{
Config = InternalConfiguration.GetInstance();
}
}
public void should_create_downstream_route_with_rate_limit_options()
{
var rateLimitOptions = new RateLimitOptionsBuilder()
.WithEnableRateLimiting(true)
.WithClientIdHeader("test")
.Build();
var downstreamReRoute = new DownstreamReRouteBuilder()
.WithServiceName("auth")
.WithRateLimitOptions(rateLimitOptions)
.Build();
var reRoute = new ReRouteBuilder()
.WithDownstreamReRoute(downstreamReRoute)
.Build();
var reRoutes = new List <ReRoute> {
reRoute
};
var configuration = new InternalConfiguration(reRoutes, "doesnt matter", null, "doesnt matter", _loadBalancerOptions, "http", _qoSOptions, _handlerOptions);
this.Given(_ => GivenTheConfiguration(configuration))
.When(_ => WhenICreate())
.Then(_ => ThenTheDownstreamRouteIsCreated())
.And(_ => WithRateLimitOptions(rateLimitOptions))
.BDDfy();
}
private void GivenTheConfigurationIs(ServiceProviderConfiguration config)
{
_config = config;
var configuration = new InternalConfiguration(null, null, config, null, null, null, null, null);
_downstreamContext.Configuration = configuration;
}
static ConfigurationManager()
{
if (Config == null)
{
Config = InternalConfiguration.GetInstance();
}
}
public static InternalConfiguration Initialize(NameValueCollection config)
{
var res = new InternalConfiguration();
if (null == config["connectionStringName"])
throw new ArgumentNullException("connectionStringName");
res.ConnectionStringName = config["connectionStringName"];
ConnectionStringSettings ConnectionStringSettings =
ConfigurationManager.ConnectionStrings[res.ConnectionStringName];
if (ConnectionStringSettings == null)
throw new ProviderException("Connection string was not found in config file.");
if (string.IsNullOrWhiteSpace(ConnectionStringSettings.ConnectionString))
throw new ProviderException("Connection string cannot be empty.");
res.ConnectionString = ConnectionStringSettings.ConnectionString;
string prefix;
if (null != config["tablePrefix"])
prefix = config["tablePrefix"];
else
prefix = "wp_";
res.N = new TableNameUtility(prefix);
return res;
}
private async Task <Response <IInternalConfiguration> > SetUpConfiguration(FileConfiguration fileConfiguration)
{
var response = await _configurationValidator.IsValid(fileConfiguration);
if (response.Data.IsError)
{
return(new ErrorResponse <IInternalConfiguration>(response.Data.Errors));
}
var reRoutes = new List <ReRoute>();
foreach (var reRoute in fileConfiguration.ReRoutes)
{
var downstreamReRoute = SetUpDownstreamReRoute(reRoute, fileConfiguration.GlobalConfiguration);
var ocelotReRoute = SetUpReRoute(reRoute, downstreamReRoute);
reRoutes.Add(ocelotReRoute);
}
foreach (var aggregate in fileConfiguration.Aggregates)
{
var ocelotReRoute = SetUpAggregateReRoute(reRoutes, aggregate, fileConfiguration.GlobalConfiguration);
reRoutes.Add(ocelotReRoute);
}
var serviceProviderConfiguration = _serviceProviderConfigCreator.Create(fileConfiguration.GlobalConfiguration);
var config = new InternalConfiguration(reRoutes, _adminPath.Path, serviceProviderConfiguration, fileConfiguration.GlobalConfiguration.RequestIdKey);
return(new OkResponse <IInternalConfiguration>(config));
}
internal override long getActualValue()
{
long actualValue = 0;
try
{
//actualValue = nsmgr.GetQueue(QueueName).MessageCount;
//Console.WriteLine($"https://login.microsoftonline.com/{InternalConfiguration.Tenant}, {InternalConfiguration.ApplicationId}, {InternalConfiguration.ApplicationKey}");
var tokenValue =
//token.access_token;
InternalConfiguration.GetAccessToken($"https://login.microsoftonline.com/{InternalConfiguration.Tenant}", "https://management.azure.com/", InternalConfiguration.ApplicationId, InternalConfiguration.ApplicationKey).GetAwaiter().GetResult();
//Console.WriteLine($"https://management.azure.com/subscriptions/{InternalConfiguration.SubscriptionId}/resourceGroups/rgVol{InternalConfiguration.Name}/providers/Microsoft.ServiceBus/namespaces/dmsb{InternalConfiguration.Name}/queues/{QueueName.ToLower()}?api-version=2015-08-01");
var client2 = new RestClient($"https://management.azure.com/subscriptions/{InternalConfiguration.SubscriptionId}/resourceGroups/rgVol{InternalConfiguration.Name}/providers/Microsoft.ServiceBus/namespaces/dmsb{InternalConfiguration.Name}/queues/{QueueName.ToLower()}?api-version=2015-08-01");
var request2 = new RestRequest(Method.GET);
request2.AddHeader("authorization", $"Bearer {tokenValue}");
request2.AddHeader("cache-control", "no-cache");
request2.AddHeader("content-lenght", "0");
IRestResponse response2 = client2.Execute(request2);
dynamic queue = JObject.Parse(response2.Content);
actualValue = queue.properties.messageCount;
}
catch (ArgumentException ex)
{
Console.WriteLine("Trying to reconnect.");
//nsmgr = null;
//nsmgr = NamespaceManager.CreateFromConnectionString(_connectionString);
throw ex;
}
return(actualValue);
}
internal DbConfiguration(InternalConfiguration internalConfiguration)
{
DebugCheck.NotNull(internalConfiguration);
_internalConfiguration = internalConfiguration;
_internalConfiguration.Owner = this;
}
internal ExchangeRateService(InternalConfiguration configurationBase, IExchangeRateSingleRepository exchangeRateSingleRepository, IExchangeRateMultipleRepository exchangeRateMultipleRepository)
{
_configurationBase = configurationBase;
_exchangeRateSingleRepository = exchangeRateSingleRepository;
_exchangeRateMultipleRepository = exchangeRateMultipleRepository;
}
public SaleService(ApplicationDbContext context, IOptions <EmailSetting> options, IOrderService order, IOptions <InternalConfiguration> internalOptions)
{
_context = context;
_settings = options.Value;
_order = order;
_internalOptions = internalOptions.Value;
}
internal HeartbeatConfiguration(LiteServerConfiguration liteServer, InternalConfiguration configuration)
{
if (liteServer == null)
{
throw new ArgumentNullException(nameof(liteServer));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
_providers = new ScanAddRemoveInstaller <IHeartbeatProvider>();
_configuration = configuration;
LiteServer = liteServer;
LiteServer.Application
.Services(services => services
.Advanced(advanced => advanced
.Install(_providers)));
// Add default providers
AddProvider <CurrentProcessHeartbeatProvider>();
AddProvider <GarbageCollectorHeartbeatProvider>();
}
private void GivenTheConfigurationIs(ServiceProviderConfiguration config)
{
_config = config;
var configuration = new InternalConfiguration(null, null, config, null, null, null, null, null, null);
_httpContext.Items.SetIInternalConfiguration(configuration);
}
public LoginResult(SignInMessage message, HttpRequestMessage request, CoreSettings settings, InternalConfiguration internalConfig)
{
_message = message;
_settings = settings;
_request = request;
_internalConfig = internalConfig;
}
private void WhenICreate()
{
var serviceProvider = _serviceCollection.BuildServiceProvider();
_creator = new ConfigurationCreator(_spcCreator.Object, _qosCreator.Object, _hhoCreator.Object, serviceProvider, _lboCreator.Object, _vCreator.Object);
_result = _creator.Create(_fileConfig, _reRoutes);
}
public void should_call_scoped_data_repository_correctly()
{
var config = new InternalConfiguration(null, null, new ServiceProviderConfigurationBuilder().Build(), "");
var downstreamReRoute = new DownstreamReRouteBuilder()
.WithDownstreamPathTemplate("any old string")
.WithUpstreamHttpMethod(new List <string> {
"Get"
})
.Build();
this.Given(x => x.GivenTheDownStreamRouteFinderReturns(
new DownstreamRoute(
new List <PlaceholderNameAndValue>(),
new ReRouteBuilder()
.WithDownstreamReRoute(downstreamReRoute)
.WithUpstreamHttpMethod(new List <string> {
"Get"
})
.Build())))
.And(x => GivenTheFollowingConfig(config))
.When(x => x.WhenICallTheMiddleware())
.Then(x => x.ThenTheScopedDataRepositoryIsCalledCorrectly())
.BDDfy();
}
/// <summary>
/// Initializes a new instance of the <see cref="RestClientService"/> class
/// with a specified <see cref="IRestClientDescription"/> instance.
/// </summary>
/// <param name="configuration">The configuration instance.</param>
public RestClientService(IRestClientDescription configuration) : base(configuration)
{
if (this.Description == null)
{
this.Description = InternalConfiguration.GetServiceClientConfiguration().Clients.Find(d => d.Name == endpointName);
}
}
public static InternalConfiguration GetInstance()
{
if (Config == null)
{
Config = new InternalConfiguration();
}
return(Config);
}
public void Given_Configuration_When_GetCityServiceInvoked_Then_ICityServiceRetrived()
{
var configuration = new InternalConfiguration(StaticDataConfigurationBuilder.Generate().SetApiPreferably(false));
var service = StaticDataServiceFactory.GetCityService(configuration);
Assert.IsNotNull(service);
Assert.AreEqual(typeof(CityService), service.GetType());
}
/// <summary>
/// Initializes a new instance <see cref="RestClientService"/> class
/// with a specified endpoint name.
/// </summary>
/// <param name="endpointName">The name of the endpoint to use in the configuration.</param>
public RestClientService(string endpointName) : base(InternalConfiguration.GetServiceClientConfiguration().Clients.Find(x => x.Name == endpointName))
{
this.endpointName = endpointName;
this.Requesting += (o, e) =>
{
EntitySource.Current = new EntitySource(new WebEntitySourceProvider(this.Credentials));
};
}
public AuthenticationController(IUserService userService, CoreSettings settings, IExternalClaimsFilter externalClaimsFilter, AuthenticationOptions authenticationOptions, InternalConfiguration internalConfiguration)
{
_userService = userService;
_settings = settings;
_externalClaimsFilter = externalClaimsFilter;
_authenticationOptions = authenticationOptions;
_internalConfiguration = internalConfiguration;
}
public static InternalConfiguration GetInstance()
{
if (Config == null)
{
Config = new InternalConfiguration();
}
return Config;
}
public void Given_ConfigurationWithApiTrue_When_GetCountryServiceInvoked_Then_ICountryServiceWithExternalServiceRetrived()
{
var configuration = new InternalConfiguration(StaticDataConfigurationBuilder.Generate());
var service = StaticDataServiceFactory.GetCountryService(configuration);
Assert.IsNotNull(service);
Assert.AreEqual(typeof(CountryService), service.GetType());
}
public Commons(ApplicationDbContext context, IOptions <EmailSetting> options,
UserManager <ApplicationUser> userManager,
IOptions <InternalConfiguration> internalConfigurations)
{
_context = context;
_settings = options.Value;
_userManager = userManager;
_internalOptions = internalConfigurations.Value;
}
public Identity(string token, IServiceProvider serviceProvider)
{
Token = token;
ValidUntil = DateTime.UtcNow.AddMinutes(15);
_serviceProvider = serviceProvider;
_discordAPI = serviceProvider.GetRequiredService <DiscordAPIInterface>();
_config = serviceProvider.GetRequiredService <InternalConfiguration>();
}
public void should_create_downstream_route_with_handler_options()
{
var configuration = new InternalConfiguration(null, "doesnt matter", null, "doesnt matter", _loadBalancerOptions, "http", _qoSOptions, _handlerOptions, new Version("1.1"));
this.Given(_ => GivenTheConfiguration(configuration))
.When(_ => WhenICreate())
.Then(_ => ThenTheHandlerOptionsAreSet())
.BDDfy();
}
public void Given_Configuration_When_GetExchangeRateServiceInvoked_Then_IExchangeRateServiceRetrived()
{
var configuration = new InternalConfiguration(StaticDataConfigurationBuilder.Generate());
var service = StaticDataServiceFactory.GetExchangeRateService(configuration);
Assert.IsNotNull(service);
Assert.AreEqual(typeof(ExchangeRateService), service.GetType());
}
public void should_create_downstream_route()
{
var configuration = new InternalConfiguration(null, "doesnt matter", null, "doesnt matter", _loadBalancerOptions, "http", _qoSOptions, _handlerOptions);
this.Given(_ => GivenTheConfiguration(configuration))
.When(_ => WhenICreate())
.Then(_ => ThenTheDownstreamRouteIsCreated())
.BDDfy();
}
public AuthenticationController(ILogger logger, IUserService userService, CoreSettings settings, IExternalClaimsFilter externalClaimsFilter, AuthenticationOptions authenticationOptions, InternalConfiguration internalConfiguration)
{
this.logger = logger;
this.userService = userService;
this.settings = settings;
this.externalClaimsFilter = externalClaimsFilter;
this.authenticationOptions = authenticationOptions;
this.internalConfiguration = internalConfiguration;
}
private static void RegisterServicesSingleton(IServiceCollection services, InternalConfiguration configurationBase)
{
services.AddSingleton(configurationBase);
services.AddSingleton(StaticDataServiceFactory.GetCityService(configurationBase));
services.AddSingleton(StaticDataServiceFactory.GetCountryService(configurationBase));
services.AddSingleton(StaticDataServiceFactory.GetCurrencyService(configurationBase));
services.AddSingleton(StaticDataServiceFactory.GetExchangeRateService(configurationBase));
}
/// <summary>
/// Set a configuration to the pointer file
/// </summary>
/// <param name="configuration"></param>
public void SetConfiguration(IConfiguration configuration)
{
var rawConfig = ReadFile().ToList();
var internalModel = new InternalConfiguration(configuration);
var categoryIndex = rawConfig.IndexOf(internalModel.ConfigurationNameStandard);
if (categoryIndex != -1)
{
for (int i = categoryIndex + 1; i < rawConfig.Count; i++)
{
if (FormatsStandars.IsValidCategoryName(rawConfig[i]))
{
// it is a category name, ignore it
continue;
}
string propertyString = rawConfig[i];
bool isComment = FormatsStandars.IsComment(propertyString);
bool isEmpty = String.IsNullOrWhiteSpace(propertyString);
if (isComment == false && isEmpty == false)
{
var property = MyConfigParser.ParseProperty(propertyString);
if (configuration.GetConfigurations().Any(x => x.Key == property.Key))
{
var newProperty = configuration.GetConfigurations().First(x => x.Key == property.Key);
// update the property
rawConfig[i] = "\t" + newProperty.Key + " = " + newProperty.Value;
}
}
}
}
else
{
int lastIndexOfArray = rawConfig.Count == 0 ? 0 : rawConfig.Count - 1;
if (lastIndexOfArray == 0){
rawConfig.Add(internalModel.ConfigurationNameStandard);
}
else{
rawConfig[lastIndexOfArray] += Environment.NewLine + internalModel.ConfigurationNameStandard;
}
foreach (var item in internalModel.GetConfigurations())
{
rawConfig[lastIndexOfArray] += Environment.NewLine + "\t" + item.Key + " = " + item.Value;
}
}
File.WriteAllLines(this.Path, rawConfig);
}
/// <summary>
/// Set a configuration to the pointer file
/// </summary>
/// <param name="configuration"></param>
public void SetConfiguration(IConfiguration configuration)
{
var rawConfig = ReadFile().ToList();
var internalModel = new InternalConfiguration(configuration);
var categoryIndex = rawConfig.IndexOf(internalModel.ConfigurationNameStandard);
if (categoryIndex != -1)
{
for (int i = categoryIndex + 1; i < rawConfig.Count; i++)
{
if (FormatsStandars.IsValidCategoryName(rawConfig[i]))
{
// it is a category name, ignore it
continue;
}
string propertyString = rawConfig[i];
bool isComment = FormatsStandars.IsComment(propertyString);
bool isEmpty = String.IsNullOrWhiteSpace(propertyString);
if (isComment == false && isEmpty == false)
{
var property = MyConfigParser.ParseProperty(propertyString);
if (configuration.GetConfigurations().Any(x => x.Key == property.Key))
{
var newProperty = configuration.GetConfigurations().First(x => x.Key == property.Key);
// update the property
rawConfig[i] = "\t" + newProperty.Key + " = " + newProperty.Value;
}
}
}
}
else
{
int lastIndexOfArray = rawConfig.Count == 0 ? 0 : rawConfig.Count - 1;
if (lastIndexOfArray == 0)
{
rawConfig.Add(internalModel.ConfigurationNameStandard);
}
else
{
rawConfig[lastIndexOfArray] += Environment.NewLine + internalModel.ConfigurationNameStandard;
}
foreach (var item in internalModel.GetConfigurations())
{
rawConfig[lastIndexOfArray] += Environment.NewLine + "\t" + item.Key + " = " + item.Value;
}
}
File.WriteAllLines(this.Path, rawConfig);
}
public void should_create_downstream_route_for_sticky_sessions()
{
var loadBalancerOptions = new LoadBalancerOptionsBuilder().WithType(nameof(CookieStickySessions)).WithKey("boom").WithExpiryInMs(1).Build();
var configuration = new InternalConfiguration(null, "doesnt matter", null, "doesnt matter", loadBalancerOptions, "http", _qoSOptions, _handlerOptions);
this.Given(_ => GivenTheConfiguration(configuration))
.When(_ => WhenICreate())
.Then(_ => ThenTheStickySessionLoadBalancerIsUsed(loadBalancerOptions))
.BDDfy();
}
public void should_create_downstream_route_and_remove_query_string()
{
var upstreamUrlPath = "/auth/test?test=1&best=2";
var configuration = new InternalConfiguration(null, "doesnt matter", null, "doesnt matter", _loadBalancerOptions, "http", _qoSOptions, _handlerOptions);
this.Given(_ => GivenTheConfiguration(configuration, upstreamUrlPath))
.When(_ => WhenICreate())
.Then(_ => ThenTheQueryStringIsRemoved())
.BDDfy();
}
public virtual void OnLocking(InternalConfiguration configuration)
{
DebugCheck.NotNull(configuration);
var handler = _onLockingConfiguration;
if (handler != null)
{
handler(configuration.Owner, new DbConfigurationEventArgs(configuration));
}
}
public virtual void OnLoaded(InternalConfiguration configuration)
{
DebugCheck.NotNull(configuration);
var handler = _loadedHandler;
if (handler != null)
{
handler(configuration.Owner, new DbConfigurationLoadedEventArgs(configuration));
}
}
public AppConfigDependencyResolver(
AppConfig appConfig,
InternalConfiguration internalConfiguration,
ProviderServicesFactory providerServicesFactory = null)
{
DebugCheck.NotNull(appConfig);
_appConfig = appConfig;
_internalConfiguration = internalConfiguration;
_providerServicesFactory = providerServicesFactory ?? new ProviderServicesFactory();
}
public void AddSecondaryResolver_throws_if_the_configuation_is_locked()
{
var internalConfiguration = new InternalConfiguration();
internalConfiguration.Lock();
Assert.Equal(
Strings.ConfigurationLocked("AddSecondaryResolver"),
Assert.Throws<InvalidOperationException>(
() =>
new DbConfigurationEventArgs(internalConfiguration)
.AddSecondaryResolver(new Mock<IDbDependencyResolver>().Object)).Message);
}
public virtual void OnLoaded(InternalConfiguration configuration)
{
DebugCheck.NotNull(configuration);
var eventArgs = new DbConfigurationLoadedEventArgs(configuration);
var handler = _loadedHandler;
if (handler != null)
{
handler(configuration.Owner, eventArgs);
}
configuration.DispatchLoadedInterceptors(eventArgs);
}
public virtual void SetConfiguration(InternalConfiguration configuration, bool lookInConfig = true)
{
DebugCheck.NotNull(configuration);
if (lookInConfig)
{
configuration = _loader.TryLoadFromConfig(AppConfig.DefaultInstance) ?? configuration;
}
_newConfiguration = configuration.Owner;
if (_configuration.Value.Owner.GetType()
!= configuration.Owner.GetType())
{
if (_configuration.Value.Owner.GetType()
== typeof(DbConfiguration))
{
throw new InvalidOperationException(Strings.DefaultConfigurationUsedBeforeSet(configuration.Owner.GetType().Name));
}
throw new InvalidOperationException(
Strings.ConfigurationSetTwice(configuration.Owner.GetType().Name, _configuration.Value.Owner.GetType().Name));
}
}
public void RootResolver_returns_the_root_resolver()
{
var rootResolver = new RootDependencyResolver();
var config = new InternalConfiguration(
new Mock<ResolverChain>().Object,
new Mock<ResolverChain>().Object,
rootResolver,
new Mock<AppConfigDependencyResolver>().Object);
Assert.Same(rootResolver, config.RootResolver);
}
public void All_interceptors_are_added_and_Loaded_interceptors_are_called_when_config_is_locked()
{
var mockAppConfigChain = new Mock<ResolverChain>();
var interceptor1 = new Mock<IDbInterceptor>().Object;
var interceptor2 = new Mock<IDbConfigurationInterceptor>().Object;
var mockNormalResolver = new Mock<IDbDependencyResolver>();
mockNormalResolver
.Setup(m => m.GetServices(typeof(IDbInterceptor), null))
.Returns(new[] { interceptor1, interceptor2 });
var normalChain = new ResolverChain();
normalChain.Add(mockNormalResolver.Object);
var interceptor3 = new Mock<IDbConfigurationInterceptor>().Object;
var mockLoadedResolver = new Mock<IDbDependencyResolver>();
mockLoadedResolver
.Setup(m => m.GetServices(typeof(IDbInterceptor), null))
.Returns(new[] { interceptor3 });
var mockDispatchers = new Mock<DbDispatchers>();
var mockDispatcher = new Mock<DbConfigurationDispatcher>();
mockDispatchers.Setup(m => m.Configuration).Returns(mockDispatcher.Object);
mockDispatcher
.Setup(m => m.Loaded(It.IsAny<DbConfigurationLoadedEventArgs>(), It.IsAny<DbInterceptionContext>()))
.Callback<DbConfigurationLoadedEventArgs, DbInterceptionContext>(
(a, _) => a.AddDependencyResolver(mockLoadedResolver.Object, false));
var config = new InternalConfiguration(
mockAppConfigChain.Object, normalChain,
new RootDependencyResolver(),
new Mock<AppConfigDependencyResolver>().Object,
() => mockDispatchers.Object);
config.Lock();
mockNormalResolver.Verify(m => m.GetServices(typeof(IDbInterceptor), null), Times.Exactly(2));
mockLoadedResolver.Verify(m => m.GetServices(typeof(IDbInterceptor), null), Times.Once());
mockDispatchers.Verify(m => m.AddInterceptor(interceptor1), Times.Once());
mockDispatchers.Verify(m => m.AddInterceptor(interceptor2), Times.Once());
mockDispatchers.Verify(m => m.AddInterceptor(interceptor3), Times.Once());
mockDispatcher.Verify(
m => m.Loaded(It.IsAny<DbConfigurationLoadedEventArgs>(), It.IsAny<DbInterceptionContext>()));
}
public void DependencyResolver_returns_the_dependency_resolver_in_use()
{
var mockAppConfigChain = new Mock<ResolverChain>();
var mockNormalChain = new Mock<ResolverChain>();
var config = new InternalConfiguration(
mockAppConfigChain.Object, mockNormalChain.Object,
new RootDependencyResolver(),
new Mock<AppConfigDependencyResolver>().Object);
var resolver = (CompositeResolver<ResolverChain, ResolverChain>)config.DependencyResolver;
Assert.Same(mockAppConfigChain.Object, resolver.First);
Assert.Same(mockNormalChain.Object, resolver.Second);
}
private static void AssertIsNotLocked(InternalConfiguration internalConfiguration)
{
Assert.DoesNotThrow(() => internalConfiguration.CheckNotLocked("Foo"));
}
private static void AssertIsLocked(InternalConfiguration internalConfiguration)
{
Assert.Throws<InvalidOperationException>(() => internalConfiguration.CheckNotLocked("Foo"));
}
static BizUnitSetting()
{
Config = InternalConfiguration.GetInstance();
}
public virtual void SetConfiguration(InternalConfiguration configuration)
{
DebugCheck.NotNull(configuration);
var configurationType = _loader.TryLoadFromConfig(AppConfig.DefaultInstance);
if (configurationType != null)
{
configuration = configurationType
.CreateInstance<DbConfiguration>(Strings.CreateInstance_BadDbConfigurationType)
.InternalConfiguration;
}
_newConfiguration = configuration.Owner;
if (_configuration.Value.Owner.GetType() != configuration.Owner.GetType())
{
if (_configuration.Value.Owner.GetType() == typeof(DbConfiguration))
{
throw new InvalidOperationException(Strings.DefaultConfigurationUsedBeforeSet(configuration.Owner.GetType().Name));
}
throw new InvalidOperationException(
Strings.ConfigurationSetTwice(configuration.Owner.GetType().Name, _configuration.Value.Owner.GetType().Name));
}
}
public static InternalConfiguration GetInstance()
{
if (Current == null)
{
Current = new InternalConfiguration();
}
return Current;
}
