Está en la página 1de 22

Cmo utilizar HttpWebRequest y

HttpWebResponse en. NET


Por munishk , 28 de marzo 2004


4.53 ( 80 votos)



Cambio: voto 1voto 2votos 3votos 4votos 5

Introduccin
Aplicaciones de Internet se pueden clasificar ampliamente en dos tipos: las aplicaciones de
cliente que solicitan informacin y aplicaciones de servidor que respondan a las solicitudes de
informacin de los clientes. La clsica aplicacin de cliente-servidor de Internet es la World
Wide Web, donde la gente utiliza navegadores para acceder a los documentos y otros datos
almacenados en los servidores Web de todo el mundo.
Las aplicaciones no se limitan slo a una de estas funciones, por ejemplo, el servidor de
aplicaciones de nivel medio familiarizado responde a las peticiones de los clientes al solicitar
datos de otro servidor, en cuyo caso est actuando como un servidor y un cliente.
La aplicacin de cliente realiza una solicitud identificando el recurso de Internet solicitado y el
protocolo de comunicacin a utilizar para la solicitud y la respuesta. Si es necesario, el cliente
tambin proporciona datos adicionales necesarios para completar la solicitud, como la
ubicacin proxy o informacin de autenticacin (nombre de usuario, contrasea, etc). Una vez
que se forma la solicitud, la solicitud se puede enviar al servidor.
La identificacin de los Recursos
El. NET Framework utiliza un identificador uniforme de recursos (URI) para identificar el recurso
de Internet solicitado y el protocolo de comunicacin. El URI se compone de al menos tres y
posiblemente cuatro, fragmentos: el identificador de servicio, que identifica el protocolo de
comunicaciones para la solicitud y la respuesta, y el identificador del servidor, el cual consiste
de un sistema de nombres de dominio (DNS) nombre de host o una direccin TCP que
identifica el servidor en Internet, el identificador de ruta, que localiza la informacin solicitada
en el servidor, y una cadena de consulta opcional, que pasa informacin desde el cliente al
servidor. Por ejemplo, el URI "http://www.MyWebSite.com/whatsnew.aspx?date=today"
consiste en el identificador de esquema de "http", el "www. MyWebSite.com" identificador de
servidor, la ruta "/ whatsnew. aspx ", y la cadena de consulta"? date = hoy ".
Despus de que el servidor ha recibido la solicitud y procesado la respuesta, se devuelve la
respuesta a la aplicacin cliente. La respuesta incluye informacin suplementaria, tal como el
tipo del contenido (texto sin formato o datos XML, por ejemplo).
El desarrollo de aplicaciones que se ejecutan en el entorno operativo distribuido de la Internet
de hoy requiere un mtodo eficiente y fcil de usar para recuperar datos de recursos de todo
tipo. Protocolos conectables permiten desarrollar aplicaciones que utilicen una nica interfaz
para recuperar datos de mltiples protocolos de Internet.
. NET Framework utiliza clases especficas para proporcionar los tres elementos de informacin
necesarios para acceder a los recursos de Internet a travs de un modelo de solicitud /
respuesta: el Uri de la clase, que contiene el URI del recurso de Internet que usted est
buscando, el HttpWebRequest clase, que contiene una solicitud para el recurso, y
la HttpWebResponse clase, que proporciona un contenedor para la respuesta entrante.
Aqu, voy a mostrar con el cdigo de prctica, la forma de enviar la solicitud y recibir respuesta
a los sitios de Internet / intranet. Estoy asumiendo que el lector posee conocimientos bsicos
de C # y Visual Studio.
Abra un proyecto de biblioteca de clases C # Visual studio, copie y pegue el cdigo siguiente a
la parte donde dice "Fin de la base de la Clase":
Contraer | Copiar cdigo
utilizando System;
utilizando System.Collections.Specialized;
utilizando System.Net;
utilizando System.Text;
utilizando System.IO;

