C# Configuration.Add方法代码示例

        private void ParseFile(FileInfo file, Configuration configuration)
        {
            var lines = File.ReadAllLines(file.FullName);
            foreach (var line in lines)
            {
                if (line.IsEmpty())
                {
                    continue;
                }

                if (line.Contains(":"))
                {
                    var splat = line.Split(':');
                    var name = splat.First().Trim();
                    var value = splat.Skip(1).JoinAsString(":").Trim();
                    configuration.Add(new Configuration(name, value));
                    continue;
                }

                var newName = line.Trim();
                var newFile =
                    new FileInfo(Path.Combine(file.Directory.FullName, newName + "." + _subFileExtension));
                var newConfiguration = new Configuration(newName, c => c.BelongingTo(configuration));
                ParseFile(newFile, newConfiguration);
            }
        }

 private ForceFieldUnityContainer CreateContainer()
 {
     var unityAdvisorConfiguration = new Configuration();
     unityAdvisorConfiguration.Add<TestAdvice>(ApplyAdvice.OnEveryMethod);
     var forceFieldUnityContainer = new ForceFieldUnityContainer(unityAdvisorConfiguration);
     forceFieldUnityContainer.RegisterType<ITestInterface, TestInterfaceExtended>();
     return forceFieldUnityContainer;
 }

 public ConfigurationParameters BelongingTo(Configuration configuration)
 {
     if (configuration != null)
     {
         configuration.Add(Configuration);
     }
     return this;
 }

        public void Should_Add_a_user_watching_an_exsisting_pipeline()
        {
            var skypename = "username";
            var pipeline = "somePipe";

            var configuration = new Configuration();
            configuration.Add(pipeline, skypename);
            Assert.That(configuration.Items[0].name, Is.EqualTo(pipeline));
            Assert.That(configuration.Items[0].users[0].skypeName, Is.EqualTo(skypename));
        }

        public void AllAdvicesShouldBeAutomaticlyRegistered()
        {
            //Arrange
            var configuration = new Configuration();
            configuration.Add<TestAdvice>(ApplyAdvice.OnEveryMethod);
            var container = new ForceFieldUnityContainer(configuration);

            //Act
            var resolvedAdvice = container.Resolve<TestAdvice>();

            //Assert
            Assert.IsNotNull(resolvedAdvice);
        }

        public void ImplementsIHaveConfiguration()
        {
            //Arrange
            var containerBuilder = new ContainerBuilder();
            var configuration = new Configuration();
            configuration.Add<TestAdvice>(ApplyAdvice.OnEveryMethod);

            //Act
            var forceFieldContainer = containerBuilder.Build(configuration);

            //Assert
            Assert.IsNotNull(forceFieldContainer as IHaveConfiguration);
        }

        private static void TestUnityIntegration()
        {
            var forceFieldConfiguration = new Configuration();
            forceFieldConfiguration.Add<CachingAdvice>(ApplyAdvice.OnEveryMethod);
            forceFieldConfiguration.Add<ExceptionHandlingAdvice>(new ApplyAdviceOnAllRepositories());
            forceFieldConfiguration.Add<LoggerAdvice>(new ApplyAdviceOnAllRepositories());
            forceFieldConfiguration.Add<EmptyAdvice>(ApplyAdvice.OnEveryMethod);

            var unity = new ForceFieldUnityContainer(forceFieldConfiguration);
            unity.RegisterType<ICacheProvider, RamCacheProvider>();
            unity.RegisterType<ILoggingService, LoggingService>();
            unity.RegisterType<IOtherService, OtherService>();
            unity.RegisterType<ICacheConfigurationService, ExampleOfCacheConfigurationService>();
            unity.RegisterType<IPersonRepository, PersonRepository>();

            var repository = unity.Resolve<IPersonRepository>();
            repository.Save(new Person { Key = 1, Age = 25, Name = "John" });
            repository.GetByName("John");
            repository.GetByName("John");

            var service = unity.Resolve<IOtherService>();
            var meaningOfLife = service.Bar();
        }

        public void ResolveComponentReturnsAProxy()
        {
            //Arrange
            var containerBuilder = new ContainerBuilder();
            containerBuilder.Register(c => new TestInterfaceExtended()).As<ITestInterface>();
            var configuration = new Configuration();
            configuration.Add<TestAdvice>(ApplyAdvice.OnEveryMethod);
            var forceFieldContainer = containerBuilder.Build(configuration);

            //Act
            var resolvedInterface = forceFieldContainer.Resolve<ITestInterface>();

            //Assert
            Assert.IsNotNull(resolvedInterface as IDynamicProxy);
        }

        /// <summary>
        /// Parse a configuration command user.name='hola' user.password=what
        /// </summary>
        /// <param name="configCommand"></param>
        /// <returns></returns>
        public static IEnumerable<IConfiguration> ParseConfiguration(string configCommand)
        {
            Dictionary<string, IConfiguration> result = new Dictionary<string, IConfiguration>();
            MatchCollection matches = CommandExpression.Matches(configCommand);

            foreach (Match match in matches)
            {
                string config = match.Value;
                int firstDotIndex = config.IndexOf('.');

                // getting the category name of the command
                string category = config.Substring(0, firstDotIndex);

                //geting the property without the dot(.)
                string property = config.Substring(firstDotIndex + 1, (config.Length - firstDotIndex) - 1);

                var propertyInfo = ParseProperty(property);

                if (result.ContainsKey(category))
                {
                    result[category].Add(propertyInfo.Key, propertyInfo.Value);
                }
                else
                {
                    Configuration c = new Configuration(category);
                    c.Add(propertyInfo.Key, propertyInfo.Value);

                    result.Add(category, c);
                }
            }

            foreach (var item in result)
            {
                yield return item.Value;
            }
        }

        public ActionResult Edit([Bind(Include = "ClassroomId,CourseId,DataCenterId,UserId,Start,Name")] Classroom classroom, string sessionId)
        {
            if (ModelState.IsValid)
            {
                DataCenter dc = this.db.Query<DataCenter>().Where(d => d.DataCenterId == classroom.DataCenterId).FirstOrDefault();
                if (dc != null)
                {
                    Course crs = this.db.Query<Course>().Where(c => c.CourseId == classroom.CourseId).FirstOrDefault();
                    if (crs != null)
                    {
                        Project projectObject = new Project(this.st);
                        if (classroom.ClassroomId == 0)
                        {
                            projectObject.name = crs.Name + "-" + classroom.Start.ToShortDateString();
                            projectObject.region = dc.Region;
                            projectObject.Add();
                            if (projectObject.id != null)
                            {
                                classroom.Project = projectObject.id;
                                this.db.Add<Classroom>(classroom);
                                Log.Write(this.db, ControllerContext.HttpContext, new Log() { Message = LogMessages.create, Detail = "Classroom created for " + crs.Name + " on " + classroom.JSDate });
                            }
                        }
                        else
                        {
                            this.db.Update<Classroom>(classroom);
                            Log.Write(this.db, ControllerContext.HttpContext, new Log() { Message = LogMessages.update, Detail = "Classroom updated for  " + crs.Name + " on " + classroom.JSDate });
                        }

                        List<SeatTemp> sts = this.db.Query<SeatTemp>().Where(st => st.SessionId == sessionId).ToList();
                        List<int> stids = sts.Select(s => s.SeatId).ToList();
                        List<Seat> seatsToRemove = this.db.Query<Seat>().Where(s => !stids.Contains(s.SeatId)).ToList();
                        Configuration configuration = new Configuration(this.st);
                        foreach (Seat s in seatsToRemove)
                        {
                            this.db.Remove<Seat>(s);
                            configuration.Id = s.ConfigurationId;
                            configuration.Delete();
                        }

                        foreach (SeatTemp st in sts)
                        {
                            Seat s = st.ToSeat();
                            if (s.SeatId == 0)
                            {
                                if (s.ClassroomId == 0)
                                {
                                    s.ClassroomId = classroom.ClassroomId;
                                }

                                User usr = this.db.Query<User>().Where(u => u.UserId == s.UserId).FirstOrDefault();
                                configuration.Name = usr.EmailAddress + "-" + crs.Name;
                                configuration.Add(classroom.Project, classroom.Course.Template, dc.GateWayBackboneId, dc.Region);
                                if (configuration.Id != null)
                                {
                                    s.ConfigurationId = configuration.Id;
                                    this.db.Add<Seat>(s);
                                }
                            }

                            this.db.Remove<SeatTemp>(st);
                        }

                        this.db.SaveChanges();
                    }
                }

                return this.RedirectToAction("Index", "Home");
            }

            ViewBag.Session = sessionId;
            this.PopulateTemp(classroom.ClassroomId, ViewBag.Session);
            ViewBag.CourseId = new SelectList(this.db.Query<Course>(), "CourseId", "Name", classroom.CourseId);
            ViewBag.UserId = new SelectList(this.db.Query<User>(), "UserId", "EmailAddress", classroom.UserId);
            return this.View(classroom);
        }

        public static Configuration GetDefault(string rootPath)
        {
            Configuration res = new Configuration();
            res.DefaultConfiguration = "Default";

            MappingInfo mapping = GetDefaultMapping(rootPath, "Default");
            res.Add(mapping);

            return res;
        }