Exemple #1
0
        static void Main(string[] args)
        {
            var dependencyResolver = new UnityDependencyResolver();

            dependencyResolver.Load();

            var messageLog = dependencyResolver.Resolve <MessageLog>();

            messageLog.MessageAdded += new MessageLog.MessageAddedHandler(DisplayMessage);

            var game = dependencyResolver.Resolve <Game>();

            game.Start();

            Console.ReadLine();
        }
        public void Unresolveable_Should_Return_Null()
        {
            var resolver = new UnityDependencyResolver();

            var result = resolver.Resolve <IFace1>();

            Assert.IsNull(result);
        }
Exemple #3
0
 public void Configuration(IAppBuilder app)
 {
     string strUseRedis = CloudConfigurationManager.GetSetting("UseRedis") ?? "false";
     bool useRedis = bool.Parse(strUseRedis);
     var dependencyResolver = new UnityDependencyResolver();
     UnityWireupConfiguration.WireUp(dependencyResolver);
     GlobalHost.DependencyResolver = dependencyResolver;
     var options = new CookieAuthenticationOptions()
     {
         AuthenticationType = CookieAuthenticationDefaults.AuthenticationType,
         LoginPath = new PathString("/"),
         LogoutPath = new PathString("/")
     };
     app.UseCookieAuthentication(options);
     app.Use(async (context, next) =>
     {
         if (context.Request.Path.Value.Equals("/") ||
         context.Request.Path.Value.StartsWith("/public", StringComparison.CurrentCultureIgnoreCase))
         {
             await next();
         }
         else if (context.Request.User == null || !context.Request.User.Identity.IsAuthenticated)
         {
             context.Response.StatusCode = 401;
         }
         else
         {
             await next();
         }
     });
     HttpConfiguration webApiConfiguration = new HttpConfiguration();
     webApiConfiguration.DependencyResolver = dependencyResolver;
     webApiConfiguration.MapHttpAttributeRoutes();
     app.UseWebApi(webApiConfiguration);
     RedisConfiguration redisConfiguration = dependencyResolver.Resolve<RedisConfiguration>();
     if (redisConfiguration.UseRedis)
     {
         GlobalHost.DependencyResolver.UseRedis(redisConfiguration.HostName, redisConfiguration.Port, redisConfiguration.Password, redisConfiguration.EventKey);
     }
     app.MapSignalR();
     var sharedOptions = new SharedOptions()
     {
         RequestPath = new PathString(string.Empty),
         FileSystem =
             new PhysicalFileSystem(".//public//content")
     };
     app.UseDefaultFiles(new Microsoft.Owin.StaticFiles.DefaultFilesOptions(sharedOptions)
     {
         DefaultFileNames = new List<string>() { "index.html" }
     });
     app.UseStaticFiles("/public");
     app.UseStaticFiles("/content");
     app.UseStaticFiles("/scripts");
     app.UseStaticFiles("/styles");
     app.UseStaticFiles(new StaticFileOptions(sharedOptions));
 }
        public void Array_Injector_Should_Inject_All_Registed_Types()
        {
            var resolver = new UnityDependencyResolver();
            resolver.RegisterType<IFace1, Class1>();
            resolver.RegisterType<IFace1, Class2>();
            resolver.RegisterInstance<IFace1>(new Class3());

            var resolve = resolver.Resolve<Class4>();
            Assert.AreEqual(3, resolve.Ifaces.Count());
            Assert.IsTrue(resolve.Ifaces.OfType<Class1>().Any());
            Assert.IsTrue(resolve.Ifaces.OfType<Class2>().Any());
            Assert.IsTrue(resolve.Ifaces.OfType<Class3>().Any());
        }
        public void Array_Injector_Should_Inject_All_Registed_Types()
        {
            var resolver = new UnityDependencyResolver();

            resolver.RegisterType <IFace1, Class1>();
            resolver.RegisterType <IFace1, Class2>();
            resolver.RegisterInstance <IFace1>(new Class3());

            var resolve = resolver.Resolve <Class4>();

            Assert.AreEqual(3, resolve.Ifaces.Count());
            Assert.IsTrue(resolve.Ifaces.OfType <Class1>().Any());
            Assert.IsTrue(resolve.Ifaces.OfType <Class2>().Any());
            Assert.IsTrue(resolve.Ifaces.OfType <Class3>().Any());
        }
        static void Main(string[] args)
        {
            var messageDispatched = 0;
            var resolver          = new UnityDependencyResolver();

            using (new InformationLogEventWriter())
            {
                ApplicationConfiguration.RegisterDependencyResolver(() => resolver);
                ApplicationConfiguration.RegisterServerInitialiserFactory(() => new ServerInitialiser());

                Program.InitializeServer();
            }
            var dispatcher       = resolver.Resolve <ITranspontDispatcher>();
            var internalListener = new MessageListener();

            dispatcher.TransportManager.RegisterListener(internalListener);

            Console.ReadLine();
            //Task.WaitAll(tasks.ToArray());
        }