de espacio de nombres BaseClassNameSpace.Web.BaseServices
{
/ / / < Resumen >
/ / / Esta clase base proporciona la aplicacin de peticin
/ / / y mtodos de respuesta durante Http Llamadas.
/ / / < / resumen >

pblico de clase HttpBaseClass
{

private string UserName;
private string UserPwd;
private string ProxyServer;
private int ProxyPort;
private string Request;

public HttpBaseClass( string HttpUserName,
string HttpUserPwd, string HttpProxyServer,
int HttpProxyPort, string HttpRequest)
{
UserName = HttpUsername;
UserPwd = HttpUserPwd;
ProxyServer = HttpProxyServer;
ProxyPort = HttpProxyPort;
Solicite = HttpRequest;
}

/ / / < Resumen >
/ / / Este mtodo crea web seguro seguro / no
/ / / peticin sobre la base de los parmetros pasados.
/ / / < / resumen >
/ / / < param name = "uri" > < / param >
/ / / < param name = "collHeader" > Este parmetro de tipo
/ / / NameValueCollection puede contener cualquier cabecera adicionales
/ / / elementos que deben incluirse en esta solicitud < / param >
/ / / < param name = "RequestMethod" > El valor puede POST o GET < / param >
/ / / < param name = "NwCred" > En caso de solicitud de seguro esto sera verdad < /
param >
/ / / < retornos > < / retornos >
pblica virtual de HttpWebRequest CreateWebRequest ( string uri,
NameValueCollection collHeader,
cadena RequestMethod, bool NwCred)
{
HttpWebRequest WebRequest =
(HttpWebRequest) WebRequest.Create (uri);
webrequest.KeepAlive = false ;
webrequest.Method = RequestMethod;

int iCount = collHeader.Count;
string clave,
string keyvalue;

para ( int i = 0; i <iCount; i + +)
{
= collHeader.Keys clave [i];
keyvalue = collHeader [i];
webrequest.Headers.Add (clave, keyvalue);
}

webrequest.ContentType = " text / html " ;
/ / "application / x-www-form-urlencoded";

si (ProxyServer.Length> 0 )
{
webrequest.Proxy = nueva
WebProxy (ProxyServer, ProxyPort);
}
webrequest.AllowAutoRedirect = false ;

si (NwCred)
{
CredentialCache wrCache =
nueva CredentialCache ();
wrCache.Add ( nuevo Uri (uri), " Bsico " ,
nueva NetworkCredential (nombre de usuario, UserPwd));
webrequest.Credentials = wrCache;
}
/ / quitar elementos de la coleccin
collHeader.Clear ();
volver WebRequest;
} / / Fin de seguro CreateWebRequest

/ / / < sumarias >
/ / / Este mtodo retreives redirigidos URL del
/ / / cabecera de la respuesta y tambin pasa de nuevo
/ / / cualquier galleta (si hay any)
/// < / summary >
/// < param name="webresponse" > < / param >
/// < param name="Cookie" > < / param >
/// < returns > < / returns >
public virtual string GetRedirectURL(HttpWebResponse
WebResponse, ref string Cookies)
{
string uri = " " ;

WebHeaderCollection headers = webresponse.Headers;

si ((webresponse.StatusCode == HttpStatusCode.Found) | |
(Webresponse.StatusCode == HttpStatusCode.Redirect) | |
(Webresponse.StatusCode == HttpStatusCode.Moved) | |
(Webresponse.StatusCode == HttpStatusCode.MovedPermanently))
{
/ / redirecciona uri
uri = cabeceras [ " ubicacin " ];
uri = uri.Trim ();
}

/ / Comprobar si las cookies
si (cabeceras [ " Set-Cookie " ]! = nulo )
{
Cookies = cabeceras [ " Set-Cookie " ];
}
/ / string StartURI = "http://";
/ / if (uri.Length> 0 && uri.StartsWith (StartURI) == false)
/ / {
/ / uri = StartURI + uri;
/ / }
regreso uri;
} / / Fin del mtodo GetRedirectUrl


pblica virtual de cadena GetFinalResponse ( string ReUri,
cadena de la galleta, cadena RequestMethod, bool NwCred)
{
NameValueCollection collHeader =
nueva NameValueCollection ();

si (Cookie.Length> 0 )
{
collHeader.Add ( " Cookie " , Cookie);
}

HttpWebRequest WebRequest =
CreateWebRequest (ReUri, collHeader,
RequestMethod, NwCred);

BuildReqStream ( ref WebRequest);

HttpWebResponse WebResponse;

WebResponse = (HttpWebResponse) WebRequest.GetResponse ();

Codificacin enc = System.Text.Encoding.GetEncoding ( 1252 );
StreamReader loResponseStream = nueva
StreamReader (webResponse.GetResponseStream (), enc);

cadena de respuesta = loResponseStream.ReadToEnd ();

loResponseStream.Close ();
WebResponse.Close ();

regresar respuesta;
}

privado void BuildReqStream ( ref HttpWebRequest WebRequest)
/ / Este mtodo construye la secuencia de la solicitud de WebRequest
{
byte [] bytes = Encoding.ASCII.GetBytes (Request);
webrequest.ContentLength = bytes.Length;

Stream oStreamOut = WebRequest.GetRequestStream ();
oStreamOut.Write (bytes, 0 , bytes.Length);
oStreamOut.Close ();
}
}
} / / Fin de la HttpBaseClass clase

