मेरे ASP.NET MVC कंट्रोलर के अंदर, मुझे एक विधि मिली है जिसके लिए एक HttpRequestऑब्जेक्ट की आवश्यकता होती है। सभी मेरे पास एक HttpRequestBaseवस्तु है।
वहाँ वैसे भी मैं किसी भी तरह यह परिवर्तित कर सकते हैं?
मैं क्या कर सकता / सकती हूँ ??
जवाबों:
क्या यह आपकी विधि है, इसलिए आप इसे लेने के लिए फिर से लिख सकते हैं HttpRequestBase? यदि नहीं, तो आप हमेशा चालू HttpRequestसे HttpContext.Current.HttpRequestपास कर सकते हैं । हालाँकि, मैं अक्सर ASP.NET में उल्लिखित एक वर्ग के अंदर HttpContext तक पहुंच को लपेटता हूं : बेहतर इकाई परीक्षण समर्थन के लिए System.Web निर्भरता को हटाते हुए ।
आपको अपने एप्लिकेशन में हमेशा ऐसे HttpRequestBase और HttpResponseBase का उपयोग करना चाहिए, जो उन ठोस संस्करणों के विपरीत हैं, जिनका परीक्षण (टाइपमॉक या कुछ अन्य जादू के बिना) करना असंभव है।
नीचे दिखाए अनुसार परिवर्तित करने के लिए बस HttpRequestWrapper वर्ग का उपयोग करें।
var httpRequestBase = new HttpRequestWrapper(Context.Request);
HttpRequestBaseऔर HttpResponseBase, भी HttpContextBase। :)
आप बस इस्तेमाल कर सकते हैं
System.Web.HttpContext.Current.Request
यहां कुंजी यह है कि आपको "सही" HttpContext पर पहुंचने के लिए पूर्ण नामस्थान की आवश्यकता है।
मुझे पता है कि यह प्रश्न पूछे जाने के बाद 4 साल हो गए हैं, लेकिन अगर यह किसी की मदद करेगा, तो यहां आप जाएं!
(संपादित करें: मैं देख रहा हूं कि केविन हेकसन ने पहले ही यह जवाब दे दिया था ... इसलिए उम्मीद है कि मेरी प्रतिक्रिया से उन लोगों को मदद मिलेगी, जो सिर्फ टिप्पणियां नहीं पढ़ते हैं।) :)
ASP.NET MVC4 .NET 4.5 में HttpRequest प्राप्त करने के लिए, आप निम्न कार्य कर सकते हैं:
this.HttpContext.ApplicationInstance.Context.Request
आमतौर पर जब आपको एक्सेस करने की आवश्यकता होती है HttpContext नियंत्रक क्रिया में संपत्ति होती है, तो कुछ ऐसी चीज होती है जिसे आप बेहतर डिजाइन वार कर सकते हैं।
उदाहरण के लिए, यदि आपको वर्तमान उपयोगकर्ता तक पहुँचने की आवश्यकता है, तो अपनी कार्य विधि को एक प्रकार का पैरामीटर दें IPrincipal, जिसे आप Attributeपरीक्षण करते समय अपनी इच्छानुसार एक और नकली के साथ आबाद करते हैं। कैसे, इस ब्लॉग पोस्ट और विशेष रूप से 7 बिंदु पर एक छोटे से उदाहरण के लिए देखें ।
इन प्रकारों के बीच कनवर्ट करने का कोई तरीका नहीं है।
हमारे पास एक समान मामला था। हम अपनी कक्षाओं / वेब सेवाओं के तरीकों को फिर से लिखते हैं ताकि वे HttpContextBase, HttpApplicationStateBase, HttpServerUtilityBase, HttpSessionStateBase, HttpSessionStateBase के बजाय "आधार" प्रत्यय (HttpContext, ... Http://conpSonstxtBase) के नाम का उपयोग करें। वे घर-निर्मित मॉकिंग के साथ संभालना बहुत आसान हैं।
मुझे खेद है कि आप ऐसा नहीं कर सके।
यह एक ASP.Net MVC 3.0 AsyncController है, जो अनुरोधों को स्वीकार करता है, इनबाउंड HttpRequestBase MVC ऑब्जेक्ट को System.Web.HttpWebRequest में कनवर्ट करता है। इसके बाद अनुरोध को एसिंक्रोनस रूप से भेजा जाता है। जब प्रतिक्रिया वापस आती है, तो यह System.Web.HttpWebResponse को MVC HttpResponseBase ऑब्जेक्ट में परिवर्तित करता है जिसे MVC नियंत्रक के माध्यम से वापस किया जा सकता है।
इस प्रश्न का स्पष्ट रूप से उत्तर देने के लिए, मुझे लगता है कि आप केवल BuildWebRequest () फ़ंक्शन में रुचि लेंगे। हालाँकि, यह दर्शाता है कि पूरी पाइपलाइन से कैसे आगे बढ़ना है - बेसरप्लेस्ट> रिक्वेस्ट और फिर रिस्पॉन्स> बेसरस्पोंड से परिवर्तित करना। मैंने सोचा कि दोनों को साझा करना उपयोगी होगा।
इन कक्षाओं के माध्यम से, आपके पास एक एमवीसी सर्वर हो सकता है जो वेब प्रॉक्सी के रूप में कार्य करता है।
उम्मीद है की यह मदद करेगा!
नियंत्रक:
[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);
}
}
यह छद्म वर्ग है जो भारी उठाने का काम करता है:
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();
}
}
}
}
यह काम केविन ने कहा।
मैं पुनः प्राप्त करने के लिए एक स्थिर विधि का उपयोग कर रहा हूं HttpContext.Current.Request, और इसलिए हमेशा एHttpRequest जरूरत पड़ने पर उपयोग के लिए वस्तु होती है।
public static HttpRequest GetRequest()
{
return HttpContext.Current.Request;
}
if (AcessoModel.UsuarioLogado(Helper.GetRequest()))
bool bUserLogado = ProjectNamespace.Models.AcessoModel.UsuarioLogado(
ProjectNamespace.Models.Helper.GetRequest()
);
if (bUserLogado == false) { Response.Redirect("/"); }
public static bool UsuarioLogado(HttpRequest Request)