Exemple #7
0
        public void Configuration(IAppBuilder app)
        {
            var dependencyResolver = new UnityDependencyResolver();

            UnityWireupConfiguration.WireUp(dependencyResolver);
            GlobalHost.DependencyResolver = dependencyResolver;

            var options = new CookieAuthenticationOptions
            {
                AuthenticationType = CookieAuthenticationDefaults.AuthenticationType,
                LoginPath          = new PathString("/"),
                LogoutPath         = new PathString("/")
            };

            app.UseCookieAuthentication(options);

            app.Use(async(context, next) =>
            {
                if (context.Request.Path.Value.Equals("/") ||
                    context.Request.Path.Value.StartsWith("/public", StringComparison.CurrentCultureIgnoreCase))
                {
                    await next().ConfigureAwait(false);
                }
                else if (context.Request.User == null || !context.Request.User.Identity.IsAuthenticated)
                {
                    context.Response.StatusCode = 401;
                }
                else
                {
                    await next().ConfigureAwait(false);
                }
            });

            var webApiConfiguration = new HttpConfiguration {
                DependencyResolver = dependencyResolver
            };

            webApiConfiguration.MapHttpAttributeRoutes();
            app.UseWebApi(webApiConfiguration);

            //var strUseRedis = CloudConfigurationManager.GetSetting("UseRedis") ?? "false";
            //var useRedis = bool.Parse(strUseRedis);
            var redisConfiguration = dependencyResolver.Resolve <RedisConfiguration>();

            if (redisConfiguration.UseRedis)
            {
                GlobalHost.DependencyResolver.UseRedis(redisConfiguration.HostName, redisConfiguration.Port,
                                                       redisConfiguration.Password, redisConfiguration.EventKey);
            }

            app.MapSignalR();

            var sharedOptions = new SharedOptions
            {
                RequestPath = new PathString(string.Empty),
                FileSystem  = new PhysicalFileSystem(".//public//content")
            };

            app.UseDefaultFiles(new DefaultFilesOptions(sharedOptions)
            {
                DefaultFileNames = new List <string> {
                    "index.html"
                }
            });
            app.UseStaticFiles("/public");
            app.UseStaticFiles("/content");
            app.UseStaticFiles("/scripts");
            app.UseStaticFiles("/styles");
            app.UseStaticFiles(new StaticFileOptions(sharedOptions));
        }
        public void Unresolveable_Should_Return_Null()
        {
            var resolver = new UnityDependencyResolver();

            var result = resolver.Resolve<IFace1>();
            Assert.IsNull(result);
        }
        public void Parameterized_Generic_Resolve_Should_Use_Container()
        {
            _container.Setup(c => c.Resolve <IDummyObject>("foo")).Returns((IDummyObject)null).Verifiable();

            _resolver.Resolve <IDummyObject>("foo");
        }