Pregunta ¿Cómo convierto un HttpRequestBase en un objeto HttpRequest?


dentro de mi controlador ASP.NET MVC, tengo un método que requiere una HttpRequest objeto. Todo lo que tengo acceso es un HttpRequestBase objeto.

¿Hay alguna forma de que de alguna manera pueda convertir esto?

¿Qué puedo / debo hacer?


74
2017-09-21 01:28


origen


Respuestas:


¿Es su método, por lo que puede volver a escribirlo para tomar HttpRequestBase? Si no, siempre puedes obtener la corriente HttpRequest de HttpContext.Current.HttpRequest transmitir. Sin embargo, a menudo abrigo el acceso al HttpContext dentro de una clase como se menciona en ASP.NET: eliminando las dependencias de System.Web para un mejor soporte de prueba de unidad.


43
2017-09-21 01:44



Siempre debe usar HttpRequestBase y HttpResponseBase en su aplicación como apposed a las versiones concretas que son imposibles de probar (sin typemock o alguna otra magia).

Simplemente usa el HttpRequestWrapper clase para convertir como se muestra a continuación.

var httpRequestBase = new HttpRequestWrapper(Context.Request);

55
2018-02-27 12:29



Puedes simplemente usar

System.Web.HttpContext.Current.Request

La clave aquí es que necesita el espacio de nombre completo para llegar al "correcto" HttpContext.

Sé que han pasado 4 años desde que se hizo esta pregunta, pero si esto ayuda a alguien, ¡aquí tienes!

(Editar: Veo que Kevin Hakanson ya dio esta respuesta ... así que espero que mi respuesta ayude a las personas que solo leen respuestas y no comentarios). :)


23
2018-06-08 22:47



Intenta usar / crear un HttpRequestWrapper usando tu HttpRequestBase.


9
2018-04-18 17:32



Para obtener HttpRequest en ASP.NET MVC4 .NET 4.5, puede hacer lo siguiente:

this.HttpContext.ApplicationInstance.Context.Request

6
2018-03-05 16:40



Típicamente cuando necesita acceder al HttpContext propiedad en una acción de controlador, hay algo que puede hacer mejor en cuanto al diseño.

Por ejemplo, si necesita acceder al usuario actual, proporcione a su método de acción un parámetro de tipo IPrincipal, que pueblas con un Attribute y fingir como lo desee cuando realice la prueba. Para un pequeño ejemplo de cómo, ver esta publicación en el blog, y específicamente el punto 7.


4
2017-09-21 01:37



No hay forma de convertir estos tipos.

Tuvimos un caso similar. Reescribimos nuestros métodos de clases / servicios web para que utilicen HttpContextBase, HttpApplicationStateBase, HttpServerUtilityBase, HttpSessionStateBase ... en lugar de los tipos de nombres cercanos sin el sufijo "Base" (HttpContext, ... HttpSessionState). Son mucho más fáciles de manejar con burlas caseras.

Siento mucho que no puedas hacerlo.


2
2017-09-08 10:18



Este es un ASP.Net MVC 3.0 AsyncController que acepta solicitudes, convierte el objeto entrante HttpRequestBase MVC a System.Web.HttpWebRequest. A continuación, envía la solicitud de forma asíncrona. Cuando la respuesta vuelve, convierte System.Web.HttpWebResponse en un objeto MVC HttpResponseBase que puede devolverse a través del controlador MVC.

Para responder esta pregunta de forma explícita, supongo que solo estaría interesado en la función BuildWebRequest (). Sin embargo, muestra cómo moverse a través de todo el proceso: convertir BaseRequest> Request y luego Response> BaseResponse. Pensé que compartir ambos sería útil.

A través de estas clases, puede tener un servidor MVC que actúa como un proxy web.

¡Espero que esto ayude!

Controlador:

[HandleError]
public class MyProxy : AsyncController
{
    [HttpGet]
    public void RedirectAsync()
    {
        AsyncManager.OutstandingOperations.Increment();

        var hubBroker = new RequestBroker();
        hubBroker.BrokerCompleted += (sender, e) =>
        {
            this.AsyncManager.Parameters["brokered"] = e.Response;
            this.AsyncManager.OutstandingOperations.Decrement();
        };

        hubBroker.BrokerAsync(this.Request, redirectTo);
   }

    public ActionResult RedirectCompleted(HttpWebResponse brokered)
    {
        RequestBroker.BuildControllerResponse(this.Response, brokered);
        return new HttpStatusCodeResult(Response.StatusCode);
    }
}

Esta es la clase proxy que hace el trabajo pesado:

namespace MyProxy
{
    /// <summary>
    /// Asynchronous operation to proxy or "broker" a request via MVC
    /// </summary>
    internal class RequestBroker
    {
        /*
         * HttpWebRequest is a little protective, and if we do a straight copy of header information we will get ArgumentException for a set of 'restricted' 
         * headers which either can't be set or need to be set on other interfaces. This is a complete list of restricted headers.
         */
        private static readonly string[] RestrictedHeaders = new string[] { "Accept", "Connection", "Content-Length", "Content-Type", "Date", "Expect", "Host", "If-Modified-Since", "Range", "Referer", "Transfer-Encoding", "User-Agent", "Proxy-Connection" };

        internal class BrokerEventArgs : EventArgs
        {
            public DateTime StartTime { get; set; }

            public HttpWebResponse Response { get; set; }
        }

        public delegate void BrokerEventHandler(object sender, BrokerEventArgs e);

