C# IDictionary.Get方法代码示例

        public Task Invoke(IDictionary<string, object> environment)
        {
            if (!environment.Get<string>(OwinConstants.RequestMethodKey).EqualsIgnoreCase("GET"))
            {
                return _inner(environment);
            }

            var originalOutput = environment.Get<Stream>(OwinConstants.ResponseBodyKey);
            var recordedStream = new MemoryStream();
            environment.Set(OwinConstants.ResponseBodyKey, recordedStream);

            return _inner(environment).ContinueWith(t => {
                recordedStream.Position = 0;
                environment[OwinConstants.ResponseBodyKey] = originalOutput;

                var response = new OwinHttpResponse(environment);

                if (IsGetHtmlRequest(environment) && response.StatusCode < 500)
                {
                    injectContent(environment, recordedStream, response);
                }
                else
                {
                    response.StreamContents(recordedStream);
                }
            });
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="environment">OWIN environment dictionary which stores state information about the request, response and relevant server state.</param>
        /// <returns></returns>
        public Task Invoke(IDictionary<string, object> environment)
        {
            if (environment == null)
            {
                throw new ArgumentNullException("environment");
            }

            // No IPrincipal
            if (environment.Get<IPrincipal>(Constants.ServerUserKey) == null)
            {
                environment[Constants.ResponseStatusCodeKey] = 401;
                return GetCompletedTask();
            }

            // Anonymous IPrincipal
            var winPrincipal = environment.Get<IPrincipal>(Constants.ServerUserKey) as WindowsPrincipal;
            if (winPrincipal != null)
            {
                var winIdentity = winPrincipal.Identity as WindowsIdentity;
                if (winIdentity != null && winIdentity.IsAnonymous)
                {
                    environment[Constants.ResponseStatusCodeKey] = 401;
                    return GetCompletedTask();
                }
            }

            return _nextApp(environment);
        }

 void IConstructable.Construct(IDictionary<string, string> param)
 {
     if (param.Get("source", null) != null)
         Source = param.Get("source", null);
     else
         Source = File.Exists(param["sourceRef"]) ? File.ReadAllText(param["sourceRef"]) : "";
 }

        private void PrivateMessageCommand(IDictionary<string, object> command)
        {
            var sender = command.Get(Constants.Arguments.Character);
            if (!CharacterManager.IsOnList(sender, ListKind.Ignored))
            {
                if (ChatModel.CurrentPms.FirstByIdOrNull(sender) == null)
                    channels.AddChannel(ChannelType.PrivateMessage, sender);

                channels.AddMessage(command.Get(Constants.Arguments.Message), sender, sender);

                var temp = ChatModel.CurrentPms.FirstByIdOrNull(sender);
                if (temp == null)
                    return;

                temp.TypingStatus = TypingStatus.Clear; // webclient assumption
            }
            else
            {
                ChatConnection.SendMessage(
                    new Dictionary<string, object>
                    {
                        {Constants.Arguments.Action, Constants.Arguments.ActionNotify},
                        {Constants.Arguments.Character, sender},
                        {Constants.Arguments.Type, Constants.ClientCommands.UserIgnore}
                    });
            }
        }

        private void LeaveChannelCommand(IDictionary<string, object> command)
        {
            var channelId = command.Get(Constants.Arguments.Channel);
            var characterName = command.Get(Constants.Arguments.Character);

            var channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
            if (ChatModel.CurrentCharacter.NameEquals(characterName))
            {
                if (channel != null)
                    channels.RemoveChannel(channelId, false, true);

                return;
            }

            if (channel == null)
                return;

            var ignoreUpdate = false;

            if (command.ContainsKey("ignoreUpdate"))
                ignoreUpdate = (bool) command["ignoreUpdate"];

            if (!channel.CharacterManager.SignOff(characterName) || ignoreUpdate) return;

            var updateArgs = new JoinLeaveEventArgs
            {
                Joined = false,
                TargetChannel = channel.Title,
                TargetChannelId = channel.Id
            };

            Events.NewCharacterUpdate(CharacterManager.Find(characterName), updateArgs);
        }

        public Task Invoke(IDictionary<string, object> env)
        {
            var opaqueUpgrade = env.Get<OpaqueUpgrade>("opaque.Upgrade");
            var webSocketAccept = env.Get<WebSocketAccept>(Constants.WebSocketAcceptKey);

            if (opaqueUpgrade != null
                && webSocketAccept == null
                && IsWebSocketRequest(env))
            {
                // Add websocket support
                env[Constants.WebSocketAcceptKey] = new WebSocketAccept(
                    (options, callback) =>
                    {
                        if (callback == null)
                        {
                            throw new ArgumentNullException("callback");
                        }

                        env[Constants.ResponseStatusCodeKey] = 101;

                        SetWebSocketResponseHeaders(env, options);

                        opaqueUpgrade(options,
                            opaqueEnv =>
                            {
                                var webSocket = new WebSocketLayer(opaqueEnv);
                                return callback(webSocket.Environment)
                                    .Then(() => webSocket.CleanupAsync());
                            });
                    });
            }

            return _next(env);
        }

 private void OnPivateMessageSendRequested(IDictionary<string, object> command)
 {
     channels.AddMessage(
         command.Get(Constants.Arguments.Message),
         command.Get("recipient"),
         Constants.Arguments.ThisCharacter);
     connection.SendMessage(command);
 }

 public void Map(IDictionary<string, object> document, Emitter emitter)
 {
     bool vacant = (bool)document.Get("vacant");
     string name = (string)document.Get("name");
     if (vacant && name != null)
     {
         emitter.Emit(name, vacant);
     }
 }

 public RedisLiveConnection(IDictionary<string, string> settings)
 {
     if (!settings.TryGet("host", out _Host))
     {
         throw new Exception("Redis host is required");
     }
     _Port = settings.Get("port", 6379);
     _Timeout = settings.Get("timeout", 2000);
 }

        public OwinRequestData(RouteData routeData, IDictionary<string, object> environment, ICurrentHttpRequest currentRequest)
        {
            AddValues(new RouteDataValues(routeData));
            AddValues(Querystring, new NamedKeyValues(HttpUtility.ParseQueryString(environment.Get<string>(OwinConstants.RequestQueryStringKey))));
            AddValues(FormPost, new NamedKeyValues(environment.Get<NameValueCollection>(OwinConstants.RequestFormKey)));

            AddValues(new CookieValueSource(new Cookies(currentRequest)));
            AddValues(new HeaderValueSource(currentRequest));
        }

 private void OnLrpRequested(IDictionary<string, object> command)
 {
     channels.AddMessage(
         command.Get(Constants.Arguments.Message),
         command.Get(Constants.Arguments.Channel),
         Constants.Arguments.ThisCharacter,
         MessageType.Ad);
     connection.SendMessage(command);
 }

        private void InviteCommand(IDictionary<string, object> command)
        {
            var sender = command.Get(Constants.Arguments.Sender);
            var id = command.Get(Constants.Arguments.Name);
            var title = command.Get(Constants.Arguments.Title);

            var args = new ChannelInviteEventArgs {Inviter = sender};
            Events.NewChannelUpdate(ChatModel.FindChannel(id, title), args);
        }

        public static IDisposable Create(Func<IDictionary<string, object>, Task> app, IDictionary<string, object> properties)
        {
            if (app == null)
            {
                throw new ArgumentNullException("app");
            }

            if (properties == null)
            {
                throw new ArgumentNullException("properties");
            }

            var capabilities = properties.Get<IDictionary<string, object>>(OwinKeys.ServerCapabilitiesKey)
                               ?? new Dictionary<string, object>();

            var addresses = properties.Get<IList<IDictionary<string, object>>>("host.Addresses")
                            ?? new List<IDictionary<string, object>>();

            var servers = new List<INowinServer>();
            var endpoints = new List<IPEndPoint>();
            foreach (var address in addresses)
            {
                var builder = ServerBuilder.New().SetOwinApp(app);
                int port;
                if (!int.TryParse(address.Get<string>("port"), out port)) throw new ArgumentException("port must be number from 0 to 65535");
                builder.SetPort(port);
                builder.SetOwinCapabilities(capabilities);
                var certificate = address.Get<X509Certificate>("certificate");
                if (certificate != null)
                    builder.SetCertificate(certificate);
                servers.Add(builder.Build());
                endpoints.Add(new IPEndPoint(IPAddress.Loopback,port));
            }

            var disposer = new Disposer(servers.Cast<IDisposable>().ToArray());
            try
            {
                foreach (var nowinServer in servers)
                {
                    nowinServer.Start();
                }
                // This is workaround to Windows Server 2012 issue by calling ReadLine after AcceptAsync, by making one bogus connection this problem goes away
                foreach (var ipEndPoint in endpoints)
                {
                    var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
                    socket.Connect(ipEndPoint);
                    socket.Close();
                }
            }
            catch (Exception)
            {
                disposer.Dispose();
                throw;
            }
            return disposer;
        }

        private void OnTemporaryInterestedRequested(IDictionary<string, object> command)
        {
            var character = command.Get(Constants.Arguments.Character).ToLower().Trim();
            var add = command.Get(Constants.Arguments.Type) == "tempinteresting";

            characterManager.Add(
                character,
                add ? ListKind.Interested : ListKind.NotInterested,
                true);
        }

        public Task Invoke(IDictionary<string, object> env)
        {
            IList<string> warnings = new List<string>();
            if (!TryValidateCall(env, warnings))
            {
                return TaskHelpers.Completed();
            }

            Stream originalStream = env.Get<Stream>("owin.ResponseBody");
            TriggerStream triggerStream = new TriggerStream(originalStream);
            env["owin.ResponseBody"] = triggerStream;

            // Validate response headers and values on first write.
            bool responseValidated = false;
            Action responseValidation = () =>
            {
                if (responseValidated)
                {
                    return;
                }

                responseValidated = true;

                if (!TryValidateResult(env, warnings))
                {
                    return;
                }

                if (warnings.Count > 0)
                {
                    var headers = env.Get<IDictionary<string, string[]>>(OwinConstants.ResponseHeaders);
                    headers["X-OwinValidatorWarning"] = warnings.ToArray();
                }
            };
            triggerStream.OnFirstWrite = responseValidation;

            try
            {
                return nextApp(env)
                    // Run response validation explicitly in case there was no response data written.
                    .Then(responseValidation)
                    .Catch(errorInfo =>
                    {
                        SetFatalResult(env, "6.1", "An asynchronous exception was thrown from the AppFunc: <br>"
                            + errorInfo.Exception.ToString().Replace(Environment.NewLine, "<br>"));
                        return errorInfo.Handled();
                    });
            }
            catch (Exception ex)
            {
                SetFatalResult(env, "6.1", "A synchronous exception was thrown from the AppFunc: <br>"
                            + ex.ToString().Replace(Environment.NewLine, "<br>"));
                return TaskHelpers.Completed();
            }
        }