/ / "Fin de la base de la Clase"
Guarde el archivo anterior por el nombre, por ejemplo, HttpBaseClass.cs .
Vamos a travs de las diferentes piezas del programa anterior.
System.Net espacio de nombres
proporciona HttpWebRequest y HttpWebResponse clases. Ya he explicado sobre estas clases
en el principio.
Sytem.IO espacio de nombres proporciona las clases para enviar la solicitud y recibir
respuesta en los arroyos.
Esta es la clase base, que proporciona mtodos para solicitar datos, analizar cualquier URL de
redireccin, recibir respuesta y convertir la respuesta (ya que viene en los arroyos) en datos
significativos. De esta clase, va a crear una clase derivada (espera, eso sera el siguiente paso
hasta que terminemos esta clase) y puede invalidar los pblicosmtodos (por eso es que se
definen con virtual de la palabra clave). Vamos a ir al trabajo real del cdigo de la clase
base.
Cuando se crea una instancia de esta clase, usted tendr que proporcionar ciertos parmetros
al constructor. Los parmetros son:
cadena HttpUsername : Nombre de usuario
cadena HttpUserPwd : Contrasea del usuario
Se requieren ms de dos variables para las sitios seguros, que requieren ID de usuario y
contrasea que se enviar junto con el encabezado de la solicitud. Por lo general, para los sitios
seguros, encabezado de la solicitud es la siguiente:
Contraer | Copiar cdigo
Autorizacin: NNNNNNNNNNNNNNNNNN bsico ==
Autorizacin es la propiedad, bsico es el tipo de codificacin y NNNNNNNNNNNNNNNNNN
== es el ID de usuario actual y la contrasea codificada en formato Base64.
cadena HttpProxyServer, int HttpProxyPort : Si su solicitud va a un sitio externo de
sus redes corporativas, entonces probablemente se requerira nombre del servidor proxy y el
nmero de puerto del servidor proxy (normalmente 8080). Compruebe la configuracin del
navegador para estas propiedades y pasarlas en consecuencia para el constructor. Puede pasar
una cadena vaca y 0 si se conecta a un sitio de intranet.
HttpRequest Cadena : Solicitud de Apelacin. Puede ser un XML u otro texto solicitud.
Vamos a ver lo que est sucediendo bajo el cap de CreateWebRequest mtodo. Este
mtodo es el primer paso en la creacin de la solicitud con la URL de destino. Parmetros que
se pasan en este mtodo son:
Uri Cuerda : Target URI (Ej.: Google.com, Yahoo.com, yourownintranetsite.com)
NameValueCollection collHeader : Una variable de tipo NameValueCollection . Si
usted ve en el mtodo en una lnea (en el de bucle), si se requieren encabezados adicionales,
que estn siendo extrados de esta variable y se insertan en encabezado de la solicitud. Por
ejemplo, su sitio requerido podr exigir galletas adicionales para ser enviados en el
encabezado.
Cadena RequestMethod : Puede ser "POST" o "GET".
bool NwCred : Este valor de la variable se establece en funcin de si el sitio requiere ID de
usuario / contrasea (si se trata de sitio seguro) o no. Ver en el cdigo si es cierto , entonces
el uso de CredentialCache yNetworkCredential clases, ID de usuario y la contrasea se
transmiten en formato Base64. En este momento, he codificado el tipo de seguridad como
" bsico ", pero se puede ajustar otros parmetros de seguridad tales como Digest, Kerberos,
NTLM, dependiendo de los requerimientos.
Contraer | Copiar cdigo
Lnea HttpWebRequest WebRequest = (HttpWebRequest) WebRequest.Create (uri)
Crea un HttpWebRequest instancia.
Si usted est golpeando sitio externo, fuera de la intranet corporativa, entonces esta lnea se
ejecutara sobre la base de si ProxyServer variable contiene el valor del servidor o se
establece en una cadena vaca en el constructor en el momento de la creacin de una instancia
de esta clase.
Contraer | Copiar cdigo
webrequest.Proxy = nueva WebProxy (ProxyServer, ProxyPort);
Ajuste webrequest.AllowAutoRedirect = false es para manejo de redireccin (s) por s
mismo y es por eso que est establecido en false .
Tengo una pregunta aqu para cualquier friki que leen este artculo. Cuando yo estaba sentado
a la verdadera , que estaba recibiendo un mensaje de error, pero si he
usado ServerXMLHttp (va COM), cada redireccin se manej de forma automtica (misterio
para m)??????
Vamos a ver el otro mtodo GetRedirectUrl : este mtodo se invoca para observar si alguno
de redireccin o galletas estn regresando despus de URI de destino es golpeado. Puede
haber casos en los que no hay redireccin pero an prxima solicitud al URI espera unas
galletas espalda. Por ejemplo, el sitio donde mi aplicacin golpea ahora pasa de nuevo a la
redireccin de URI y galletas (que contiene el ID de sesin). Golpe redirigido URI de nuevo
con la galleta en la cabecera y luego me da la respuesta final. Esto es muy evidente
en GetFinalResponse mtodo en lnea:
Contraer | Copiar cdigo
si (Cookie.Length> 0 )
{
collHeader.Add ( " Cookie " , Cookie);
}
Este nameValue collHeader coleccin se pas de nuevo
a CreateWebRequest mtodo. Voy a explicar los parmetros pasados
en GetFinalResponse mtodo:
cadena ReUri : Redirigido URI. Si no hay ninguna redireccin, URI original se pasa.
cadena de cookies : Si hay alguna cookie de mtodo GetRedirectUrl .
cadena RequestMethod : "POST" o "GET". Si usted piensa que habr un poco de URI
redirigido, a continuacin, inicialmente (cuando CreateWebRequest se llama al mtodo) te
recibe como mtodo de peticin, y en respuesta final, se puede decir el mtodo "POST", en
funcin de sus necesidades.
bool NwCred : Como se explica en el mtodo CreateWebRequest .
Dentro de este mtodo, BuildReqStream mtodo se llama el que construye el flujo de
solicitud de WebRequest . En la comunicacin por Internet, peticin texto est construido en
forma de arroyos y tambin lo es la respuesta. Cuando la respuesta viene de nuevo en la
corriente, a convertir de nuevo en formato original. Ver la parte:
Contraer | Copiar cdigo
Codificacin enc = System.Text.Encoding.GetEncoding ( 1252 );
1252 es la codificacin para el formato de Windows. Lea ms sobre la codificacin y arroyos en
MSDN.
Contraer | Copiar cdigo
StreamReader loResponseStream =
nuevo StreamReader (webResponse.GetResponseStream (), enc);
cadena de respuesta = loResponseStream.ReadToEnd ();
Antes de esta parte, ver estamos declarando:
Contraer | Copiar cdigo
HttpWebResponse WebResponse;
WebResponse = (HttpWebResponse) WebRequest.GetResponse ();
En estas 2 lneas, en realidad estamos recibiendo la respuesta despus de haber creado la
solicitud enCreateWebRequest mtodo. Del mismo modo, HttpWebRequest clase est ah
para que la creacin de la solicitud, por lo que es el HttpWebResponse para obtener la
respuesta.
Ahora, vamos a ver cmo realmente usamos la clase anterior.
Abra un nuevo archivo de biblioteca de clases en el mismo proyecto, copia y pega el siguiente
cdigo:
Contraer | Copiar cdigo
using System;
using System.Collections.Specialized;
using System.Net;
using System.Text;
using System.IO;
using BaseClassNameSpace.Web.BaseServices;

