Comment puis-je convertir un HttpRequestBase dans un objet HttpRequest?

Question

dans mon contrôleur ASP.NET MVC, j'ai une méthode qui nécessite un objet HttpRequest. Tout ce que j'ai accès à un objet est HttpRequestBase.

Y at-il de toute façon je peux en quelque sorte convertir cela?

Que peut / dois-je faire ??

Answer 1

Est-ce votre méthode, vous pouvez ré-écrire pour prendre HttpRequestBase? Sinon, vous pouvez toujours obtenir le HttpRequest courant de HttpContext.Current.HttpRequest à transmettre. Cependant, je conclurai souvent accès à l'intérieur d'une classe HttpContext comme mentionné dans ASP.NET. Suppression System.Web dépendances pour un meilleur support de tests unitaires

Answer 2

Vous devriez toujours utiliser HttpRequestBase et HttpResponseBase dans votre application, par opposition aux versions concrètes qui sont impossibles à tester (sans Typemock ou d'une autre magie).

Il suffit d'utiliser le HttpRequestWrapper classe pour convertir comme indiqué ci-dessous.

var httpRequestBase = new HttpRequestWrapper(Context.Request);

Answer 3

Vous pouvez simplement utiliser

System.Web.HttpContext.Current.Request

La clé ici est que vous avez besoin de l'espace de noms complet pour se rendre à la « bonne » HttpContext.

Je sais que ça fait 4 ans que cette question a été posée, mais si cela vous aidera quelqu'un, alors ici vous allez!

(Edit: Je vois que Kevin Hakanson a déjà donné cette réponse ... alors espérons ma réponse aidera les gens qui lisent simplement des réponses et des commentaires non.):)

Answer 4

Essayez d'utiliser / créer un HttpRequestWrapper en utilisant votre HttpRequestBase.

Answer 5

Pour HTTPRequête ASP.NET MVC4 .NET 4.5, vous pouvez faire ce qui suit:

this.HttpContext.ApplicationInstance.Context.Request

Answer 6

En général, lorsque vous avez besoin d'accéder à la propriété HttpContext dans une action de contrôleur, il y a quelque chose que vous pouvez faire une meilleure conception sage.

Par exemple, si vous avez besoin d'accéder à l'utilisateur actuel, donnez votre méthode d'action un paramètre de type IPrincipal, que vous remplissez avec un Attribute et maquette que vous le souhaitez lors du test. Pour un petit exemple sur la façon, voir ce billet de blog , et spécifiquement le point 7.

Answer 7

Il n'y a aucun moyen de convertir entre ces types.

Nous avons eu un cas similaire. Nous avons réécrit nos classes / méthodes de services Web afin qu'ils utilisent HttpContextBase, HttpApplicationStateBase, HttpServerUtilityBase, HttpSessionStateBase ... au lieu des types de nom à proximité sans le suffixe "Base" (HttpContext, ... HttpSessionState). Ils sont beaucoup plus faciles à manipuler avec moqueur fait maison.

Je suis désolé que vous ne pouviez pas le faire.

Answer 8

Ceci est un ASP.Net MVC 3.0 AsyncController qui accepte les requêtes, convertit l'objet entrant HttpRequestBase MVC à un System.Web.HttpWebRequest. Il envoie ensuite la demande de manière asynchrone. Lorsque la réponse revient, il convertit le System.Web.HttpWebResponse de nouveau dans un objet MVC HttpResponseBase qui peut être renvoyé par le contrôleur MVC.

Pour répondre à cette question explicitement, je suppose que vous ne serez intéressé par la fonction BuildWebRequest (). Cependant, il montre comment se déplacer à travers toute canalisation - conversion de BaseRequest> Demande et réponse> BaseResponse. Je partage à la fois serait pensais être utile.

Grâce à ces cours, vous pouvez avoir un serveur MVC qui agit comme un proxy web.

Hope this helps!

Contrôleur:

[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);
    }
}

Ceci est la classe proxy qui fait le levage de charges lourdes:

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();
            }
        }
    }
}

Answer 9

Il a travaillé comme Kevin.

J'utilise une méthode statique pour récupérer le HttpContext.Current.Request, et ont donc toujours un objet HttpRequest pour une utilisation en cas de besoin.

Ici, dans Helper classe

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

Ici dans le contrôleur

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

Ici, dans Voir

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

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

Ma méthode UsuarioLogado

public static bool UsuarioLogado(HttpRequest Request)