C# HttpRequestBase.ThrowIfNull方法代码示例

		public async Task<ValidateResult> Validate(HttpRequestBase request, HttpResponseBase response)
		{
			request.ThrowIfNull("request");
			response.ThrowIfNull("response");

			if (!String.IsNullOrEmpty(request.ContentType))
			{
				try
				{
					var contentType = new ContentType(request.ContentType);

					if (String.Equals(contentType.MediaType, "application/x-www-form-urlencoded", StringComparison.OrdinalIgnoreCase) || String.Equals(contentType.MediaType, "multipart/form-data", StringComparison.OrdinalIgnoreCase))
					{
						ValidationResult validationResult = await _antiCsrfNonceValidator.ValidateAsync(request);
						ResponseResult responseResult = await _antiCsrfResponseGenerator.GetResponseAsync(validationResult);

						if (responseResult.ResultType == ResponseResultType.ResponseGenerated)
						{
							return ValidateResult.ResponseGenerated(responseResult.Response);
						}
					}
				}
				catch (FormatException)
				{
				}
			}

			await _antiCsrfCookieManager.ConfigureCookieAsync(request, response);

			return ValidateResult.RequestValidated();
		}

        public bool CanMapType(HttpRequestBase request, Type parameterType)
        {
            request.ThrowIfNull("request");
            parameterType.ThrowIfNull("parameterType");

            return request.ContentType == "application/json" && _parameterTypeMatchDelegate(parameterType);
        }

        public ResponseHandlerResult HandleResponse(HttpRequestBase httpRequest, HttpResponseBase httpResponse, IResponse suggestedResponse, ICache cache, string cacheKey)
        {
            httpRequest.ThrowIfNull("httpRequest");
            httpResponse.ThrowIfNull("httpResponse");
            suggestedResponse.ThrowIfNull("suggestedResponse");

            StatusAndSubStatusCode statusCode = suggestedResponse.StatusCode;

            if (!_statusCodes.Contains(statusCode))
            {
                return ResponseHandlerResult.ResponseNotHandled();
            }

            AcceptHeader[] acceptHeaders = AcceptHeader.ParseMany(httpRequest.Headers["Accept"]).ToArray();

            if (acceptHeaders.Any() && !acceptHeaders.Any(arg => arg.MediaTypeMatches("text/plain")))
            {
                return ResponseHandlerResult.ResponseNotHandled();
            }

            Response response = new Response(statusCode)
                .TextPlain()
                .Content(String.Format("{0} {1}", statusCode.StatusDescription, statusCode.StatusDescription.Length > 0 ? String.Format("({0})", statusCode.StatusDescription) : ""));

            response.CachePolicy.NoClientCaching();

            new CacheResponse(response).WriteResponse(httpResponse);

            httpResponse.TrySkipIisCustomErrors = true;

            return ResponseHandlerResult.ResponseWritten();
        }

        public ResponseResult GetResponse(HttpRequestBase request, IEnumerable<RouteMatchResult> routeMatchResults)
        {
            request.ThrowIfNull("request");
            routeMatchResults.ThrowIfNull("routeMatchResults");

            return ResponseResult.ResponseGenerated(Response.NotFound());
        }

        public bool CanMapType(HttpRequestBase request, Type parameterType)
        {
            request.ThrowIfNull("request");
            parameterType.ThrowIfNull("parameterType");

            return parameterType.ImplementsInterface<IConvertible>();
        }

		public Cookie RenewTicket(HttpRequestBase request)
		{
			request.ThrowIfNull("request");

			HttpCookie cookie = GetRequestCookie(request);

			if (cookie == null)
			{
				return null;
			}

			FormsAuthenticationTicket ticket;

			try
			{
				ticket = System.Web.Security.FormsAuthentication.Decrypt(cookie.Value);
			}
			catch (ArgumentException)
			{
				return null;
			}

			if (ticket == null || ticket.Expired)
			{
				return null;
			}
			if (!_configuration.SlidingExpiration)
			{
				return new Cookie(cookie);
			}

			ticket = System.Web.Security.FormsAuthentication.RenewTicketIfOld(ticket);

			return ticket != null ? GenerateTicket(ticket.Expiration, ticket.UserData) : null;
		}

        public bool CanMapType(HttpRequestBase request, Type parameterType)
        {
            request.ThrowIfNull("request");
            parameterType.ThrowIfNull("parameterType");

            return true;
        }

        public bool CanMapType(HttpRequestBase request, Type parameterType)
        {
            request.ThrowIfNull("request");
            parameterType.ThrowIfNull("parameterType");

            return _parameterTypeMatchDelegate(parameterType);
        }

        public MapResult Map(HttpRequestBase request, Type type, MethodInfo method, ParameterInfo parameter)
        {
            request.ThrowIfNull("request");
            type.ThrowIfNull("type");
            method.ThrowIfNull("method");
            parameter.ThrowIfNull("parameter");

            Type parameterType = parameter.ParameterType;
            var reader = new StreamReader(request.InputStream, request.ContentEncoding);
            string json = reader.ReadToEnd();
            object jsonModel;

            try
            {
                jsonModel = JsonConvert.DeserializeObject(json, parameterType, _serializerSettings);
            }
            catch (Exception exception)
            {
                if (_errorHandling == DataConversionErrorHandling.ThrowException)
                {
                    throw new ApplicationException(String.Format("Request content could not be deserialized to '{0}'.", parameterType.FullName), exception);
                }
                jsonModel = parameterType.GetDefaultValue();
            }

            return MapResult.ValueMapped(jsonModel);
        }

        public MapResult Map(HttpRequestBase request, Type modelType, PropertyInfo property)
        {
            request.ThrowIfNull("request");
            modelType.ThrowIfNull("modelType");
            property.ThrowIfNull("property");

            return MapResult.ValueMapped(property.PropertyType.GetDefaultValue());
        }

		public Task<MapResult> MapAsync(HttpRequestBase request, Type modelType, PropertyInfo property)
		{
			request.ThrowIfNull("request");
			modelType.ThrowIfNull("modelType");
			property.ThrowIfNull("property");

			return MapResult.ValueMapped(property.PropertyType.GetDefaultValue()).AsCompletedTask();
		}

        public MapResult Map(HttpRequestBase request, Type type, MethodInfo method, ParameterInfo parameter)
        {
            request.ThrowIfNull("request");
            type.ThrowIfNull("type");
            method.ThrowIfNull("method");
            parameter.ThrowIfNull("parameter");

            return MapResult.ValueMapped(parameter.ParameterType.GetDefaultValue());
        }

        public IEnumerable<object> GetParameterValues(HttpRequestBase request, Type type, MethodInfo method)
        {
            request.ThrowIfNull("request");
            type.ThrowIfNull("type");
            method.ThrowIfNull("method");

            ParameterInfo[] parameterInfos = method.GetParameters();
            var parameterValues = new List<object>();

            foreach (ParameterInfo parameterInfo in parameterInfos)
            {
                Type parameterType = parameterInfo.ParameterType;
                string parameterName = parameterInfo.Name;
                Type currentParameterType = parameterType;

                do
                {
                    bool mapped = false;

                    foreach (IParameterMapper parameterMapper in _parameterMappers.Where(arg => arg.CanMapType(request, parameterType)))
                    {
                        MapResult mapResult = parameterMapper.Map(request, type, method, parameterInfo);

                        if (mapResult.ResultType == MapResultType.ValueNotMapped)
                        {
                            continue;
                        }

                        parameterValues.Add(mapResult.Value);
                        mapped = true;
                        break;
                    }
                    if (mapped)
                    {
                        break;
                    }

                    currentParameterType = currentParameterType.BaseType;
                } while (currentParameterType != null);

                if (currentParameterType == null)
                {
                    throw new ApplicationException(
                        String.Format(
                            "No request parameter mapper was found for parameter '{0} {1}' of '{2}.{3}'.",
                            parameterType.FullName,
                            parameterName,
                            type.FullName,
                            method.Name));
                }
            }

            return parameterValues;
        }

        public MatchResult MatchesRequest(HttpRequestBase request)
        {
            request.ThrowIfNull("request");

            MatchResult[] matchResults = _restrictions.Select(arg => arg.MatchesRequest(request)).ToArray();
            MatchResult matchingMatchResult = matchResults.FirstOrDefault(arg => arg.ResultType == MatchResultType.RestrictionMatched);

            return matchingMatchResult != null
                ? MatchResult.RestrictionMatched(matchingMatchResult.MatchedRestrictions)
                : MatchResult.RestrictionNotMatched(Enumerable.Empty<IRestriction>(), matchResults.SelectMany(arg => arg.UnmatchedRestrictions));
        }

        public ResponseHandlerResult HandleResponse(HttpRequestBase httpRequest, HttpResponseBase httpResponse, IResponse suggestedResponse, ICache cache, string cacheKey)
        {
            httpRequest.ThrowIfNull("httpRequest");
            httpResponse.ThrowIfNull("httpResponse");
            suggestedResponse.ThrowIfNull("suggestedResponse");

            var cacheResponse = new CacheResponse(suggestedResponse);

            cacheResponse.WriteResponse(httpResponse);

            return ResponseHandlerResult.ResponseWritten();
        }