C# IDictionary.GetValueOrDefault方法代码示例

 /// <summary>
 /// Gets a unique key representing a composite value of the four stable metadata token types 
 /// (MetricInstanceSetType, MetricType, RenderingMode and Open) which are used to sub-group 
 /// the metric templates to reduce the amount of iteration required while searching for matches.
 /// </summary>
 /// <param name="tokens">The tokens to be used to create the metric template groupings.</param>
 /// <returns>A metric template grouping key.</returns>
 public static string GetTemplateGroupingId(IDictionary<string, string> tokens)
 {
     return DescriptorHelper.CreateUniqueId(tokens.GetValueOrDefault("MetricInstanceSetType"),
                                     tokens.GetValueOrDefault("MetricType"),
                                     tokens.GetValueOrDefault("RenderingMode"),
                                     tokens.GetValueOrDefault("Open"));
 }

 public LanguageServiceMetadata(IDictionary<string, object> data)
     : base(data)
 {
     this.ServiceType = (string)data.GetValueOrDefault("ServiceType");
     this.Layer = (string)data.GetValueOrDefault("Layer");
     this.Data = (IReadOnlyDictionary<string, object>)data;
 }

        private static AccessToken ParseAccessTokenFromResult(IDictionary<string, object> resultDictionary)
        {
            string userID = resultDictionary.GetValueOrDefault<string>(LoginResult.UserIdKey);
            string accessToken = resultDictionary.GetValueOrDefault<string>(LoginResult.AccessTokenKey);
            DateTime expiration = LoginResult.ParseExpirationDateFromResult(resultDictionary);
            ICollection<string> permissions = LoginResult.ParsePermissionFromResult(resultDictionary);

            return new AccessToken(
                accessToken,
                userID,
                expiration,
                permissions);
        }

        private void Configure(IDictionary<string, string> props) {
            if(props == null) {
                if(IsDebugEnabled)
                    log.Debug("캐시의 환경 설정 값을 기본값으로 설정합니다...");

                _expiration = DefaultExpiration;
                _priority = CacheItemPriority.Default;
                _regionPrefix = DefaultRegionPrefix;
            }
            else {
                _priority = props.GetValueOrDefault("priority", "4").AsEnum(CacheItemPriority.Default);
                _expiration = TimeSpan.FromSeconds(Math.Max(60, props.GetValueOrDefault("expiration", "300").AsInt(300)));
                _regionPrefix = props.GetValueOrDefault("regionPrefix", string.Empty).AsText(DefaultRegionPrefix);
            }
        }

        private IAstTypeReference RecursionSafeReflect(Type type, IDictionary<Type, IAstTypeReference> alreadyReflected)
        {
            var reflected = alreadyReflected.GetValueOrDefault(type);
            if (reflected != null)
                return reflected;

            if (type == typeof(object))
                return AstAnyType.Instance;

            if (type.IsGenericParameter) {
                var constraints = type.GetGenericParameterConstraints();
                return new AstGenericPlaceholderType(
                    type.Name,
                    p => {
                        alreadyReflected.Add(type, p);
                        return constraints.Select(c => this.RecursionSafeReflect(c, alreadyReflected));
                    },
                    target: type
                );
            }

            if (IsFunctionType(type))
                return ReflectFunctionType(type, alreadyReflected);

            if (type.IsGenericType && !type.IsGenericTypeDefinition)
                return ReflectGenericType(type, alreadyReflected);

            return new AstReflectedType(type, this);
        }

 public OrderableMetadata(IDictionary<string, object> data)
 {
     var readOnlyData = (IReadOnlyDictionary<string, object>)data;
     this.AfterTyped = readOnlyData.GetEnumerableMetadata<string>("After").WhereNotNull();
     this.BeforeTyped = readOnlyData.GetEnumerableMetadata<string>("Before").WhereNotNull();
     this.Name = (string)data.GetValueOrDefault("Name");
 }

 private Mock<IVsSettingsReader> MockDictionarySettingsReader(IDictionary<string, string> settings)
 {
     var reader = new Mock<IVsSettingsReader>();
     string _;
     reader.Setup(x => x.ReadSettingString(It.IsAny<string>(), out _))
           .Callback((string key, out string value) => { value = settings.GetValueOrDefault(key); });
     return reader;
 }

        private void AddGenericTheory(IDictionary<Type, ISet<Type>> genericTheories, Type genericType, Type actualType)
        {
            var set = genericTheories.GetValueOrDefault(genericType);
            if (set == null) {
                genericTheories.Add(genericType, new HashSet<Type> {actualType});
                return;
            }

            set.Add(actualType);
        }

 internal Lexer(string str, IDictionary<string, object> options)
 {
     _input = InputRegex.Replace(str, "\n");
     _colons = (bool) options.GetValueOrDefault("colons", false);
     _deferredTokens = new List<Token>();
     _lastIndents = 0;
     LineNumber = 1;
     _stash = new List<Token>();
     _indentStack = new List<int>();
     _indentRe = null;
     Pipeless = false;
 }

        public override void Render(IParrotWriter writer, IRendererFactory rendererFactory, Statement statement, IDictionary<string, object> documentHost, object model)
        {
            var childrenQueue = documentHost.GetValueOrDefault(LayoutRenderer.LayoutChildren) as Queue<StatementList>;
            if (childrenQueue == null)
            {
                //TODO: replace this with a real exception
                throw new Exception("Children elements empty");
            }

            var children = childrenQueue.Dequeue();

            RenderChildren(writer, children, rendererFactory, documentHost, DefaultChildTag, model);
        }

 internal Compiler(Node node, IDictionary<string, object> options = null)
 {
     _options = options ?? new Dictionary<string, object>();
     _node = node;
     _hasCompiledDoctype = false;
     _hasCompiledTag = false;
     _pp = (bool) _options.GetValueOrDefault("pretty", false);
     _debug = _options.ContainsKey("compileDebug") && (bool) _options["compileDebug"];
     _indents = 0;
     _parentIndents = 0;
     if (_options.ContainsKey("doctype")) SetDoctype((string) _options["doctype"]);
         
 }

        private static DateTime ParseExpirationDateFromResult(IDictionary<string, object> resultDictionary)
        {
            DateTime expiration;
            if (Constants.IsWeb)
            {
                // For canvas we get back the time as seconds since now instead of in epoch time.
                expiration = DateTime.Now.AddSeconds(resultDictionary.GetValueOrDefault<long>(LoginResult.ExpirationTimestampKey));
            }
            else
            {
                string expirationStr = resultDictionary.GetValueOrDefault<string>(LoginResult.ExpirationTimestampKey);
                int expiredTimeSeconds;
                if (int.TryParse(expirationStr, out expiredTimeSeconds) && expiredTimeSeconds > 0)
                {
                    expiration = LoginResult.FromTimestamp(expiredTimeSeconds);
                }
                else
                {
                    expiration = DateTime.MaxValue;
                }
            }

            return expiration;
        }

 public ContentTypeMetadata(IDictionary<string, object> data)
 {
     this.ContentTypes = (IEnumerable<string>)data.GetValueOrDefault("ContentTypes");
 }

 public WorkspaceServiceMetadata(IDictionary<string, object> data)
 {
     this.ServiceType = (string)data.GetValueOrDefault("ServiceType");
     this.Layer = (string)data.GetValueOrDefault("Layer");
 }

 public VisualStudioVersionMetadata(IDictionary<string, object> data)
 {
     Version = (VisualStudioVersion)data.GetValueOrDefault("Version");
 }