namespace DeriveClassNameSpace.Services.Web
{

pblico de clase HTTPRequestResponse
{
private string URI;
private string Request;
private string UserName;
private string UserPwd;
private string ProxyServer;
private int ProxyPort;
private string RequestMethod = " GET " ;

pblica HTTPRequestResponse ( string pRequest,
cadena Puri) / / Constructor
{
Peticin = pRequest;
URI = Puri;
}

pblica cadena HTTP_USER_NAME
{
conseguir
{
volver Nombre de usuario;
}
conjunto
{
Nombre de usuario = valor;
}
}

pblica cadena HTTP_USER_PASSWORD
{
conseguir
{
volver UserPwd;
}
conjunto
{
UserPwd = valor;
}
}

pblica cadena proxy_server
{
conseguir
{
volver ProxyServer;
}
conjunto
{
ProxyServer = valor;
}
}

pblica int PROXY_PORT
{
conseguir
{
volver ProxyPort;
}
conjunto
{
ProxyPort = valor;
}
}

pblica cadena sendRequest ()
/ * Esta interfaz pblica recibe la solicitud
y enviar la respuesta de tipo cadena. * /
{
cadena FinalResponse = " " ;
cadena Cookies = " " ;

NameValueCollection collHeader = nueva NameValueCollection ();

HttpWebResponse WebResponse;

HttpBaseClass BaseHttp = nueva
HttpBaseClass (nombre de usuario, UserPwd,
ProxyServer, ProxyPort, Request);
intentar
{
HttpWebRequest WebRequest =
BaseHttp.CreateWebRequest (URI,
collHeader, RequestMethod, cierto );
WebResponse =
(HttpWebResponse) WebRequest.GetResponse ();

cadena ReUri =
BaseHttp.GetRedirectURL (WebResponse,
ref galleta);
/ / . Compruebe si hay algn URI redirigido
WebResponse.Close ();
ReUri = ReUri.Trim ();
si (ReUri.Length == 0 ) / / No redireccin URI
{
ReUri = URI;
}
RequestMethod = " POSTE " ;
FinalResponse = BaseHttp.GetFinalResponse (ReUri,
Cookies, RequestMethod, cierto );

} / / Fin de bloque try

catch (WebException e)
{
tirar CatchHttpExceptions (FinalResponse = e.Message);
}
captura (System.Exception e)
{
arrojar nueva excepcin (FinalResponse = e.Message);
}
finalmente
{
BaseHttp = null;
}
volver FinalResponse;
} / / Fin del mtodo SendRequestTo

privado CatchHttpExceptions WebException ( string Mens)
{
Mensaje de error = " . Error durante la Interfaz Web de error es: " + mens;
volver nueva WebException (Mens);
}
} / / Fin de la RequestResponse Clase
}
Veremos la implementacin de la clase anterior en una etapa posterior, pero antes de eso,
vamos a considerar lo que est sucediendo dentro de esta clase. En
el HTTPRequestResponse constructor, los 2 parmetros son:
cadena pRequest : Solicitar texto que ira con la solicitud
cuerpo. Ver BuildReqStream mtodo enHttpBaseClass .
cadena de Puri : Target URI (sitio externo o intranet URI).
Los mtodos pblicos de la propiedad son:
HTTP_USER_NAME : Usuario para el sitio web seguro.
HTTP_USER_PASSWORD : contrasea para el sitio web seguro.
Proxy_server : Nombre del servidor proxy requiere cuando usted est tratando de golpear a
un sitio externo de la red corporativa.
PROXY_PORT : Puerto proxy requiere cuando usted est tratando de golpear a un sitio externo
de la red corporativa.
Vamos a ver el mtodo sendRequest : esta interfaz pblica se pondr en la respuesta deseada
que usted est esperando despus se pasan los parmetros en el constructor de esta
clase. Vamos a ver lo que est sucediendo bajo su cap:
Contraer | Copiar cdigo
HttpBaseClass BaseHttp = nueva HttpBaseClass (nombre de usuario,
UserPwd, ProxyServer, ProxyPort, Request);
La lnea anterior crea una instancia de BaseHttp clase (la primera clase que ha copiado y
pegado).
Pase los parmetros deseados en BaseHttp constructor de la clase.
Dentro de tratar - la captura de bloque: HttpWebRequest WebRequest =
BaseHttp.CreateWebRequest (URI, collHeader, RequestMethod, cierto ) crea la
solicitud Web.
Esta parte = (HttpWebResponse) WebRequest.GetResponse WebResponse () crea la
respuesta web.
Si hay alguna redireccin de BaseHttp , GetRedirectUrl se almacena en ReUri , y tambin
si hay alguna cookie que se almacena en la galleta variable.
Despus de todas las validaciones, BaseHttp.GetFinalResponse se llama al pasar en las
siguientes variables:
ReUri : redirigidas o URI originales.
Cookies : Si hay alguna.
RequestMethod = "POST" . Recuerde, nosotros discutimos ms arriba que hasta el momento
estamos revisando para la redireccin, podemos establecer como mtodo de peticin Get, y
cuando estamos a punto de llamar BaseHttp.GetFinalResponse mtodo, podemos
establecer el mtodo de la peticin POST.
verdadero / falso : Este valor depende totalmente de sus necesidades. Si URI redirigido
todava quiere un acceso seguro, a continuacin, pasar como verdadero , de lo falso . En
uno de los requisitos que tuve, la primera vez URI estaba requiriendo xito seguro, pero en la
segunda URI, no se requera ninguna peticin segura porque ya me pas el valor de la cookie
sea necesario.
Construir el conjunto de la clase anterior. Abrir nuevo proyecto y establecer la referencia a esta
nueva DLL.
Ahora, usted puede llamar al mtodo sendRequest despus de pasar los valores requeridos
en el constructor de la clase anterior.
Quiero saber si esto funciona para usted. Djame saber cualquier consulta adicional que
tenga. Adems, algunos sitios requieren certificado SSL. Tengo ese cdigo tambin y si usted
los necesita, que me haga saber.
How to use HttpWebRequest and
HttpWebResponse in .NET
Introduction
Internet applications can be classified broadly into two kinds: client applications that request
information, and server applications that respond to information requests from clients. The
classic Internet client-server application is the World Wide Web, where people use browsers to
access documents and other data stored on Web servers worldwide.
Applications are not limited to just one of these roles; for instance, the familiar middle-tier
application server responds to requests from clients by requesting data from another server, in
which case it is acting as both a server and a client.
The client application makes a request by identifying the requested Internet resource and the
communication protocol to use for the request and response. If necessary, the client also
provides any additional data required to complete the request, such as proxy location or
authentication information (user name, password, and so on). Once the request is formed, the
request can be sent to the server.
Identifying Resources
The .NET Framework uses a Uniform Resource Identifier (URI) to identify the requested Internet
resource and communication protocol. The URI consists of atleast three, and possibly four,
fragments: the scheme identifier, which identifies the communications protocol for the request
and response; the server identifier, which consists of either a Domain Name System (DNS) host
name or a TCP address that uniquely identifies the server on the Internet; the path identifier,
which locates the requested information on the server; and an optional query string, which
passes information from the client to the server. For example, the URI
"http://www.MyWebSite.com/whatsnew.aspx?date=today" consists of the scheme identifier
"http", the server identifier "www. MyWebSite.com", the path "/whatsnew.aspx", and the query
string "?date=today".
After the server has received the request and processed the response, it returns the response to
the client application. The response includes supplemental information, such as the type of the
content (raw text or XML data, for example).
Developing applications that run in the distributed operating environment of today's Internet
requires an efficient, easy-to-use method for retrieving data from resources of all types.
Pluggable protocols let you develop applications that use a single interface to retrieve data
from multiple Internet protocols.
The .NET Framework uses specific classes to provide the three pieces of information required to
access Internet resources through a request/response model: the Uri class, which contains the
URI of the Internet resource you are seeking; the HttpWebRequest class, which contains a
request for the resource; and the HttpWebResponse class, which provides a container for the
incoming response.
Here, I am going to show with practical code, how to send request and receive response to
Internet/intranet sites. I am assuming that the reader possesses basic knowledge of C# and
Visual Studio.
Open a Visual studio C# class library project, copy and paste the following code up to the part
where it says End of Base Class:
Collapse | Copy Code
using System;
using System.Collections.Specialized;
using System.Net;
using System.Text;
using System.IO;

