public void Register(SimpleInjector.Container container)
{
container.RegisterSingleton<ISubModerationService, SubModerationService>();
container.RegisterSingleton<ISubModerationDao, SubModerationDao>();
container.RegisterSingleton<IReportService, ReportService>();
container.RegisterSingleton<IReportDao, ReportDao>();
container.RegisterSingleton<ISubActivityService, SubActivityService>();
container.RegisterSingleton<ISubActivityDao, SubActivityDao>();
container.RegisterSingleton<ISubUserBanService, SubUserBanService>();
container.RegisterSingleton<ISubUserBanDao, SubUserBanDao>();
container.RegisterSingleton<ISubService, SubService>();
container.RegisterSingleton<ISubDao, SubDao>();
container.RegisterSingleton<IPostService, PostService>();
container.RegisterSingleton<IPostDao, PostDao>();
container.RegisterSingleton<IVoteService, VoteService>();
container.RegisterSingleton<IVoteDao, VoteDao>();
container.RegisterSingleton<ICommentService, CommentService>();
container.RegisterSingleton<ICommentDao, CommentDao>();
container.RegisterSingleton<IPermissionService, PermissionService>();
container.RegisterSingleton<IPermissionDao, PermissionDao>();
container.RegisterSingleton<IMessageService, MessageService>();
container.RegisterSingleton<IMessageDao, MessageDao>();
container.RegisterSingleton<ICommentTreeBuilder, CommentTreeBuilder>();
container.RegisterSingleton<ICommentTreeContextBuilder, CommentTreeContextBuilder>();
container.RegisterSingleton<ICommentNodeHierarchyBuilder, CommentNodeHierarchyBuilder>();
container.RegisterSingleton<ICommentWrapper, CommentWrapper>();
container.RegisterSingleton<IPostWrapper, PostWrapper>();
container.RegisterSingleton<ISubWrapper, SubWrapper>();
container.RegisterSingleton<ISubUserBanWrapper, SubUserBanWrapper>();
container.RegisterSingleton<IMessageWrapper, MessageWrapper>();
container.RegisterSingleton<IModeratorWrapper, ModeratorWrapper>();
}
public void ShouldReturnNullIfNothingIsFoundForTheGivenType()
{
var container = new SimpleInjector();
var shouldNotExist = container.FindByType <House>();
Assert.Null(shouldNotExist);
}
public void Register(SimpleInjector.Container container)
{
container.RegisterSingle<ISubService, SubService>();
container.RegisterSingle<ISubDao, SubDao>();
container.RegisterSingle<IPostService, PostService>();
container.RegisterSingle<IPostDao, PostDao>();
}
public static void Main()
{
SimpleInjector injector = new SimpleInjector();
injector.Store(Console.Out, typeof(TextWriter));
injector.Store(Console.In, typeof(TextReader));
injector.Configure <ListTicketsScreen>();
injector.Configure <AddTicketScreen>();
injector.Configure <EditTicketScreen>();
injector.Configure <RemoveTicketScreen>();
injector.Store(new List <IScreen>
{
injector.FindByType <ListTicketsScreen>(),
injector.FindByType <AddTicketScreen>(),
injector.FindByType <EditTicketScreen>(),
injector.FindByType <RemoveTicketScreen>()
}, typeof(ICollection <IScreen>));
injector.Configure <ScreenManager>();
var screenManager = injector.FindByType <ScreenManager>();
screenManager.StartInputOutputLoop().Wait();
}
public void Resolve_ConstructorHasValueDependency_DependencyResolved()
{
SimpleInjector simpleInjector = new SimpleInjector();
TestClassValueParameter result = simpleInjector.Resolve <TestClassValueParameter>();
Assert.IsNotNull(result);
}
public void RegisterSingleInstance_TypeProvided_SingleInstanceRegistered()
{
SimpleInjector simpleInjector = new SimpleInjector();
simpleInjector.RegisterSingleInstance <TestClass>();
Assert.AreEqual(simpleInjector.Resolve <TestClass>(), simpleInjector.Resolve <TestClass>());
}
public void Register_ImplementationTypeProvided_InterfaceResolved()
{
SimpleInjector simpleInjector = new SimpleInjector();
simpleInjector.Register <ITestClass, TestClass>();
Assert.IsNotNull(simpleInjector.Resolve <ITestClass>());
}
public void RegisterServices(SimpleInjector.Container container)
{
container.Register<ThemeService>();
container.Register<ICartService, CartService>();
container.Register<IPageService, PageService>();
container.Register<ITaxService, TaxService>();
container.Register<IShippingService, ShippingService>();
container.Register<IProductService, ProductService>();
}
public void RegisterSingleInstance_InstanceProvided_SingleInstanceRegistered()
{
TestClass singleton = new TestClass(16);
SimpleInjector simpleInjector = new SimpleInjector();
simpleInjector.RegisterSingleInstance(singleton);
Assert.AreEqual(singleton, simpleInjector.Resolve <TestClass>());
}
public void ShouldSkipReadOnlyPropertiesAndNotThrowException()
{
var container = new SimpleInjector();
container.Configure <ReadOnlyFoo>();
var actualInstance = container.FindByType <ReadOnlyFoo>();
Assert.Null(actualInstance.Window);
}
public void ShouldStoreInstancesCreatedForProperties()
{
var container = new SimpleInjector();
container.Configure <House>();
var actualInstance = container.FindByType <Room>();
Assert.NotNull(actualInstance);
}
public void Constructor_InjectorWithImplementationMapProvided_ImplementationMapCopied()
{
SimpleInjector simpleInjector = new SimpleInjector();
simpleInjector.Register <ITestClass, TestClass>();
SimpleInjector simpleInjectorCopy = new SimpleInjector(simpleInjector);
Assert.IsNotNull(simpleInjectorCopy.Resolve <ITestClass>());
}
public void ShouldRecursivelyConfigureProperties()
{
var container = new SimpleInjector();
container.Configure <House>();
Window window = container.FindByType <House>().Room.Window;
Assert.NotNull(window);
}
public void ShouldNotAutomaticallyConfigureDotNetTypedDependenciesIfNoMatchesAreAvailable()
{
var container = new SimpleInjector();
container.Configure <Block>();
var block = container.FindByType <Block>();
Assert.Null(block.Houses);
}
public void Resolve_ClassHasRegisteredSetterDependency_DependencyResolved()
{
SimpleInjector simpleInjector = new SimpleInjector();
simpleInjector.Register <ITestClass, TestClass>();
TestClassSetter result = simpleInjector.Resolve <TestClassSetter>();
Assert.IsNotNull(result);
}
public void Constructor_InjectorWithControlledLifetimeTypesProvided_ControlledLifetimeTypesCopied()
{
SimpleInjector simpleInjector = new SimpleInjector();
simpleInjector.RegisterSingleInstance <TestClass>();
SimpleInjector simpleInjectorCopy = new SimpleInjector(simpleInjector);
Assert.AreEqual(simpleInjectorCopy.Resolve <TestClass>(), simpleInjectorCopy.Resolve <TestClass>());
}
public void ShouldCreateAnInstanceAndRetrieveByType()
{
var container = new SimpleInjector();
container.Configure <House>();
var actualInstance = container.FindByType <House>();
Assert.NotNull(actualInstance);
}
private static void SampleCommandHandlerWithInstance()
{
var injector = new SimpleInjector();
var commandBus = new CommandBus(injector);
commandBus.RegisterInstance(new ConsoleLogHandler());
var command = new TestCommand("srnlib");
commandBus.Handle(command);
}
public void ShouldStoreByTypeIfASpecificTypeIsProvided()
{
var container = new SimpleInjector();
Cat cat = new Cat();
container.Store(cat, typeof(Animal));
var catFromStore = container.FindByType <Animal>();
Assert.Same(cat, catFromStore);
}
public void Constructor_InjectorWithInstanceMapProvided_InstanceMapCopied()
{
TestClass singleton = new TestClass(16);
SimpleInjector simpleInjector = new SimpleInjector();
simpleInjector.RegisterSingleInstance(singleton);
SimpleInjector simpleInjectorCopy = new SimpleInjector(simpleInjector);
Assert.AreEqual(singleton, simpleInjectorCopy.Resolve <TestClass>());
}
public void ShouldStoreAPreBakedObjectWithoutConfiguringItsDependencies()
{
var container = new SimpleInjector();
var house = new House();
container.Store(house);
var houseFromContainer = container.FindByType <House>();
Assert.NotNull(houseFromContainer);
Assert.Null(house.Room);
}
public void ShouldCreateOneInstanceAndShareItWithOtherConfiguredObjects()
{
var container = new SimpleInjector();
container.Configure <House>();
container.Configure <Office>();
Room houseRoom = container.FindByType <House>().Room;
Room officeRoom = container.FindByType <Office>().ConferenceRoom;
Assert.Same(houseRoom, officeRoom);
}
public void ShouldStoreAndLoadCollectionTypes()
{
var container = new SimpleInjector();
var houses = new List <House> {
new House(), new House(), new House()
};
container.Store(houses);
var housesFromStore = container.FindByType <List <House> >();
Assert.Same(houses, housesFromStore);
}
private static void SampleQueryHandlerWithInstance()
{
var injector = new SimpleInjector();
var queryBus = new QueryBus(injector);
queryBus.RegisterInstance(new TestQueryHandler());
var query = new TestQuery("srn");
var response = queryBus.Handle(query);
Console.WriteLine(response.Message);
}
private static void InitDIMappingsViaReflection(SimpleInjector.Container container)
{
//Idee: Wir laden alle DLLs aus unserem Ordner, deren Dateiname mit IwAutoUpdater startet und nicht mit .Test endet
//Anschließend gehen wir durch alle .Contracts-DLLs durch und suchen uns die Public Interfaces
//Dann gehen wir durch die Implementierungs-DLLs durch und suchen für jede Klasse durch, ob deren Interfaces in den Public Interfaces der Contracts sind. Falls ja -> Registrieren
Queue<Assembly> contractAssemblies, implementationAssemblies;
LadeDlls(out contractAssemblies, out implementationAssemblies);
HashSet<Type> interfaces = ErmittleZuImplementierendeInterfaces(contractAssemblies);
RegistriereImplementierungenZuInterfaces(container, implementationAssemblies, interfaces);
}
public static void RegisterServices(SimpleInjector.Container container)
{
container.Register<ApplicationUserContext>(Lifestyle.Scoped);
container.RegisterPerWebRequest<IUserStore<ApplicationUser>>(() => new UserStore<ApplicationUser>(new ApplicationUserContext()));
container.Register<ApplicationUserManager>(Lifestyle.Scoped);
container.Register<ApplicationSignInManager>(Lifestyle.Scoped);
container.Register<ITransportadoraAppService, TransportadoraAppService>();
container.Register<ITransportadoraService, TransportadoraService>();
container.Register<ITransportadoraRepository, TransportadoraRepository>();
container.Register<IDbContext, TesteAxadoContext>();
}
private static void SampleCommandHandler()
{
var injector = new SimpleInjector();
injector.Register <ICommandHandler <TestCommand> >(() => new ConsoleLogHandler());
var commandBus = new CommandBus(injector);
commandBus.Register <TestCommand, ICommandHandler <TestCommand> >();
var command = new TestCommand("srnlib");
commandBus.Handle(command);
}
public void ShouldDoNothingIfMoreThanOneAttemptIsMadeToCreateAnInstance()
{
var container = new SimpleInjector();
container.Configure <House>();
var house = container.FindByType <House>();
container.Configure <House>();
var secondHouse = container.FindByType <House>();
Assert.Same(house, secondHouse);
}
private static void SampleQueryHandler()
{
var injector = new SimpleInjector();
injector.Register <IQueryHandler <TestQuery, TestResponse> >(() => new TestQueryHandler());
var queryBus = new QueryBus(injector);
queryBus.Register <TestQuery, IQueryHandler <TestQuery, TestResponse> >();
var query = new TestQuery("srn");
var response = queryBus.Handle(query);
Console.WriteLine(response.Message);
}
public void ShouldConfigureDotNetTypesIfAndOnlyIfAMatchIsAvailable()
{
var container = new SimpleInjector();
var houses = new List <House> {
new House(), new House(), new House()
};
container.Store(houses);
container.Configure <Block>();
var block = container.FindByType <Block>();
Assert.Same(houses, block.Houses);
}
public void Register(SimpleInjector.Container container)
{
container.RegisterSingle<ISubUserBanService, SubUserBanService>();
container.RegisterSingle<ISubUserBanDao, SubUserBanDao>();
container.RegisterSingle<ISubService, SubService>();
container.RegisterSingle<ISubDao, SubDao>();
container.RegisterSingle<IPostService, PostService>();
container.RegisterSingle<IPostDao, PostDao>();
container.RegisterSingle<IVoteService, VoteService>();
container.RegisterSingle<IVoteDao, VoteDao>();
container.RegisterSingle<ICommentService, CommentService>();
container.RegisterSingle<ICommentDao, CommentDao>();
container.RegisterSingle<IPermissionService, PermissionService>();
container.RegisterSingle<IPermissionDao, PermissionDao>();
container.RegisterSingle<ICommentTreeBuilder, CommentTreeBuilder>();
container.RegisterSingle<ICommentTreeContextBuilder, CommentTreeContextBuilder>();
container.RegisterSingle<ICommentNodeHierarchyBuilder, CommentNodeHierarchyBuilder>();
container.RegisterSingle<ICommentWrapper, CommentWrapper>();
container.RegisterSingle<IPostWrapper, PostWrapper>();
container.RegisterSingle<ISubWrapper, SubWrapper>();
container.RegisterSingle<ISubUserBanWrapper, SubUserBanWrapper>();
}
public void Register_ImplementationTypeNotProvided_ThrowsArgumentException()
{
SimpleInjector simpleInjector = new SimpleInjector();
simpleInjector.Resolve <ITestClass>();
}
private static void RegistriereImplementierungenZuInterfaces(SimpleInjector.Container container, Queue<Assembly> implementationAssemblies, HashSet<Type> interfaces)
{
var interfaceByNameComparer = new CrossCutting.SFW.EqualityComparerDefault<Type>((left, right) => left.Name == right.Name);
foreach (var impl in implementationAssemblies)
{
var exportedTypesWithInterfaces = impl.GetExportedTypes().Where(a => a.GetInterfaces().Any());
foreach (var etwi in exportedTypesWithInterfaces)
{
foreach (var iface in etwi.GetInterfaces().Where(i => interfaces.Contains(i, interfaceByNameComparer)))
{
Lifestyle registerAsLifestyle = null;
if (iface.IsDefined(typeof(DIAsTransientAttribute)))
{
registerAsLifestyle = Lifestyle.Transient;
}
else if (iface.IsDefined(typeof(DIAsSingletonAttribute)))
{
registerAsLifestyle = Lifestyle.Singleton;
}
else
{
// unser Standardverhalten, wenn gar nichts angegeben ist, ist "Singleton",
// weil das bei meiner Implementierung 95% der Fälle abdeckt
registerAsLifestyle = Lifestyle.Singleton;
}
container.Register(iface, etwi, registerAsLifestyle);
}
}
}
}
/// <summary>
/// Loads the module into the kernel.
/// </summary>
public void RegisterComponents(SimpleInjector.Container container)
{
IConfiguration configuration = new Configuration();
container.Register<IConfiguration>(() => configuration, Lifestyle.Singleton);
Lazy<GallerySetting> gallerySetting = new Lazy<GallerySetting>(() =>
{
using (var entitiesContext = new EntitiesContext())
{
var settingsRepo = new EntityRepository<GallerySetting>(entitiesContext);
return settingsRepo.GetAll().FirstOrDefault();
}
});
container.Register<GallerySetting>(()=> gallerySetting.Value);
//Bind<GallerySetting>().ToMethod(c => gallerySetting.Value);
container.RegisterPerWebRequest<ISearchService, LuceneSearchService>();
container.RegisterPerWebRequest<IEntitiesContext>(() => new EntitiesContext());
container.RegisterPerWebRequest<IEntityRepository<User>, EntityRepository<User>>();
container.RegisterPerWebRequest<IEntityRepository<PackageRegistration>, EntityRepository<PackageRegistration>>();
container.RegisterPerWebRequest<IEntityRepository<Package>, EntityRepository<Package>>();
container.RegisterPerWebRequest<IEntityRepository<PackageAuthor>, EntityRepository<PackageAuthor>>();
container.RegisterPerWebRequest<IEntityRepository<PackageFramework>, EntityRepository<PackageFramework>>();
container.RegisterPerWebRequest<IEntityRepository<PackageDependency>, EntityRepository<PackageDependency>>();
container.RegisterPerWebRequest<IEntityRepository<PackageFile>, EntityRepository<PackageFile>>();
container.RegisterPerWebRequest<IEntityRepository<PackageStatistics>, EntityRepository<PackageStatistics>>();
container.RegisterPerWebRequest<IEntityRepository<PackageOwnerRequest>, EntityRepository<PackageOwnerRequest>>();
container.RegisterPerWebRequest<IUserService, UserService>();
container.RegisterPerWebRequest<IPackageService, PackageService>();
container.RegisterPerWebRequest<ICryptographyService, CryptographyService>();
container.Register<IFormsAuthenticationService, FormsAuthenticationService>(Lifestyle.Singleton);
container.RegisterPerWebRequest<IControllerFactory, NuGetControllerFactory>();
container.RegisterPerWebRequest<IIndexingService, LuceneIndexingService>();
container.RegisterPerWebRequest<INuGetExeDownloaderService, NuGetExeDownloaderService>();
Lazy<IMailSender> mailSenderThunk = new Lazy<IMailSender>(() =>
{
var settings = container.GetInstance<GallerySetting>();
if (settings.UseSmtp)
{
var mailSenderConfiguration = new MailSenderConfiguration()
{
DeliveryMethod = SmtpDeliveryMethod.Network,
Host = settings.SmtpHost,
Port = settings.SmtpPort,
EnableSsl = configuration.SmtpEnableSsl,
};
if (!String.IsNullOrWhiteSpace(settings.SmtpUsername))
{
mailSenderConfiguration.UseDefaultCredentials = false;
mailSenderConfiguration.Credentials = new NetworkCredential(
settings.SmtpUsername,
settings.SmtpPassword);
}
return new NuGetGallery.MailSender(mailSenderConfiguration);
}
else
{
var mailSenderConfiguration = new MailSenderConfiguration()
{
DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
PickupDirectoryLocation = HostingEnvironment.MapPath("~/App_Data/Mail")
};
return new NuGetGallery.MailSender(mailSenderConfiguration);
}
});
container.Register<IMailSender>(()=> mailSenderThunk.Value,Lifestyle.Singleton);
container.Register<IMessageService, MessageService>(Lifestyle.Singleton);
container.RegisterPerWebRequest<IPrincipal>(() => HttpContext.Current.User);
//Bind<IPrincipal>().ToMethod(context => HttpContext.Current.User);
switch (configuration.PackageStoreType)
{
case PackageStoreType.FileSystem:
case PackageStoreType.NotSpecified:
container.Register<IFileSystemService, FileSystemService>(Lifestyle.Singleton);
container.Register<IFileStorageService, FileSystemFileStorageService>(Lifestyle.Singleton);
break;
case PackageStoreType.AzureStorageBlob:
container.Register<ICloudBlobClient>(() => new CloudBlobClientWrapper(new CloudBlobClient(
new Uri(configuration.AzureStorageBlobUrl, UriKind.Absolute),
new StorageCredentialsAccountAndKey(configuration.AzureStorageAccountName, configuration.AzureStorageAccessKey)
))
,Lifestyle.Singleton);
container.Register<IFileStorageService, CloudBlobFileStorageService>(Lifestyle.Singleton);
break;
case PackageStoreType.AmazonS3Storage:
container.Register<IAmazonS3Client, AmazonS3ClientWrapper>(Lifestyle.Singleton);
container.Register<IFileStorageService, AmazonS3FileStorageService>(Lifestyle.Singleton);
break;
}
container.Register<IPackageFileService, PackageFileService>(Lifestyle.Singleton);
container.Register<IUploadFileService, UploadFileService>();
// todo: bind all package curators by convention
container.Register<IAutomaticPackageCurator, WebMatrixPackageCurator>(Lifestyle.Singleton);
container.Register<IAutomaticPackageCurator, Windows8PackageCurator>(Lifestyle.Singleton);
// todo: bind all commands by convention
container.RegisterPerWebRequest<IAutomaticallyCuratePackageCommand, AutomaticallyCuratePackageCommand>();
container.RegisterPerWebRequest<ICreateCuratedPackageCommand, CreateCuratedPackageCommand>();
container.RegisterPerWebRequest<IDeleteCuratedPackageCommand, DeleteCuratedPackageCommand>();
container.RegisterPerWebRequest<IModifyCuratedPackageCommand, ModifyCuratedPackageCommand>();
// todo: bind all queries by convention
container.RegisterPerWebRequest<ICuratedFeedByKeyQuery, CuratedFeedByKeyQuery>();
container.RegisterPerWebRequest<ICuratedFeedByNameQuery, CuratedFeedByNameQuery>();
container.RegisterPerWebRequest<ICuratedFeedsByManagerQuery, CuratedFeedsByManagerQuery>();
container.RegisterPerWebRequest<IPackageRegistrationByKeyQuery, PackageRegistrationByKeyQuery>();
container.RegisterPerWebRequest<IPackageRegistrationByIdQuery, PackageRegistrationByIdQuery>();
container.RegisterPerWebRequest<IUserByUsernameQuery, UserByUsernameQuery>();
container.RegisterPerWebRequest<IPackageIdsQuery, PackageIdsQuery>();
container.RegisterPerWebRequest<IPackageVersionsQuery, PackageVersionsQuery>();
container.RegisterPerWebRequest<IAggregateStatsService, AggregateStatsService>();
RegisterChocolateySpecific(container);
}
private static void InitializeContainer(SimpleInjector.Container container)
{
BootStrapper.RegisterServices(container);
}
void IInitializeMapping.Init(SimpleInjector.Container container)
{
container.RegisterSingleton<IMessagingClient, IrcMessagingClient>();
}
public void Resolve_DependencyPropertyHasNoSetter_ThrowsMissingMethodException()
{
SimpleInjector simpleInjector = new SimpleInjector();
TestClassNoSetter result = simpleInjector.Resolve <TestClassNoSetter>();
}
private static void InitCrossCutting(SimpleInjector.Container container)
{
(new CrossCuttingMappings() as IInitializeMapping).Init(container);
}
void IInitializeMapping.Init(SimpleInjector.Container container)
{
container.RegisterSingleton<ILogging, Logging.Logging>();
container.RegisterSingleton<IConfiguration, HardcodedConfiguration>();
}
private static void InitializeContainer(Container container)
{
SimpleInjector.Register(container);
}
private static void InitializeContainer(SimpleInjector.Container container)
{
var binding = new ContainerBinding();
binding.RegisterComponents(container);
}
public void Resolve_NoPublicConstructor_ThrowsEntryPointNotFoundException()
{
SimpleInjector simpleInjector = new SimpleInjector();
TestClassNoPublicConstructor result = simpleInjector.Resolve <TestClassNoPublicConstructor>();
}
public void Resolve_SimpleInjectorTypeProvided_ExistingInstanceReturned()
{
SimpleInjector simpleInjector = new SimpleInjector();
Assert.AreEqual(simpleInjector, simpleInjector.Resolve <SimpleInjector>());
}
public void Register(SimpleInjector.Container container)
{
container.RegisterSingle<IEventHandlerRegistry, EventHandlerRegistry>();
container.RegisterSingle<ICommandHandlerRegistry, CommandHandlerRegistry>();
}
public void Register(SimpleInjector.Container container)
{
container.RegisterSingleton<IEventDiscovery, EventDiscovery>();
container.RegisterSingleton<ICommandDiscovery, CommandDiscovery>();
}
private static void InitDAL(SimpleInjector.Container container)
{
(new DAL.MessagingMappings() as IInitializeMapping).Init(container);
}
private void RegisterChocolateySpecific(SimpleInjector.Container container)
{
container.RegisterPerWebRequest<IUserSiteProfilesService, UserSiteProfilesService>();
container.RegisterPerWebRequest<IEntityRepository<UserSiteProfile>, EntityRepository<UserSiteProfile>>();
}
internal static void InsertIn(SimpleInjector.Container c)
{
c.Register<SheetEntryRepository>();
c.Register<CategoryRepository>();
c.Register<SheetRepository>();
c.Register<AppOwnerRepository>();
}
protected override void RegisterPlatformSpecificImplementations (SimpleInjector.Container container)
{
container.Register<ISettingsService, SettingsService>();
container.Register<IDisplayAlertService, DisplayAlertService> ();
}
public void Register(SimpleInjector.Container container)
{
}
public void Register(SimpleInjector.Container container)
{
container.RegisterSingleton(typeof (ISettingsProvider<>), typeof (JsonFileSettingsProvider<>));
}
public void RegisterServices(SimpleInjector.Container container)
{
//container.Register<ILehrerRepository, LehrerRepository>();
container.RegisterSingle<Uri>(new Uri(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Themes")));
}
