C# IConfiguration.ContainsKey方法代码示例

        public SiteContextGenerator(IFileSystem fileSystem, LinkHelper linkHelper, IConfiguration config)
        {
            this.fileSystem = fileSystem;
            this.linkHelper = linkHelper;
            _config = config;

            if (_config.ContainsKey("include"))
            {
                includes.AddRange((IEnumerable<string>)_config["include"]);
            }
            if (_config.ContainsKey("exclude"))
            {
                excludes.AddRange((IEnumerable<string>)_config["exclude"]);
            }
        }

 /// <summary>
 /// Add or update the property in the underlying config depending on if it exists
 /// </summary>
 /// <param name="name"></param>
 /// <param name="newValue"></param>
 /// <param name="config"></param>
 public void AddOrChangeProperty(string name, object newValue, IConfiguration config)
 {
     // We do not want to abort the operation due to failed validation on one property
     try
     {
         if (!config.ContainsKey(name))
         {
             m_Log.DebugFormat("Adding property key [{0}], value [{1}]", name, newValue);
             config.AddProperty(name, newValue);
             return;
         }
         var oldValue = config.GetProperty(name);
         if (newValue != null)
         {
             object newValueArray;
             if (oldValue is IList && config.ListDelimiter != '\0')
             {
                 newValueArray = new ArrayList();
                 var values = ((string)newValue).Split(config.ListDelimiter).Select(v => v.Trim()).Where(v => v.Length != 0);
                 foreach (var value in values)
                 {
                     ((IList)newValueArray).Add(value);
                 }
             }
             else
             {
                 newValueArray = newValue;
             }
             if (!ObjectUtils.AreEqual(newValueArray, oldValue))
             {
                 m_Log.DebugFormat("Updating property key [{0}], value [{1}]", name, newValue);
                 config.SetProperty(name, newValue);
             }
         }
         else if (oldValue != null)
         {
             m_Log.DebugFormat("nulling out property key [{0}]", name);
             config.SetProperty(name, null);
         }
     }
     catch (ValidationException e)
     {
         m_Log.Warn("Validation failed for property " + name, e);
     }
 }

 /// <summary>
 /// Delete a property in the underlying config
 /// </summary>
 /// <param name="key"></param>
 /// <param name="config"></param>
 public void DeleteProperty(string key, IConfiguration config)
 {
     if (!config.ContainsKey(key))
     {
         return;
     }
     m_Log.DebugFormat("Deleting property key [{0}]", key);
     config.ClearProperty(key);
 }

        private Page CreatePage(SiteContext context, IConfiguration config, string file, bool isPost)
        {
            try
            {
                if (pageCache.ContainsKey(file))
                    return pageCache[file];
                var content = SafeReadContents(file);

                var relativePath = MapToOutputPath(context, file);
                var scopedDefaults = context.Config.Defaults.ForScope(relativePath);

                var header = scopedDefaults.Merge(content.YamlHeader());

                if (header.ContainsKey("published") && header["published"].ToString().ToLower() == "false")
                {
                    return null;
                }

                var page = new Page
                                {
                                    Title = header.ContainsKey("title") ? header["title"].ToString() : "this is a post",
                                    Date = header.ContainsKey("date") ? DateTime.Parse(header["date"].ToString()) : file.Datestamp(fileSystem),
                                    Content = content,
                                    Filepath = isPost ? GetPathWithTimestamp(context.OutputFolder, file) : GetFilePathForPage(context, file),
                                    File = file,
                                    Bag = header,
                                };

                // resolve categories and tags
                if (isPost)
                {
                    page.Categories = ResolveCategories(context, header, page);

                    if (header.ContainsKey("tags"))
                        page.Tags = header["tags"] as IEnumerable<string>;
                }

                // resolve permalink
                if (header.ContainsKey("permalink"))
                {
                    page.Url = linkHelper.EvaluatePermalink(header["permalink"].ToString(), page);
                }
                else if (isPost && config.ContainsKey("permalink"))
                {
                    page.Url = linkHelper.EvaluatePermalink(config["permalink"].ToString(), page);
                }
                else
                {
                    page.Url = linkHelper.EvaluateLink(context, page);
                }

                // resolve id
                page.Id = page.Url.Replace(".html", string.Empty).Replace("index", string.Empty);

                // always write date back to Bag as DateTime
                page.Bag["date"] = page.Date;

                // The GetDirectoryPage method is reentrant, we need a cache to stop a stack overflow :)
                pageCache.Add(file, page);
                page.DirectoryPages = GetDirectoryPages(context, config, Path.GetDirectoryName(file), isPost).ToList();

                return page;
            }
            catch (Exception e)
            {
                Tracing.Info(String.Format("Failed to build post from File: {0}", file));
                Tracing.Info(e.Message);
                Tracing.Debug(e.ToString());
            }

            return null;
        }