        public event BrokerEventHandler BrokerCompleted;

        public void BrokerAsync(HttpRequestBase requestToBroker, string redirectToUrl)
        {
            var httpRequest = BuildWebRequest(requestToBroker, redirectToUrl);

            var brokerTask = new Task(() => this.DoBroker(httpRequest));
            brokerTask.Start();
        }

        private void DoBroker(HttpWebRequest requestToBroker)
        {
            var startTime = DateTime.UtcNow;

            HttpWebResponse response;
            try
            {
                response = requestToBroker.GetResponse() as HttpWebResponse;
            }
            catch (WebException e)
            {
                Trace.TraceError("Broker Fail: " + e.ToString());

                response = e.Response as HttpWebResponse;
            }

            var args = new BrokerEventArgs()
            {
                StartTime = startTime,
                Response = response,
            };

            this.BrokerCompleted(this, args);
        }

        public static void BuildControllerResponse(HttpResponseBase httpResponseBase, HttpWebResponse brokeredResponse)
        {
            if (brokeredResponse == null)
            {
                PerfCounters.ErrorCounter.Increment();

                throw new GriddleException("Failed to broker a response. Refer to logs for details.");
            }

            httpResponseBase.Charset = brokeredResponse.CharacterSet;
            httpResponseBase.ContentType = brokeredResponse.ContentType;

            foreach (Cookie cookie in brokeredResponse.Cookies)
            {
                httpResponseBase.Cookies.Add(CookieToHttpCookie(cookie));
            }

            foreach (var header in brokeredResponse.Headers.AllKeys
                .Where(k => !k.Equals("Transfer-Encoding", StringComparison.InvariantCultureIgnoreCase)))
            {
                httpResponseBase.Headers.Add(header, brokeredResponse.Headers[header]);
            }

            httpResponseBase.StatusCode = (int)brokeredResponse.StatusCode;
            httpResponseBase.StatusDescription = brokeredResponse.StatusDescription;

            BridgeAndCloseStreams(brokeredResponse.GetResponseStream(), httpResponseBase.OutputStream);
        }

        private static HttpWebRequest BuildWebRequest(HttpRequestBase requestToBroker, string redirectToUrl)
        {
            var httpRequest = (HttpWebRequest)WebRequest.Create(redirectToUrl);

            if (requestToBroker.Headers != null)
            {
                foreach (var header in requestToBroker.Headers.AllKeys)
                {
                    if (RestrictedHeaders.Any(h => header.Equals(h, StringComparison.InvariantCultureIgnoreCase)))
                    {
                        continue;
                    }                   

                    httpRequest.Headers.Add(header, requestToBroker.Headers[header]);
                }
            }

            httpRequest.Accept = string.Join(",", requestToBroker.AcceptTypes);
            httpRequest.ContentType = requestToBroker.ContentType;
            httpRequest.Method = requestToBroker.HttpMethod;

            if (requestToBroker.UrlReferrer != null)
            {
                httpRequest.Referer = requestToBroker.UrlReferrer.AbsoluteUri;
            }

            httpRequest.UserAgent = requestToBroker.UserAgent;

            /* This is a performance change which I like.
             * If this is not explicitly set to null, the CLR will do a registry hit for each request to use the default proxy.
             */
            httpRequest.Proxy = null;

            if (requestToBroker.HttpMethod.Equals("POST", StringComparison.InvariantCultureIgnoreCase))
            {
                BridgeAndCloseStreams(requestToBroker.InputStream, httpRequest.GetRequestStream());
            }

            return httpRequest;
        }

        /// <summary>
        /// Convert System.Net.Cookie into System.Web.HttpCookie
        /// </summary>
        private static HttpCookie CookieToHttpCookie(Cookie cookie)
        {
            HttpCookie httpCookie = new HttpCookie(cookie.Name);

            foreach (string value in cookie.Value.Split('&'))
            {
                string[] val = value.Split('=');
                httpCookie.Values.Add(val[0], val[1]);
            }

            httpCookie.Domain = cookie.Domain;
            httpCookie.Expires = cookie.Expires;
            httpCookie.HttpOnly = cookie.HttpOnly;
            httpCookie.Path = cookie.Path;
            httpCookie.Secure = cookie.Secure;

            return httpCookie;
        }

        /// <summary>
        /// Reads from stream into the to stream
        /// </summary>
        private static void BridgeAndCloseStreams(Stream from, Stream to)
        {
            try
            {
                int read;
                do
                {
                    read = from.ReadByte();

                    if (read != -1)
                    {
                        to.WriteByte((byte)read);
                    }
                }
                while (read != -1);
            }
            finally 
            {
                from.Close();
                to.Close();
            }
        }
    }
}

2
2017-07-26 07:55



Funcionó como Kevin dijo.

Estoy usando un método estático para recuperar el HttpContext.Current.Request, y así siempre tener una HttpRequest objeto para usar cuando sea necesario.

Aquí en Class Helper

public static HttpRequest GetRequest()
{
    return HttpContext.Current.Request;
}

Aquí en Controller

if (AcessoModel.UsuarioLogado(Helper.GetRequest()))

Aquí en la vista

bool bUserLogado = ProjectNamespace.Models.AcessoModel.UsuarioLogado(
                      ProjectNamespace.Models.Helper.GetRequest()
                   );

if (bUserLogado == false) { Response.Redirect("/"); }

Mi Método UsuarioLogado

public static bool UsuarioLogado(HttpRequest Request)

1
2017-07-19 16:09