web-dev-qa-db-fra.com

Comment convertir un HttpRequestBase en un objet HttpRequest?

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

Existe-t-il de toute façon que je peux convertir cela en quelque sorte?

Que puis-je/dois-je faire?

asp.net-mvchttprequest
82
Pure.Krome

Est-ce votre méthode, vous pouvez donc la réécrire pour prendre HttpRequestBase? Sinon, vous pouvez toujours obtenir le HttpRequest actuel de HttpContext.Current.HttpRequest transmettre. Cependant, j'encapsule souvent l'accès au HttpContext dans une classe comme mentionné dans ASP.NET: Suppression des dépendances System.Web pour une meilleure prise en charge des tests unitaires.

48
Kevin Hakanson

Vous devez toujours utiliser HttpRequestBase et HttpResponseBase dans votre application par opposition aux versions concrètes qui sont impossibles à tester (sans typemock ou autre magie).

Utilisez simplement la classe HttpRequestWrapper pour convertir comme indiqué ci-dessous.

var httpRequestBase = new HttpRequestWrapper(Context.Request);
65
CountZero

Vous pouvez simplement utiliser

System.Web.HttpContext.Current.Request

La clé ici est que vous avez besoin de l'espace de noms complet pour accéder au HttpContext "correct".

Je sais que cela fait 4 ans que cette question a été posée, mais si cela peut aider quelqu'un, alors c'est parti!

(Edit: Je vois que Kevin Hakanson a déjà donné cette réponse ... alors j'espère que ma réponse aidera ces gens qui ne font que lire les réponses et non les commentaires.) :)

29
adamgede

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

9
Klaas

Pour obtenir HttpRequest dans ASP.NET MVC4 .NET 4.5, vous pouvez effectuer les opérations suivantes:

this.HttpContext.ApplicationInstance.Context.Request
8
Mohamed Mansour

En règle générale, lorsque vous devez accéder à la propriété HttpContext dans une action de contrôleur, vous pouvez améliorer la conception.

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

4
Tomas Aschan

Il s'agit d'un AsyncController ASP.Net MVC 3.0 qui accepte les demandes, convertit l'objet MVC HttpRequestBase entrant en un System.Web.HttpWebRequest. Il envoie ensuite la demande de manière asynchrone. Lorsque la réponse revient, il reconvertit System.Web.HttpWebResponse en un objet MVC HttpResponseBase qui peut être renvoyé via le contrôleur MVC.

Pour répondre explicitement à cette question, je suppose que vous ne seriez intéressé que par la fonction BuildWebRequest (). Cependant, il montre comment se déplacer dans l'ensemble du pipeline - conversion de BaseRequest> Request puis Response> BaseResponse. Je pensais que partager les deux serait utile.

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

J'espère que cela t'aides!

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 gros du travail:

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
Kenn

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'elles utilisent HttpContextBase, HttpApplicationStateBase, HttpServerUtilityBase, HttpSessionStateBase ... au lieu des types de nom proche sans le suffixe "Base" (HttpContext, ... HttpSessionState). Ils sont beaucoup plus faciles à manipuler avec des moqueries faites maison.

Je suis désolé que tu ne puisses pas le faire.

2
Barbara Post

Cela a fonctionné comme Kevin l'a dit.

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

Ici dans Class Helper

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

Ici dans le contrôleur

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

Ici en vue

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

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

My Method UsuarioLogado

public static bool UsuarioLogado(HttpRequest Request)
1
RogerGales