namespace BaseClassNameSpace.Web.BaseServices
{
/// <summary>
///This base class provides implementation of request
///and response methods during Http Calls.
/// </summary>

public class HttpBaseClass
{

private string UserName;
private string UserPwd;
private string ProxyServer;
private int ProxyPort;
private string Request;

public HttpBaseClass(string HttpUserName,
string HttpUserPwd, string HttpProxyServer,
int HttpProxyPort, string HttpRequest)
{
UserName = HttpUserName;
UserPwd = HttpUserPwd;
ProxyServer = HttpProxyServer;
ProxyPort = HttpProxyPort;
Request = HttpRequest;
}

/// <summary>
/// This method creates secure/non secure web
/// request based on the parameters passed.
/// </summary>
/// <param name="uri"></param>
/// <param name="collHeader">This parameter of type
/// NameValueCollection may contain any extra header
/// elements to be included in this request </param>
/// <param name="RequestMethod">Value can POST OR GET</param>
/// <param name="NwCred">In case of secure request this would be true</param>
/// <returns></returns>
public virtual HttpWebRequest CreateWebRequest(string uri,
NameValueCollection collHeader,
string RequestMethod, bool NwCred)
{
HttpWebRequest webrequest =
(HttpWebRequest) WebRequest.Create(uri);
webrequest.KeepAlive = false;
webrequest.Method = RequestMethod;

int iCount = collHeader.Count;
string key;
string keyvalue;

for (int i=0; i < iCount; i++)
{
key = collHeader.Keys[i];
keyvalue = collHeader[i];
webrequest.Headers.Add(key, keyvalue);
}

webrequest.ContentType = "text/html";
//"application/x-www-form-urlencoded";

if (ProxyServer.Length > 0)
{
webrequest.Proxy = new
WebProxy(ProxyServer,ProxyPort);
}
webrequest.AllowAutoRedirect = false;

if (NwCred)
{
CredentialCache wrCache =
new CredentialCache();
wrCache.Add(new Uri(uri),"Basic",
new NetworkCredential(UserName,UserPwd));
webrequest.Credentials = wrCache;
}
//Remove collection elements
collHeader.Clear();
return webrequest;
}//End of secure CreateWebRequest

/// <summary>
/// This method retreives redirected URL from
/// response header and also passes back
/// any cookie (if there is any)
/// </summary>
/// <param name="webresponse"></param>
/// <param name="Cookie"></param>
/// <returns></returns>
public virtual string GetRedirectURL(HttpWebResponse
webresponse, ref string Cookie)
{
string uri="";

WebHeaderCollection headers = webresponse.Headers;

if ((webresponse.StatusCode == HttpStatusCode.Found) ||
(webresponse.StatusCode == HttpStatusCode.Redirect) ||
(webresponse.StatusCode == HttpStatusCode.Moved) ||
(webresponse.StatusCode == HttpStatusCode.MovedPermanently))
{
// Get redirected uri
uri = headers["Location"] ;
uri = uri.Trim();
}

//Check for any cookies
if (headers["Set-Cookie"] != null)
{
Cookie = headers["Set-Cookie"];
}
// string StartURI = "http:/";
// if (uri.Length > 0 && uri.StartsWith(StartURI)==false)
// {
// uri = StartURI + uri;
// }
return uri;
}//End of GetRedirectURL method


public virtual string GetFinalResponse(string ReUri,
string Cookie, string RequestMethod, bool NwCred)
{
NameValueCollection collHeader =
new NameValueCollection();

if (Cookie.Length > 0)
{
collHeader.Add("Cookie",Cookie);
}

HttpWebRequest webrequest =
CreateWebRequest(ReUri,collHeader,
RequestMethod, NwCred);

BuildReqStream(ref webrequest);

HttpWebResponse webresponse;

webresponse = (HttpWebResponse)webrequest.GetResponse();

Encoding enc = System.Text.Encoding.GetEncoding(1252);
StreamReader loResponseStream = new
StreamReader(webresponse.GetResponseStream(),enc);

string Response = loResponseStream.ReadToEnd();

loResponseStream.Close();
webresponse.Close();

return Response;
}

private void BuildReqStream(ref HttpWebRequest webrequest)
//This method build the request stream for WebRequest
{
byte[] bytes = Encoding.ASCII.GetBytes(Request);
webrequest.ContentLength=bytes.Length;

Stream oStreamOut = webrequest.GetRequestStream();
oStreamOut.Write(bytes,0,bytes.Length);
oStreamOut.Close();
}
}
}//End of HttpBaseClass class

