// This method gets called by the runtime.
public void ConfigureServices(IServiceCollection services)
{
// Add MVC services to the services container.
services.AddMvc();
var d = new ServiceDescriptor(typeof(IUnitOfWork), new UnitOfWork());
services.Add(d);
}
private static Lazy<object> GetLazyForService(IServiceProvider services, ServiceDescriptor descriptor)
{
CryptoUtil.Assert(descriptor != null && descriptor.Lifetime == ServiceLifetime.Singleton, "Descriptor must represent singleton.");
CryptoUtil.Assert(descriptor.ImplementationFactory != null, "Descriptor must have an implementation factory.");
// pull the factory out so we don't close over the whole descriptor instance
Func<IServiceProvider, object> wrapped = descriptor.ImplementationFactory;
return new Lazy<object>(() => wrapped(services));
}
public void CanGenerateFactoryService()
{
var builder = new ContainerBuilder();
var descriptor = new ServiceDescriptor(typeof(IService), typeof(Service), ServiceLifetime.Transient);
builder.Populate(new ServiceDescriptor[] {descriptor});
var container = builder.Build();
container.AssertRegistered<Func<IService>>();
}
/// <summary>
/// Adds warcraft services to the collection
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
public static IServiceCollection AddWarcraft(this IServiceCollection services)
{
if (services == null) throw new ArgumentNullException(nameof(services));
services.TryAddDefaultServices();
var descriptor = new ServiceDescriptor(typeof(WarcraftClient), typeof(WarcraftClient), ServiceLifetime.Scoped);
services.TryAdd(descriptor);
return services;
}
public void CanRegisterFactoryService()
{
var builder = new ContainerBuilder();
var descriptor = new ServiceDescriptor(typeof(IService), sp => new Service(), LifecycleKind.Transient);
builder.Populate(new IServiceDescriptor[] {descriptor});
var container = builder.Build();
container.AssertRegistered<Func<IServiceProvider, IService>>();
}
public void CanRegisterGenericService()
{
var builder = new ContainerBuilder();
var descriptor = new ServiceDescriptor(typeof(IList<>), typeof(List<>), LifecycleKind.Scoped);
builder.Populate(new IServiceDescriptor[] { descriptor });
var container = builder.Build();
container.AssertRegistered<IList<IService>>();
}
/// <summary>
/// Adds <see cref="DefaultRegionSelector"/> to the service collection
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
private static IServiceCollection TryAddDefaultServices(this IServiceCollection services)
{
var descriptor = new ServiceDescriptor(typeof(IRegionSelector), DefaultRegionSelector.DefaultInstance);
services.TryAdd(descriptor);
descriptor = new ServiceDescriptor(typeof(IBattleNetAccessTokenAccessor), typeof(BattleNetAccessTokenAccessor), ServiceLifetime.Scoped);
services.TryAdd(descriptor);
return services;
}
public void CanRegisterSingletonService()
{
var builder = new ContainerBuilder();
var descriptor = new ServiceDescriptor(typeof(IService), typeof(Service), LifecycleKind.Singleton);
builder.Populate(new IServiceDescriptor[] {descriptor});
var container = builder.Build();
container.AssertLifetime<IService, RootScopeLifetime>();
container.AssertSharing<IService>(InstanceSharing.Shared);
container.AssertOwnership<IService>(InstanceOwnership.OwnedByLifetimeScope);
}
public DefaultKeyServices(IServiceProvider services, ServiceDescriptor keyEncryptorDescriptor, ServiceDescriptor keyRepositoryDescriptor)
{
if (keyEncryptorDescriptor != null)
{
// optional
CryptoUtil.Assert(keyEncryptorDescriptor.ServiceType == typeof(IXmlEncryptor), "Bad service type.");
_keyEncryptorLazy = GetLazyForService(services, keyEncryptorDescriptor);
}
CryptoUtil.Assert(keyRepositoryDescriptor.ServiceType == typeof(IXmlRepository), "Bad service type.");
_keyRepositoryLazy = GetLazyForService(services, keyRepositoryDescriptor);
}
/// <summary>
/// Adds warcraft services to the collection
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
public static IServiceCollection AddBattleNetCache(this IServiceCollection services)
{
if (services == null) throw new ArgumentNullException(nameof(services));
services.AddCaching();
services.TryAddDefaultServices();
var descriptor = new ServiceDescriptor(typeof(IBattleNetCache), typeof(BattleNetMemoryCache), ServiceLifetime.Singleton);
services.TryAdd(descriptor);
descriptor = new ServiceDescriptor(typeof(IBattleNetCachePolicy), typeof(AttributesBattleNetCachePolicy), ServiceLifetime.Scoped);
services.TryAdd(descriptor);
return services;
}
public void Add_AddsDescriptorToServiceDescriptors()
{
// Arrange
var serviceCollection = new ServiceCollection();
var descriptor = new ServiceDescriptor(typeof(IFakeService), new FakeService());
// Act
serviceCollection.Add(descriptor);
// Assert
var result = Assert.Single(serviceCollection);
Assert.Same(result, descriptor);
}
public void Add_AddsMultipleDescriptorToServiceDescriptors()
{
// Arrange
var serviceCollection = new ServiceCollection();
var descriptor1 = new ServiceDescriptor(typeof(IFakeService), new FakeService());
var descriptor2 = new ServiceDescriptor(typeof(IFactoryService), typeof(TransientFactoryService), ServiceLifetime.Transient);
// Act
serviceCollection.Add(descriptor1);
serviceCollection.Add(descriptor2);
// Assert
Assert.Equal(2, serviceCollection.Count);
Assert.Equal(new[] { descriptor1, descriptor2 }, serviceCollection);
}
public void ServiceDescriptors_AllowsRemovingPreviousRegisteredServices()
{
// Arrange
var serviceCollection = new ServiceCollection();
var descriptor1 = new ServiceDescriptor(typeof(IFakeService), new FakeService());
var descriptor2 = new ServiceDescriptor(typeof(IFactoryService), typeof(TransientFactoryService), ServiceLifetime.Transient);
// Act
serviceCollection.Add(descriptor1);
serviceCollection.Add(descriptor2);
serviceCollection.Remove(descriptor1);
// Assert
var result = Assert.Single(serviceCollection);
Assert.Same(result, descriptor2);
}
/// <summary>
/// Adds default services to the service collection
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
private static IServiceCollection TryAddDefaultServices(this IServiceCollection services)
{
if (services == null) throw new ArgumentNullException(nameof(services));
services.AddLogging();
services.AddDataProtection();
var descriptor = new ServiceDescriptor(typeof(IAuthenticatorDataRepository), typeof(UserProfileAuthenticatorDataRepository), ServiceLifetime.Scoped);
services.TryAdd(descriptor);
descriptor = new ServiceDescriptor(typeof(IEnrollmentClient), typeof(EnrollmentClient), ServiceLifetime.Scoped);
services.TryAdd(descriptor);
descriptor = new ServiceDescriptor(typeof(IAuthenticator), typeof(Authenticator), ServiceLifetime.Scoped);
services.TryAdd(descriptor);
return services;
}
private static void Register(IUnityContainer container,
ServiceDescriptor descriptor)
{
if (descriptor.ImplementationType != null)
{
container.RegisterType(descriptor.ServiceType,
descriptor.ImplementationType,
GetLifetimeManager(descriptor.Lifetime));
container.RegisterType(descriptor.ServiceType,
descriptor.ImplementationType,
descriptor.ImplementationType.ToString(),
GetLifetimeManager(descriptor.Lifetime));
}
else if (descriptor.ImplementationFactory != null)
{
container.RegisterType(descriptor.ServiceType,
GetLifetimeManager(descriptor.Lifetime),
new InjectionFactory(unity =>
{
var provider = unity.Resolve<IServiceProvider>();
return descriptor.ImplementationFactory(provider);
}));
container.RegisterType(descriptor.ServiceType,
Guid.NewGuid().ToString(),
GetLifetimeManager(descriptor.Lifetime),
new InjectionFactory(unity =>
{
var provider = unity.Resolve<IServiceProvider>();
return descriptor.ImplementationFactory(provider);
}));
}
else if (descriptor.ImplementationInstance != null)
{
container.RegisterInstance(descriptor.ServiceType,
descriptor.ImplementationInstance,
GetLifetimeManager(descriptor.Lifetime));
container.RegisterInstance(descriptor.ServiceType,
Guid.NewGuid().ToString(),
descriptor.ImplementationInstance,
GetLifetimeManager(descriptor.Lifetime));
}
}
private static void Use(GenericFamilyExpression expression, ServiceDescriptor descriptor)
{
if (descriptor.ImplementationFactory != null)
{
expression.Use(Guid.NewGuid().ToString(), context => { return descriptor.ImplementationFactory(context.GetInstance<IServiceProvider>()); });
}
else if (descriptor.ImplementationInstance != null)
{
expression.Use(descriptor.ImplementationInstance);
}
else if (descriptor.ImplementationType != null)
{
expression.Use(descriptor.ImplementationType);
}
else
{
throw new InvalidOperationException("IServiceDescriptor is invalid");
}
}
private void Register(ServiceDescriptor descriptor)
{
if (descriptor.ImplementationType != null)
{
For(descriptor.ServiceType)
.LifecycleIs(descriptor.Lifetime)
.Use(descriptor.ImplementationType);
return;
}
if (descriptor.ImplementationFactory != null)
{
For(descriptor.ServiceType)
.LifecycleIs(descriptor.Lifetime)
.Use(CreateFactory(descriptor));
return;
}
For(descriptor.ServiceType)
.LifecycleIs(descriptor.Lifetime)
.Use(descriptor.ImplementationInstance);
}
// Internal for testing.
internal static void AddXmlSerializerFormatterServices(IServiceCollection services)
{
services.TryAddEnumerable(
ServiceDescriptor.Transient <IConfigureOptions <MvcOptions>, MvcXmlSerializerMvcOptionsSetup>());
}
// This method gets called by the runtime.
public void ConfigureServices(IServiceCollection services)
{
services.Configure<AppSettings>(Configuration.GetSubKey("AppSettings"));
// Add MVC services to the services container.
services.AddMvc();
var d = new ServiceDescriptor(typeof(IUnitOfWork), new UnitOfWork());
services.Add(d);
}
public void TryAddEnumerable_ThrowsWhenAddingIndistinguishableImplementationType(
ServiceDescriptor descriptor,
Type serviceType,
Type implementationType)
{
// Arrange
var collection = new ServiceCollection();
// Act & Assert
ExceptionAssert.ThrowsArgument(
() => collection.TryAddEnumerable(descriptor),
"descriptor",
AbstractionResources.FormatTryAddIndistinguishableTypeToEnumerable(implementationType, serviceType));
}
public void TryAddEnumerable_DoesNotAddDuplicate(
ServiceDescriptor descriptor,
Type expectedServiceType,
Type expectedImplementationType,
ServiceLifetime expectedLifetime)
{
// Arrange
var collection = new ServiceCollection();
collection.TryAddEnumerable(descriptor);
// Act
collection.TryAddEnumerable(descriptor);
// Assert
var d = Assert.Single(collection);
Assert.Equal(expectedServiceType, d.ServiceType);
Assert.Equal(expectedImplementationType, d.GetImplementationType());
Assert.Equal(expectedLifetime, d.Lifetime);
}
public void Replace_ReplacesFirstServiceWithMatchingServiceType()
{
// Arrange
var collection = new ServiceCollection();
var descriptor1 = new ServiceDescriptor(typeof(IFakeService), typeof(FakeService), ServiceLifetime.Transient);
var descriptor2 = new ServiceDescriptor(typeof(IFakeService), typeof(FakeService), ServiceLifetime.Transient);
collection.Add(descriptor1);
collection.Add(descriptor2);
var descriptor3 = new ServiceDescriptor(typeof(IFakeService), typeof(FakeService), ServiceLifetime.Singleton);
// Act
collection.Replace(descriptor3);
// Assert
Assert.Equal(new[] { descriptor2, descriptor3 }, collection);
}
public void Replace_AddsServiceIfServiceTypeIsNotRegistered()
{
// Arrange
var collection = new ServiceCollection();
var descriptor1 = new ServiceDescriptor(typeof(IFakeService), typeof(FakeService), ServiceLifetime.Transient);
var descriptor2 = new ServiceDescriptor(typeof(IFakeOuterService), typeof(FakeOuterService), ServiceLifetime.Transient);
collection.Add(descriptor1);
// Act
collection.Replace(descriptor2);
// Assert
Assert.Equal(new[] { descriptor1, descriptor2 }, collection);
}
public void GetImplementationType_ThrowsForNoImplementationType()
{
// Arrange
var serviceType = typeof(IFakeService);
var collection = new ServiceCollection();
var descriptor = new ServiceDescriptor(serviceType, null);
// Act & Assert
ExceptionAssert.ThrowsArgument(
() => descriptor.GetImplementationType(),
null,
AbstractionResources.FormatNoImplementation(serviceType));
}
public void AddSequence_AddsServicesToCollection()
{
// Arrange
var collection = new ServiceCollection();
var descriptor1 = new ServiceDescriptor(typeof(IFakeService), typeof(FakeService), ServiceLifetime.Transient);
var descriptor2 = new ServiceDescriptor(typeof(IFakeOuterService), typeof(FakeOuterService), ServiceLifetime.Transient);
var descriptors = new[] { descriptor1, descriptor2 };
// Act
var result = collection.Add(descriptors);
// Assert
Assert.Equal(descriptors, collection);
}
public void CanRegisterTransientService()
{
var builder = new ContainerBuilder();
var descriptor = new ServiceDescriptor(typeof(IService), typeof(Service), ServiceLifetime.Transient);
builder.Populate(new ServiceDescriptor[] {descriptor});
var container = builder.Build();
container.AssertLifetime<IService, CurrentScopeLifetime>();
container.AssertSharing<IService>(InstanceSharing.None);
container.AssertOwnership<IService>(InstanceOwnership.OwnedByLifetimeScope);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
var descriptor = new ServiceDescriptor(typeof(IHitCounterService), new HitCounterService(_rootPath));
services.Add(descriptor);
}
/// <summary>
/// Adds default services to the service collection
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
private static void TryAddDefaultServices(this IServiceCollection services)
{
if (services == null) throw new ArgumentNullException(nameof(services));
services.AddLogging();
services.AddOptions();
var descriptor = new ServiceDescriptor(typeof(IRegionSelector), DefaultRegionSelector.DefaultInstance);
services.TryAdd(descriptor);
descriptor = new ServiceDescriptor(typeof(IBattleNetClient), typeof(BattleNetClient), ServiceLifetime.Scoped);
services.TryAdd(descriptor);
descriptor = new ServiceDescriptor(typeof(HttpClient), typeof(HttpClient), ServiceLifetime.Scoped);
services.TryAdd(descriptor);
}
private static long CalculateHash(ServiceDescriptor descriptor)
=> ((((long)descriptor.Lifetime * 397)
^ descriptor.ServiceType.GetHashCode()) * 397)
^ (descriptor.ImplementationInstance
?? descriptor.ImplementationType
?? (object)descriptor.ImplementationFactory).GetHashCode();
public static IdentityBuilder AddIdentity <TUser, TRole>(
this IServiceCollection services,
Action <IdentityOptions> configureOptions)
where TUser : class
where TRole : class
{
// Services used by identity
services.AddOptions();
services.AddDataProtection();
services.AddLogging();
services.TryAdd(ServiceDescriptor.Singleton <IHttpContextAccessor, HttpContextAccessor>());
// Identity services
services.TryAdd(ServiceDescriptor.Transient <IUserValidator <TUser>, UserValidator <TUser> >());
services.TryAdd(ServiceDescriptor.Transient <IPasswordValidator <TUser>, PasswordValidator <TUser> >());
services.TryAdd(ServiceDescriptor.Transient <IPasswordHasher <TUser>, PasswordHasher <TUser> >());
services.TryAdd(ServiceDescriptor.Transient <ILookupNormalizer, UpperInvariantLookupNormalizer>());
services.TryAdd(ServiceDescriptor.Transient <IRoleValidator <TRole>, RoleValidator <TRole> >());
// No interface for the error describer so we can add errors without rev'ing the interface
services.TryAdd(ServiceDescriptor.Transient <IdentityErrorDescriber, IdentityErrorDescriber>());
services.TryAdd(ServiceDescriptor.Scoped <ISecurityStampValidator, SecurityStampValidator <TUser> >());
services.TryAdd(ServiceDescriptor.Scoped <IUserClaimsPrincipalFactory <TUser>, UserClaimsPrincipalFactory <TUser, TRole> >());
services.TryAdd(ServiceDescriptor.Scoped <UserManager <TUser>, UserManager <TUser> >());
services.TryAdd(ServiceDescriptor.Scoped <SignInManager <TUser>, SignInManager <TUser> >());
services.TryAdd(ServiceDescriptor.Scoped <RoleManager <TRole>, RoleManager <TRole> >());
if (configureOptions != null)
{
services.ConfigureIdentity(configureOptions);
}
services.Configure <ExternalAuthenticationOptions>(options =>
{
options.SignInScheme = IdentityOptions.ExternalCookieAuthenticationScheme;
});
// Configure all of the cookie middlewares
services.ConfigureIdentityApplicationCookie(options =>
{
options.AuthenticationScheme = IdentityOptions.ApplicationCookieAuthenticationScheme;
options.AutomaticAuthentication = true;
options.LoginPath = new PathString("/Account/Login");
options.Notifications = new CookieAuthenticationNotifications
{
OnValidatePrincipal = SecurityStampValidator.ValidatePrincipalAsync
};
});
services.Configure <CookieAuthenticationOptions>(options =>
{
options.AuthenticationScheme = IdentityOptions.ExternalCookieAuthenticationScheme;
options.AutomaticAuthentication = false;
options.CookieName = IdentityOptions.ExternalCookieAuthenticationScheme;
options.ExpireTimeSpan = TimeSpan.FromMinutes(5);
}, IdentityOptions.ExternalCookieAuthenticationScheme);
services.Configure <CookieAuthenticationOptions>(options =>
{
options.AuthenticationScheme = IdentityOptions.TwoFactorRememberMeCookieAuthenticationScheme;
options.AutomaticAuthentication = false;
options.CookieName = IdentityOptions.TwoFactorRememberMeCookieAuthenticationScheme;
}, IdentityOptions.TwoFactorRememberMeCookieAuthenticationScheme);
services.Configure <CookieAuthenticationOptions>(options =>
{
options.AuthenticationScheme = IdentityOptions.TwoFactorUserIdCookieAuthenticationScheme;
options.AutomaticAuthentication = false;
options.CookieName = IdentityOptions.TwoFactorUserIdCookieAuthenticationScheme;
options.ExpireTimeSpan = TimeSpan.FromMinutes(5);
}, IdentityOptions.TwoFactorUserIdCookieAuthenticationScheme);
return(new IdentityBuilder(typeof(TUser), typeof(TRole), services));
}
// Adds a service if the service type and implementation type hasn't been added yet. This is needed for
// services like IConfigureOptions<MvcOptions> or IApplicationModelProvider where you need the ability
// to register multiple implementation types for the same service type.
private static bool TryAddMultiRegistrationService(IServiceCollection services, ServiceDescriptor descriptor)
{
// This can't work when registering a factory or instance, you have to register a type.
// Additionally, if any existing registrations use a factory or instance, we can't check those, but we don't
// assert that because it might be added by user-code.
Debug.Assert(descriptor.ImplementationType != null);
if (services.Any(d =>
d.ServiceType == descriptor.ServiceType &&
d.ImplementationType == descriptor.ImplementationType))
{
return false;
}
services.Add(descriptor);
return true;
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
var d = new ServiceDescriptor(typeof(IUnitOfWork), new UnitOfWork());
services.Add(d);
}
