C# Funq.RegisterValidators方法代码示例

        public override void Configure(Funq.Container container)
        {
            //Set JSON web services to return idiomatic JSON camelCase properties
            ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;

            ApiRegistration.Register(Routes);

            //Change the default ServiceStack configuration
            SetConfig(new EndpointHostConfig
            {
                DebugMode = true, //Show StackTraces in responses in development

                //enable CORS
                GlobalResponseHeaders = {	{ "Access-Control-Allow-Origin", "*" },
                                            { "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
                                            { "Access-Control-Allow-Headers", "Content-Type" },
                                        }

            });

            Plugins.Add(new ValidationFeature());

            container.RegisterValidators(typeof(ApplicationRequestValidator).Assembly);

            Plugins.Add(new RequestLogsFeature());

            //Register In-Memory Cache provider.
            //For Distributed Cache Providers Use: PooledRedisClientManager, BasicRedisClientManager or see: https://github.com/ServiceStack/ServiceStack/wiki/Caching
            container.Register<ICacheClient>(new MemoryCacheClient());

            //Set MVC to use the same Funq IOC as ServiceStack
            ServiceRegistration.RegisterAllContainers(container);
        }

        public override void Configure(Funq.Container container)
        {
            //Resource manager
            container.Register<IResourceManager>(new ConfigurationResourceManager());
            var appSettings = container.Resolve<IResourceManager>();

            Plugins.Add(new SessionFeature());

            string redis = appSettings.GetString("redis_connection_string");
            container.Register<IRedisClientsManager>(c => new BasicRedisClientManager(redis));

            // Register storage for user sessions 
            container.Register<ICacheClient>(c => c.Resolve<IRedisClientsManager>().GetCacheClient()).ReusedWithin(Funq.ReuseScope.None);
            container.Register<ISessionFactory>(c => new SessionFactory(c.Resolve<ICacheClient>()));

            // Set JSON web services to return idiomatic JSON camelCase properties
            ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;

            // Validation
            Plugins.Add(new ValidationFeature());
            container.RegisterValidators(typeof(Namespace_ApiProject).Assembly);

            Plugins.Add(new AuthFeature(() => new CustomUserSession(),
                                        new IAuthProvider[]
                                        {
                                            new FbOAuth2Provider(appSettings),
                                            new VkOAuth2Provider(appSettings),
                                        }));
            
            //container.Register<ICacheClient>(new MemoryCacheClient());
            Plugins.Add(new ServiceStack.Api.Swagger.SwaggerFeature());

            container.Adapter = new StructureMapContainerAdapter();
        }

        public override void Configure(Funq.Container container)
        {
            //Set JSON web services to return idiomatic JSON camelCase properties
            ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;

            container.Register<ICacheClient>(new MemoryCacheClient());
            container.Register<IDbConnectionFactory>(
                new OrmLiteConnectionFactory(ConfigurationManager.ConnectionStrings["Db"].ToString(), SqlServerDialect.Provider));

            Plugins.Add(new ValidationFeature());
            container.RegisterValidators(typeof(MeetingValidator).Assembly);

            //https://github.com/ServiceStack/ServiceStack/wiki/Authentication-and-authorization#userauth-persistence---the-iuserauthrepository
            //Use ServiceStacks authentication/authorization persistence

            var userRep = new OrmLiteAuthRepository(container.Resolve<IDbConnectionFactory>());
            container.Register<IUserAuthRepository>(userRep);
            userRep.CreateMissingTables(); //Create missing Auth

            var appSettings = new AppSettings();
            Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[]
                {
                    new CredentialsAuthProvider(),
                    new GoogleOpenIdOAuthProvider(appSettings),
                }));

            Plugins.Add(new RegistrationFeature());

            //Set MVC to use the same Funq IOC as ServiceStack
            ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container));
        }

            public override void Configure(Funq.Container container)
            {
                //register any dependencies your services use, e.g:
                //container.Register<ICacheClient>(new MemoryCacheClient());

                //register the routes, can be in the configure of the asax too
                //Routes.Add<HelloWorld>("/Path");

                //Add the auth feature
                Plugins.Add(new AuthFeature(
                    () => new AuthUserSession(),
                    new IAuthProvider[] {new BasicAuthProvider()}));

                //Register the Validation Plugin
                Plugins.Add(new ValidationFeature());
                container.RegisterValidators(typeof(UnitSoldService).Assembly);

                //Register users
                Plugins.Add(new RegistrationFeature());

                //Add the cache container for the auth
                //container.Register<ICacheClient>(new MemoryCacheClient());

                //Caching with Redis
                //container.Register<IRedisClientsManager>(c => new PooledRedisClientManager());
                //container.Register<ICacheClient>(c => (ICacheClient) c.Resolve<IRedisClientsManager>().GetCacheClient());

                //Defines the user repository
                var userRepository =  new InMemoryAuthRepository();
                container.Register<IUserAuthRepository>(userRepository);

                //Add User

                //create hash and salt from password
                string hash;
                string salt;
                const string password = "password";
                new SaltedHash().GetHashAndSaltString(password, out hash, out salt);

                userRepository.CreateUserAuth(new UserAuth
                    {
                        Id = 1,
                        DisplayName = "Rafael",
                        Email = "[email protected]",
                        UserName = "rafael",
                        FirstName = "Rafael",
                        LastName = "Miceli",
                        Roles = new List<string> {RoleNames.Admin},
                        //Permissions = new List<string>{"GetStatus"},
                        PasswordHash = hash,
                        Salt = salt
                    }, password);

                //var dbConnectionFactory =
                //    new OrmLiteConnectionFactory(HttpContext.Current.Server.MapPath("~/App_Data/data.txt"), true, SqliteDialect.Provider);

                //container.Register<IDbConnectionFactory>(dbConnectionFactory);

                //container.RegisterAutoWired<UnitsRepository>();
            }

        public override void Configure(Funq.Container container)
        {
            container.RegisterAutoWired<PlayersRepository>();

            Plugins.Add(new ValidationFeature());

            container.RegisterValidators(typeof(AppHost).Assembly);
        }

        public override void Configure(Funq.Container container)
        {
            container.RegisterAutoWiredAs<RegistrationRepository, IRegistrationRepository>();
            container.RegisterAutoWiredAs<GuidFactory, IGuidFactory>();

            Plugins.Add(new ValidationFeature());
            container.RegisterValidators(typeof (Global).Assembly);
        }

        public override void Configure(Funq.Container container)
        {
            //Set JSON web services to return idiomatic JSON camelCase properties
            JsConfig.EmitCamelCaseNames = true;

            //Register Typed Config some services might need to access
            var appConfig = new AppConfig(new AppSettings());

            //appconfig will contain properties from web.config
            container.Register(appConfig);

            //inform api that this will be using BasicAuth to authenticate/authorize users
            Plugins.Add(new AuthFeature(
                () => new AuthUserSession(),
                new IAuthProvider[] { new BasicAuthProvider(), }));

            //add registration functionality (user will need admin role to access this)
            Plugins.Add(new RegistrationFeature());

            //add validation using fluent validation package
            Plugins.Add(new ValidationFeature());

            //register service to validate
            container.RegisterValidators(typeof(AwardService).Assembly);

            if (appConfig.UseRedis){
                //setup cache client to user redis
                container.Register<IRedisClientsManager>(c => new PooledRedisClientManager(appConfig.RedisReadWriteHosts.ToArray()));
                container.Register<ICacheClient>(c => c.Resolve<IRedisClientsManager>().GetCacheClient());

                //setup redis for authentication repository
                container.Register<IUserAuthRepository>(c => new RedisAuthRepository(c.Resolve<IRedisClientsManager>()));
            }
            else
            {
                //setup cache client to be InMemory
                container.Register<ICacheClient>(c => new MemoryCacheClient());

                //setup authentication repository to be InMemory
                container.Register<IUserAuthRepository>(c => new InMemoryAuthRepository());
            }
            

            //seed possible users
            SeedUsers(container.Resolve<IUserAuthRepository>());

            //register any repository classes here
            container.RegisterAutoWired<AwardRepository>();
        }

        public override void Configure(Funq.Container container)
        {
            ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
            ServiceStack.Text.JsConfig.IncludeNullValues = true;
            ServiceStack.Logging.LogManager.LogFactory = new NLogFactory();

            Plugins.Add(new RazorFormat { LoadFromAssemblies = new List<Assembly> { typeof(AppHost).Assembly } });
            Plugins.Add(new ValidationFeature());

            container.RegisterValidators(typeof(AppHost).Assembly);

            this.PreRequestFilters.Add((request, response) => Log.Info(request.AbsoluteUri));
            this.GlobalRequestFilters.Add((request, response, dto) => Log.Info(request));

            RewriteReturnVoidToNoContent();
        }

        public override void Configure(Funq.Container container)
        {
            RequestBinders.Clear();

            JsConfig.EmitCamelCaseNames = true;
            JsConfig.IncludeNullValues = true;
            JsConfig.DateHandler = JsonDateHandler.ISO8601;

            Plugins.Add(new ValidationFeature());

            // Add custom request filter
            RequestFilters.Add(GetRequestProcessor.DeserializeJsonFromGet);

            container.Adapter = new AutofacContainerAdapter(containerProvider);
            container.RegisterValidators(typeof(GetTagRequestValidator).Assembly);
        }

        public override void Configure(Funq.Container container)
        {
            Routes.Add<Resorts.ResortsRequest>("/api/resorts", "GET")
                  .Add<Resorts.Resort>("/api/resort", "GET,POST,PUT,DELETE")
                  .Add<Track>("/api/track", "GET,POST,PUT,DELETE")
                  .Add<Track>("/api/track/{Id}", "GET")
                  .Add<TracksRequest>("/api/resort/{ResortId}/tracks", "GET")
                  .Add<MapRequest>("/api/resort/{ResortId}/maps", "GET")
                  .Add<Map>("/api/map", "GET,POST,PUT,DELETE")
                  .Add<Map>("/api/map/{Id}", "GET");

            //LogManager.LogFactory = new Log4NetFactory(true);
            LogManager.LogFactory = new ServiceStack.Logging.Support.Logging.ConsoleLogFactory();

            //container.Register<ServiceStack.CacheAccess.ICacheClient>(new MemoryCacheClient());
            container.Register<IRedisClientsManager>(new PooledRedisClientManager("localhost"));
            container.Register<ServiceStack.CacheAccess.ICacheClient>(c =>(ICacheClient)c.Resolve<IRedisClientsManager>().GetCacheClient());
            container.Register<ILog>(x => LogManager.GetLogger(GetType()));

            Plugins.Add(new RequestLogsFeature());
            Plugins.Add(new ValidationFeature());

            container.RegisterValidators(Assembly.GetCallingAssembly());
        }

            /// <summary>
            /// The Configure method of the HelloAppHost is the central IoC container location.
            /// All configured services, plugins and resources are centrally managed from here.
            /// </summary>
            /// <param name="container"></param>
            public override void Configure(Funq.Container container)
            {
                string soon = DateTime.Now.AddSeconds(10).ToUniversalTime().ToString("ddd, dd MMM yyyy HH:mm:ss 'GMT'");
                SetConfig(new EndpointHostConfig
                {
                    GlobalResponseHeaders = {
                         { "Access-Control-Allow-Origin", "*" },
                         { "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
                         { "Access-Control-Allow-Headers", "Content-Type" },
                 { "Cache-Control", "no-cache, no-store, must-revalidate"},
                 { "Pragma", "no-cache"},
                 { "Expires", "0"},
                         { "X-Powered-On", Environment.MachineName}
                    },
                    DefaultContentType = "application/json"
                });

                // Auto Add all Routes
                Routes.AddFromAssembly(typeof(Person).Assembly);

                // Fluent Validation
                Plugins.Add(new ValidationFeature());
                container.RegisterValidators(typeof(Person).Assembly);

                // Database Connection
                ConnectionStringSettingsCollection css = ConfigurationManager.ConnectionStrings;
                string cs = css["storage"].ConnectionString;
                container.Register<IDbConnectionFactory>(c =>
                    new OrmLiteConnectionFactory(cs, MySqlDialectProvider.Instance));

                var loadStore = container.Resolve<StorageService>();
                loadStore.Get(null);
            }

		private static void RegisterValidations(Funq.Container container)
		{
			container.RegisterValidators(typeof(UserRequestValidator).Assembly);
		}

        public override void Configure(Funq.Container container)
        {
            JsConfig.EmitCamelCaseNames = true;
            JsConfig.IncludeNullValues = true;
            JsConfig.DateHandler = JsonDateHandler.ISO8601;

            LogManager.LogFactory = new DebugLogFactory();

            SetConfig(new EndpointHostConfig
            {
                WsdlServiceNamespace = "",
                AllowJsonpRequests = true,
                DebugMode = true,
                EnableFeatures = Feature.All.Remove(GetDisabledFeatures())
            });

            //Authentication (see: https://github.com/ServiceStack/ServiceStack/blob/master/tests/ServiceStack.WebHost.Endpoints.Tests/AuthTests.cs)
            Plugins.Add(new AuthFeature(() => new AuthUserSession(),
                new IAuthProvider[] {
                  new BasicAuthProvider(), //Sign-in with Basic Auth
                }) { HtmlRedirect = null /* prevent redirect to login page, make the user login using basic auth prompt */ });
            userRepository = new InMemoryAuthRepository();
            container.Register<IUserAuthRepository>(userRepository);
            CreateUser(userRepository, 1, UserName, "DisplayName", null, Password);

            //NEW: Enable the validation feature and scans the service assembly for validators
            Plugins.Add(new ValidationFeature());
            container.RegisterValidators(typeof(Northwind.Data.Services.CategoryService).Assembly);

            //Caching
            container.Register<ICacheClient>(new MemoryCacheClient());

            //Repositories
            container.RegisterAs<CategoryServiceRepository, ICategoryServiceRepository>();
            container.RegisterAs<CustomerServiceRepository, ICustomerServiceRepository>();
            container.RegisterAs<CustomerCustomerDemoServiceRepository, ICustomerCustomerDemoServiceRepository>();
            container.RegisterAs<CustomerDemographicServiceRepository, ICustomerDemographicServiceRepository>();
            container.RegisterAs<EmployeeServiceRepository, IEmployeeServiceRepository>();
            container.RegisterAs<EmployeeTerritoryServiceRepository, IEmployeeTerritoryServiceRepository>();
            container.RegisterAs<OrderServiceRepository, IOrderServiceRepository>();
            container.RegisterAs<OrderDetailServiceRepository, IOrderDetailServiceRepository>();
            container.RegisterAs<ProductServiceRepository, IProductServiceRepository>();
            container.RegisterAs<RegionServiceRepository, IRegionServiceRepository>();
            container.RegisterAs<ShipperServiceRepository, IShipperServiceRepository>();
            container.RegisterAs<SupplierServiceRepository, ISupplierServiceRepository>();
            container.RegisterAs<TerritoryServiceRepository, ITerritoryServiceRepository>();

            //DataAccess / OrmLite
            var connectionString = ConfigurationManager.ConnectionStrings["ApiDbConnectionString"].ConnectionString;
            container.Register<IDataAccessAdapterFactory>(c => new DataAccessAdapterFactory(connectionString));
            container.Register<IDbConnectionFactory>(c => new OrmLiteConnectionFactory(connectionString, true, new SqlServerOrmLiteDialectProvider()));
        }

		public override void Configure(Funq.Container container)
		{
			//Set JSON web services to return idiomatic JSON camelCase properties
			ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;

            //https://github.com/wordnik/swagger-core/wiki
            //Document your code and expose it to the world
            Plugins.Add(new SwaggerFeature());

            //Registers authorization service and endpoints /auth and /auth{provider}
            Plugins.Add(new AuthFeature(
                    () => new AuthUserSession(),
                    new IAuthProvider[] { new CredentialsAuthProvider() }
                ) {HtmlRedirect = null});

            //Registers registartion service and endpoints /register, /assignroles, /unassignroles
            Plugins.Add(new RegistrationFeature());
            this.RegisterAs<MyRegistrationValidator, IValidator<Registration>>();
            
            Plugins.Add(new ValidationFeature());
            container.RegisterValidators(typeof(CreateOrderValidator).Assembly);

            var dataFilePath = AppDomain.CurrentDomain.GetData("DataDirectory").ToString() + "\\data.db";
		    container.Register<IDbConnectionFactory>(new OrmLiteConnectionFactory(dataFilePath, SqliteDialect.Provider));

            var userRep = new OrmLiteAuthRepository(container.Resolve<IDbConnectionFactory>());
		    container.Register<IUserAuthRepository>(userRep);
            var redisCon = ConfigurationManager.AppSettings["redisUrl"].ToString();
		    container.Register<IRedisClientsManager>(new PooledRedisClientManager(20, 60, redisCon));
            container.Register<ICacheClient>(c =>(ICacheClient)c.Resolve<IRedisClientsManager>().GetCacheClient());

		    //Set MVC to use the same Funq IOC as ServiceStack
			ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container));

            //https://github.com/ServiceStack/ServiceStack.Redis/wiki/RedisPubSub
            //start threads that subscribe to Redis channels for Pub/Sub
            new OrderSubscribers(container).StartSubscriberThreads();
            new FulfillmentSubscribers(container).StartSubscriberThreads();

            //https://github.com/ServiceStack/ServiceStack/wiki/Authentication-and-authorization#userauth-persistence---the-iuserauthrepository
            //Use ServiceStacks authentication/authorization persistence
            userRep.CreateMissingTables(); //Create missing Auth
            
            //Re-Create Tables for the demo
            using (var con = AppHostBase.Resolve<IDbConnectionFactory>().OpenDbConnection())
		    {
                con.CreateTable<Order>(true);
                con.CreateTable<Fulfillment>(true);
		    }

            //clear redis
		    using (var redis = AppHostBase.Resolve<IRedisClientsManager>().GetClient())
		    {
		    }
		    //Create dummy user accounts (TestUser/Password)
            foreach(var user in DummyUserAccounts.GetDummyAccounts())
            {
                if(userRep.GetUserAuthByUserName(user.UserName) == null)
                    userRep.CreateUserAuth(new UserAuth {UserName = user.UserName}, user.Password);
            }
		}

        public override void Configure(Funq.Container container)
        {
            JsConfig.EmitCamelCaseNames = true;
            JsConfig.IncludeNullValues = true;
            JsConfig.DateHandler = JsonDateHandler.ISO8601;

            LogManager.LogFactory = new ConsoleLogFactory();

            SetConfig(new EndpointHostConfig
                {
                    WsdlServiceNamespace = "",
                    AllowJsonpRequests = true,
                    DebugMode = true,
                    EnableFeatures = Feature.All.Remove(GetDisabledFeatures()),
                    CustomHttpHandlers = {
                        // Use the CmsRazorHandler to add theming capabilities
                        { HttpStatusCode.NotFound, new CmsRazorHandler("/notfound") }
                    }
                });

            //Authentication (see: https://github.com/ServiceStack/ServiceStack/blob/master/tests/ServiceStack.WebHost.Endpoints.Tests/AuthTests.cs)
            Plugins.Add(new AuthFeature(() => new AuthUserSession(),
                new IAuthProvider[] {
                  new BasicAuthProvider(), //Sign-in with Basic Auth
                }){ HtmlRedirect = null /* prevent redirect to login page, make the user login using basic auth prompt */ });
            userRepository = new InMemoryAuthRepository();
            container.Register<IUserAuthRepository>(userRepository);
            CreateUser(userRepository, 1, UserName, "DisplayName", null, Password);

            //Enable the validation feature and scan the service assembly for validators
            Plugins.Add(new ValidationFeature());
            container.RegisterValidators(typeof(Services.CategoryService).Assembly);

            //Razor (use CmsRazorFormat to add theming capabilities)
            Plugins.Add(new CmsRazorFormat());

            //Caching
            container.Register<ICacheClient>(new MemoryCacheClient());

            //Entity Repositories
            container.RegisterAs<CategoryServiceRepository, ICategoryServiceRepository>();
            container.RegisterAs<CustomerServiceRepository, ICustomerServiceRepository>();
            container.RegisterAs<CustomerCustomerDemoServiceRepository, ICustomerCustomerDemoServiceRepository>();
            container.RegisterAs<CustomerDemographicServiceRepository, ICustomerDemographicServiceRepository>();
            container.RegisterAs<EmployeeServiceRepository, IEmployeeServiceRepository>();
            container.RegisterAs<EmployeeTerritoryServiceRepository, IEmployeeTerritoryServiceRepository>();
            container.RegisterAs<OrderServiceRepository, IOrderServiceRepository>();
            container.RegisterAs<OrderDetailServiceRepository, IOrderDetailServiceRepository>();
            container.RegisterAs<ProductServiceRepository, IProductServiceRepository>();
            container.RegisterAs<RegionServiceRepository, IRegionServiceRepository>();
            container.RegisterAs<ShipperServiceRepository, IShipperServiceRepository>();
            container.RegisterAs<SupplierServiceRepository, ISupplierServiceRepository>();
            container.RegisterAs<TerritoryServiceRepository, ITerritoryServiceRepository>();

            //TypedList Repositories
            container.RegisterAs<TLSR.EmployeesByRegionAndTerritoryTypedListServiceRepository, TLSI.IEmployeesByRegionAndTerritoryTypedListServiceRepository>();

            //TypedView Repositories
            container.RegisterAs<TVSR.AlphabeticalListOfProductsTypedViewServiceRepository, TVSI.IAlphabeticalListOfProductsTypedViewServiceRepository>();
            container.RegisterAs<TVSR.CategorySalesFor1997TypedViewServiceRepository, TVSI.ICategorySalesFor1997TypedViewServiceRepository>();
            container.RegisterAs<TVSR.CurrentProductListTypedViewServiceRepository, TVSI.ICurrentProductListTypedViewServiceRepository>();
            container.RegisterAs<TVSR.CustomerAndSuppliersByCityTypedViewServiceRepository, TVSI.ICustomerAndSuppliersByCityTypedViewServiceRepository>();
            container.RegisterAs<TVSR.InvoicesTypedViewServiceRepository, TVSI.IInvoicesTypedViewServiceRepository>();
            container.RegisterAs<TVSR.OrderDetailsExtendedTypedViewServiceRepository, TVSI.IOrderDetailsExtendedTypedViewServiceRepository>();
            container.RegisterAs<TVSR.OrdersQryTypedViewServiceRepository, TVSI.IOrdersQryTypedViewServiceRepository>();
            container.RegisterAs<TVSR.OrderSubtotalTypedViewServiceRepository, TVSI.IOrderSubtotalTypedViewServiceRepository>();
            container.RegisterAs<TVSR.ProductsAboveAveragePriceTypedViewServiceRepository, TVSI.IProductsAboveAveragePriceTypedViewServiceRepository>();
            container.RegisterAs<TVSR.ProductSalesFor1997TypedViewServiceRepository, TVSI.IProductSalesFor1997TypedViewServiceRepository>();
            container.RegisterAs<TVSR.ProductsByCategoryTypedViewServiceRepository, TVSI.IProductsByCategoryTypedViewServiceRepository>();
            container.RegisterAs<TVSR.QuarterlyOrderTypedViewServiceRepository, TVSI.IQuarterlyOrderTypedViewServiceRepository>();
            container.RegisterAs<TVSR.SalesByCategoryTypedViewServiceRepository, TVSI.ISalesByCategoryTypedViewServiceRepository>();
            container.RegisterAs<TVSR.SalesTotalsByAmountTypedViewServiceRepository, TVSI.ISalesTotalsByAmountTypedViewServiceRepository>();
            container.RegisterAs<TVSR.SummaryOfSalesByQuarterTypedViewServiceRepository, TVSI.ISummaryOfSalesByQuarterTypedViewServiceRepository>();
            container.RegisterAs<TVSR.SummaryOfSalesByYearTypedViewServiceRepository, TVSI.ISummaryOfSalesByYearTypedViewServiceRepository>();

            //DataAccess / OrmLite
            var connectionString = ConfigurationManager.ConnectionStrings["ApiDbConnectionString"].ConnectionString;
            container.Register<IDataAccessAdapterFactory>(c => new DataAccessAdapterFactory(connectionString));
            container.Register<IDbConnectionFactory>(c => new OrmLiteConnectionFactory(connectionString, true, new SqlServerOrmLiteDialectProvider()));

            //DataAccess Caching (only for LLBLGen V4)
            //CacheController.RegisterCache(string.Empty /* connectionString */, new ResultsetCache(5*60 /* will purge the cache every 5 minutes */));
        }