//End of Base Class
Save the above file with the name, say, HttpBaseClass.cs.
Let's go through the various pieces of the above program.
System.Net namespace provides HttpWebRequest and HttpWebResponse classes. I already
explained about these classes in the beginning.
Sytem.IO namespace provides classes to send request and receive response in streams.
This is the base class, which provides methods to request data, parse any redirection URL,
receive response and convert response (since it's coming in streams) into meaningful data.
From this class, you will create a derived class (wait, that would be next step until we finish this
class) and you can override the public methods (thats why they are defined
with virtual keyword). Let's go to the actual working of the base class code.
When you create an instance of this class, you will need to provide certain parameters to the
constructor. Parameters are:
string HttpUserName: User name
string HttpUserPwd: User password
Above two variables are required for secure sites, which require User ID and password to be
sent along with the request header. Usually, for secure sites, request header is like this:
Collapse | Copy Code
Authorization: Basic NNNNNNNNNNNNNNNNNN==
Authorization is the property, Basic is the encoding type and NNNNNNNNNNNNNNNNNN== is
the actual user ID and password encoded in Base64 format.
string HttpProxyServer, int HttpProxyPort: If your request is going to an external
site of your corporate networks, then probably you would require proxy server name and proxy
port number (usually 8080). Check your browser settings for these properties and pass them
accordingly to the constructor. You can pass empty string and 0 if you are connecting to an
intranet site.
String HttpRequest: Request Body. It can be an XML or other request text.
Let's see whats happening under the hood of CreateWebRequest method. This method is the
first step in creating request with the target URL. Parameters to be passed in this method are:
String uri: Target URI (E.g.: Google.com, Yahoo.com, yourownintranetsite.com)
NameValueCollection collHeader: A variable of type namevaluecollection. If you see
in the method at one line (in the for loop), if additional headers are required, they are being
extracted from this variable and inserted into request header. For example, your requested site
may require additional cookies to be sent in the header.
String RequestMethod: It can be POST or GET.
bool NwCred: This variable value is set based on if the site requires userID/password (if it's
secure site) or not. See in the code if its true, then
using CredentialCache and NetworkCredential classes, user ID and password are passed
in Base64 format. Right now, I have hard coded security type as Basic, but you can set other
security settings such as Digest, Kerberos, NTLM, depending on requirements.
Collapse | Copy Code
Line HttpWebRequest webrequest = (HttpWebRequest) WebRequest.Create(uri)
Creates a HttpWebRequest instance.
If you are hitting external site, outside of your corporate intranet, then this line would be
executed based on ifProxyServer variable contains server value or is being set to empty
string in the constructor at the time of creation of an instance of this class.
Collapse | Copy Code
webrequest.Proxy = new WebProxy(ProxyServer,ProxyPort);
Setting webrequest.AllowAutoRedirect = false is for handling of redirection(s) by
yourself and thats why it's set to false.
I have a question here for any geeks who read this article. When I was setting it to true, I was
getting error message, but if I used ServerXMLHttp (COM way), every redirection was handled
automatically (mystery to me)??????
Let's see the other method GetRedirectURL: this method is invoked to check if any
redirection or cookies are coming back after target URI is hit. There may be cases when there is
no redirection but still next request to URI expects some cookies back. For example, the site
where my application hits now passes back redirection URI and cookies (which contains session
ID). I hit redirected URI again with cookie in the header and then I get the final response. This is
quite evident in GetFinalResponse method in line:
Collapse | Copy Code
if (Cookie.Length > 0)
{
collHeader.Add("Cookie",Cookie);
}
This collHeader namevalue collection is again passed to CreateWebRequest method. Let
me explain the parameters passed in GetFinalResponse method:
string ReUri: Redirected URI. If there is no redirection, original URI is passed.
string Cookie: If there is any cookie from method GetRedirectURL.
string RequestMethod: POST or GET. If you think there will be some redirected URI, then
initially (whenCreateWebRequest method is called) you get GET as request method, and in
final response, you can say POST method, depending on your requirements.
bool NwCred: As explained in method CreateWebRequest.
Within this method, BuildReqStream method is called which builds the request stream
for WebRequest. In Internet communication, request text is built in the form of streams and so
is response. When response comes back in the stream, you convert it back into original format.
See the part:
Collapse | Copy Code
Encoding enc = System.Text.Encoding.GetEncoding(1252);
1252 is encoding for Windows format. Please read more about encoding and streams in MSDN.
Collapse | Copy Code
StreamReader loResponseStream =
new StreamReader(webresponse.GetResponseStream(),enc);
string Response = loResponseStream.ReadToEnd();
Before this part, you see we are declaring:
Collapse | Copy Code
HttpWebResponse webresponse;
webresponse = (HttpWebResponse)webrequest.GetResponse();
In these 2 lines, we are actually getting the response after we have created request
in CreateWebRequest method. Likewise, HttpWebRequest class is there for creating request,
so is the HttpWebResponse for getting response.
Now, let's see how we actually use the above class.
Open a new class library file in the same project, copy and paste the following code:
Collapse | Copy Code
using System;
using System.Collections.Specialized;
using System.Net;
using System.Text;
using System.IO;
using BaseClassNameSpace.Web.BaseServices;

namespace DeriveClassNameSpace.Services.Web
{

public class HttpRequestResponse
{
private string URI;
private string Request;
private string UserName;
private string UserPwd;
private string ProxyServer;
private int ProxyPort;
private string RequestMethod = "GET";

public HttpRequestResponse(string pRequest,
string pURI)//Constructor
{
Request = pRequest;
URI = pURI;
}

public string HTTP_USER_NAME
{
get
{
return UserName;
}
set
{
UserName = value;
}
}

public string HTTP_USER_PASSWORD
{
get
{
return UserPwd;
}
set
{
UserPwd = value;
}
}

public string PROXY_SERVER
{
get
{
return ProxyServer;
}
set
{
ProxyServer = value;
}
}

public int PROXY_PORT
{
get
{
return ProxyPort;
}
set
{
ProxyPort = value;
}
}

public string SendRequest()
/*This public interface receives the request
and send the response of type string. */
{
string FinalResponse="";
string Cookie="";

NameValueCollection collHeader = new NameValueCollection();

HttpWebResponse webresponse;

HttpBaseClass BaseHttp = new
HttpBaseClass(UserName,UserPwd,
ProxyServer,ProxyPort,Request);
try
{
HttpWebRequest webrequest =
BaseHttp.CreateWebRequest(URI,
collHeader, RequestMethod, true);
webresponse =
(HttpWebResponse)webrequest.GetResponse();

string ReUri =
BaseHttp.GetRedirectURL(webresponse,
ref Cookie);
//Check if there is any redirected URI.
webresponse.Close();
ReUri = ReUri.Trim();
if (ReUri.Length == 0) //No redirection URI
{
ReUri = URI;
}
RequestMethod="POST";
FinalResponse = BaseHttp.GetFinalResponse(ReUri,
Cookie, RequestMethod, true);

}//End of Try Block

catch (WebException e)
{
throw CatchHttpExceptions(FinalResponse = e.Message);
}
catch (System.Exception e)
{
throw new Exception(FinalResponse = e.Message);
}
finally
{
BaseHttp=null;
}
return FinalResponse;
} //End of SendRequestTo method

private WebException CatchHttpExceptions(string ErrMsg)
{
ErrMsg = "Error During Web Interface. Error is: "+ErrMsg ;
return new WebException(ErrMsg);
}
}//End of RequestResponse Class
}
We will see the implementation of the above class in a later stage, but before that, let's
consider whats happening inside this class. In the HttpRequestResponse constructor, the 2
parameters are:
string pRequest: Request text which would go with request body.
See BuildReqStream method inHttpBaseClass.
string pURI: Target URI (external or intranet site URI).
The public property methods are:
HTTP_USER_NAME: UserID for secure web site.
HTTP_USER_PASSWORD: Password for secure web site.
PROXY_SERVER: Proxy server name required when you are trying to hit external site from your
corporate network.
PROXY_PORT: Proxy port required when you are trying to hit external site from your corporate
network.
Let's see the method SendRequest: this public interface will get back the desired response you
are expecting after parameters in the constructor of this class are passed. Let's see what's
happening under its hood:
Collapse | Copy Code
HttpBaseClass BaseHttp = new HttpBaseClass(UserName,
UserPwd,ProxyServer,ProxyPort,Request);
The above line creates an instance of BaseHttp class (the very first class you copied and
pasted).
Pass the desired parameters in BaseHttp class constructor.
Inside of try-catch block: HttpWebRequest webrequest =
BaseHttp.CreateWebRequest(URI, collHeader, RequestMethod, true) creates the
web request.
This part webresponse = (HttpWebResponse)webrequest.GetResponse() creates the
web response.
If there is any redirection from BaseHttp, GetRedirectURL gets stored in ReUri, and also if
there is any cookie that gets stored in Cookie variable.
After all validations, BaseHttp.GetFinalResponse is called by passing in the following
variables:
ReUri: Redirected or original URI.
Cookie: If there is any.
RequestMethod = POST. Remember, we discussed above that till the time we are checking
for redirection, we can set request method as Get, and when we are about to
call BaseHttp.GetFinalResponse method, we can set the request method to POST.
true/false: This value entirely depends on your requirements. If redirected URI still wants
secure access, then pass as true, else false. In one requirement which I had, first time URI
was requiring secure hit, but in second URI, no secure request was required because it already
passed me the required cookie value.
Build the assembly for the above class. Open new project and set the reference to this new DLL.
Now, you can call the method SendRequest after passing required values in the above class
constructor.
Let me know if this works for you. Let me know any further queries you have. Also some sites
requires SSL certificate. I have that code also and if you need them, let me know.