public TModelo Get(int id)
{
TModelo objeto;
//webrequest siempre es con método GET.
var request = WebRequest.Create(url + "/" + id);
if (auth)
{
request.Credentials = new NetworkCredential(user, pass);
}
request.Method = "GET";
var response = request.GetResponse();
//stream es el canal de comunicacion/flujo de datos que se abre entre aplicaciones
//que dentro lleva ya la respuesta. De base la información viaja como bytes
using (var stream = response.GetResponseStream())
{
//reader permite leer datos del stream.
//Streamreader transforma él solo de bytes a texto
using (var reader = new StreamReader(stream))
{
var serializado = reader.ReadToEnd();
//transforma el texto en una lista de objetos para trabajar con ella.
objeto = Serializacion <TModelo> .Deserializar(serializado);
}
}
return(objeto);
}
//Para que un metodo sea asincrono hay que marcarlo como Task y async
//Para esperar y poder utilizar lo que devuelve una llamada asincrona
//se usa await
public async Task Update(TModelo model)
{
var datos = Serializacion <TModelo> .Serializar(model);
//No se usa webrequest porque puede/suele fallar en los metodos post/put/delete
//Se usa el httppclienthandler en su lugar.
using (var handler = new HttpClientHandler())
{
if (auth)
{
handler.Credentials = new NetworkCredential(user, pass);
}
//Crea un client pasandole la información del handler(que tiene los datos de autenticacion)
using (var client = new HttpClient(handler))
{
//stringcontent manipula una cadena de texto plano para que la pueda interpretar
//una cabecera http
var contenido = new StringContent(datos);
//indicas en la cabecera el tipo de contenido que tiene.
contenido.Headers.ContentType = new MediaTypeHeaderValue("application/json");
//le indicas q espere(await) para que no se cierre la conexión del using
//mientras está haciendo el put
var respuesta = await client.PutAsync(new Uri(url), contenido);
if (!respuesta.IsSuccessStatusCode)
{
throw new Exception("Error al modificar");
}
}
}
}
public async Task <TModelo> Add(TModelo model)
{
var datos = Serializacion <TModelo> .Serializar(model);
using (var handler = new HttpClientHandler())
{
if (auth)
{
handler.Credentials = new NetworkCredential(user, pass);
}
using (var client = new HttpClient(handler))
{
var contenido = new StringContent(datos);
contenido.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var r = await client.PostAsync(new Uri(url), contenido); // poniendo el await nos aseguramos que no se cierra la conexion hasta que se haya mandado el contenido.
if (!r.IsSuccessStatusCode)
{
throw new Exception("Puta mierda");
}
var objSerializado = await r.Content.ReadAsStringAsync();
return(Serializacion <TModelo> .Deserializar(objSerializado));
}
}
}
//Hay que ponerlo como asincrono
public async Task Update(TModelo model)
{
//Datos = objeto que le mando serializado
var datos = Serializacion <TModelo> .Serializar(model);
//HttpClient: Crea un cliente y se maneja atraves del Handler
//Se encarga de autenticar(credenciales), crear las cabeceras...
using (var handler = new HttpClientHandler())
{
//En el handler se podria meter mas informacion
if (auth)
{
handler.Credentials = new NetworkCredential(user, pass);
}
using (var client = new HttpClient(handler))
{
var contenido = new StringContent(datos);
contenido.Headers.ContentType = new MediaTypeHeaderValue("application/json");
//Si no le metemos el await nos aseguramos que no cierra el client hasta que nosotros se lo digamos. Ya que si lo cierra nos quedamos sin informacion asi que es mejor ponerlo.
//El putAsync devuelve un task
//Si no le haces un await se le podria meter un callback --> .ContinueWith
//client.PutAsync(new Uri(url), contenido).ContinueWith(...);
var r = await client.PutAsync(new Uri(url), contenido);
if (!r.IsSuccessStatusCode)
{
throw new Exception("Fallo gordo");
}
}
}
}
public async Task <TModelo> Add(TModelo model)
{
var datos = Serializacion <TModelo> .Serializar(model);
using (var handler = new HttpClientHandler())
{
if (auth)
{
handler.Credentials = new NetworkCredential(user, pass);
}
using (var client = new HttpClient(handler))
{
var contenido = new StringContent(datos);
contenido.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var r = await client.PostAsync(new Uri(url), contenido);
if (!r.IsSuccessStatusCode)
{
throw new Exception("Fallo gordo");
}
var objSerializado = await r.Content.ReadAsStringAsync();
return(Serializacion <TModelo> .Deserializar(objSerializado));
}
}
}
public List <TModelo> Get(String paramUrl = null)
{
List <TModelo> lista;
var urlDest = url;
if (paramUrl != null)
{
urlDest += paramUrl;
}
var request = WebRequest.Create(urlDest);
if (auth)
{
request.Credentials = new NetworkCredential(user, pass);
}
request.Method = "GET";
var response = request.GetResponse();
using (var stream = response.GetResponseStream())
{
using (var reader = new StreamReader(stream))
{
var serializado = reader.ReadToEnd();
lista = Serializacion <List <TModelo> > .Deserializar(serializado);
}
}
return(lista);
}
public List <TModelo> Get(String paramUrl = null)
{
List <TModelo> lista;
var urlDest = url;
if (paramUrl == null)
{
urlDest += paramUrl;
}
var request = WebRequest.Create(urlDest);
if (auth)
{
request.Credentials = new NetworkCredential(user, pass); // este metodo coge el usuario y el password los separa por dos puntos : y lo convierte a base 64
}
request.Method = "GET";
var response = request.GetResponse();
using (var stream = response.GetResponseStream())
{
using (var reader = new StreamReader(stream)) // stream es un canal que permite leer y escribir datos
{
var serializado = reader.ReadToEnd();
lista = Serializacion <List <TModelo> > .Deserializar(serializado);
}
}
return(lista);
}
public async Task Update(TModelo model)
{
// await: bloquea hasta que termine
var datos = Serializacion <TModelo> .Serializar(model);
using (var handler = new HttpClientHandler())
{
// define la cabecera de auenticación
if (auth)
{
handler.Credentials = new NetworkCredential(user, pass);
}
using (var client = new HttpClient(handler))
{
var contenido = new StringContent(datos); // mi objeto serializado
contenido.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var r = await client.PutAsync(new Uri(url), contenido); // no cierra hasta que termine
if (!r.IsSuccessStatusCode)
{
throw new Exception("Fallo gordo");
}
}
}
}
public List <TModelo> Get(String paramUrl = null)
{
List <TModelo> lista;
var urlDest = url;
if (paramUrl != null)
{
urlDest += paramUrl;
}
var request = WebRequest.Create(urlDest);
if (auth)
{
request.Credentials = new NetworkCredential(user, pass);
}
request.Method = "GET";
var response = request.GetResponse();
// el stream es la tuberia, es el canal que permite obtener datos
// dentro lleva la respuesta
// stream se usa para la secuencia de datos,
// son bytes, array de bytes
using (var stream = response.GetResponseStream())
{
using (var reader = new StreamReader(stream)) // convierte
{
var serializado = reader.ReadToEnd(); // lea desde actual posicion hasta al final
lista = Serializacion <List <TModelo> > .Deserializar(serializado);
}
}
return(lista);
}
//aync firma que ponemos en el metodo para forzar a que sea un metodo asincrono
//await esperar a que termine una operacion para lanzar otra ?
public async Task Update(TModelo model)
{
var datos = Serializacion <TModelo> .Serializar(model);
//HttpClientHandler se encarga de manejar las peticiones del HttpClient
//cabeceras, autenticacion etc.
using (var handler = new HttpClientHandler())
{
if (auth)
{
handler.Credentials = new NetworkCredential(user, pass);
}
//HttpCliente crea un cliente nativo puro HTTP(como si abrieramos una especia de navegador web)
using (var client = new HttpClient(handler))
{
//StringContent le doy una cadena de texto plano y la prepara para enviarla en una peticion HTTP
var contenido = new StringContent(datos);
contenido.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var r = await client.PutAsync(new Uri(url), contenido);
if (!r.IsSuccessStatusCode)
{
throw new Exception("Fallo al actualizar");
}
}
}
}
/// <summary>
/// Busqueda por clave primeria
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public TModelo Get(int id)
{
TModelo objeto;
var request = WebRequest.Create(url + "/" + id);
if (auth)
{
request.Credentials = new NetworkCredential(user, pass);
}
request.Method = "GET";
var response = request.GetResponse();
// el stream es la tuberia, es el canal que permite obtener datos
// dentro lleva la respuesta
// stream se usa para la secuencia de datos,
// son bytes, array de bytes
using (var stream = response.GetResponseStream())
{
using (var reader = new StreamReader(stream)) // convierte
{
var serializado = reader.ReadToEnd(); // lea desde actual posicion hasta al final
objeto = Serializacion <TModelo> .Deserializar(serializado);
}
}
return(objeto);
}
public TModelo Get(int id)
{
TModelo objeto;
var request = WebRequest.Create(url + "/" + id);
if (auth)
{
request.Credentials = new NetworkCredential(user, pass); // este metodo coge el usuario y el password los separa por dos puntos : y lo convierte a base 64
}
request.Method = "GET";
var response = request.GetResponse();
using (var stream = response.GetResponseStream())
{
using (var reader = new StreamReader(stream)) // stream es un canal que permite leer y escribir datos
{
var serializado = reader.ReadToEnd();
objeto = Serializacion <TModelo> .Deserializar(serializado);
}
}
return(objeto);
}
//Primero se hace los GET.
public List <TModelo> Get(String paramUrl = null)
{
List <TModelo> lista;
var request = WebRequest.Create(url);
if (auth)
{
//NetworkCreantial: Genera unas credenciales (usuario y pass)
request.Credentials = new NetworkCredential(user, pass);
}
//Steam sirve como canal de conexion para enviar datos entre dos puntos
//Los stream viene en datos binarios por eso hay que transformarlo
request.Method = "GET";
var response = request.GetResponse();
using (var stream = response.GetResponseStream())
{
//Creamos un reader para leer datos de un stream como si fueran texto
using (var reader = new StreamReader(stream))
{
//ReadToEnd:Lee desde donde estas hasta el final, esto ya lo
//devuelve como un string. El ReadLine, solo la linea
var serializado = reader.ReadToEnd();
lista = Serializacion <List <TModelo> > .Deserializar(serializado);
}
}
return(lista);
}
public async Task Update(TModel model)
{
var datos = Serializacion <TModel> .Serializar(model);
//se crea el HttpClientHandler para poder añadir credenciales de autenticacion
using (var handler = new HttpClientHandler())
{
if (auth)
{
handler.Credentials = new NetworkCredential(user, pass);
}
using (var client = new HttpClient(handler))
{
var contenido = new StringContent(datos);
contenido.Headers.ContentType = new MediaTypeHeaderValue("application/json");
//el await es para que se espere a ejecutar
var r = await client.PutAsync(new Uri(url), contenido);
if (!r.IsSuccessStatusCode)
{
throw new Exception("Fail on update");
}
}
}
}
public TModel Get(int id)
{
TModel objeto;
//para trabajar con peticiones hhtp tenemos WebRequest(trabaja con peticiones utilizando GET) y el HttpClient
var request = WebRequest.Create(url);
if (auth)
{
//para autenticar
request.Credentials = new NetworkCredential(user, pass);
}
request.Method = "GET";
//obtiene la respuesta de la peticion
var response = request.GetResponse();
//desde la respuesta obtiene el stream(contenido en bytes) de la misma
using (var stream = response.GetResponseStream())
{
//crea un lector de stream para leer el contenido
using (var reader = new StreamReader(stream))
{
var serializado = reader.ReadToEnd();
objeto = Serializacion <TModel> .Deserializar(serializado);
}
}
return(objeto);
}
public TModelo Get(int id)
{
TModelo objeto;
var request = WebRequest.Create(url + "/" + id);
if (auth)
{
request.Credentials = new NetworkCredential(user, pass);
}
request.Method = "GET";
var response = request.GetResponse();
using (var stream = response.GetResponseStream())
{
using (var reader = new StreamReader(stream))
{
var serializado = reader.ReadToEnd();
objeto = Serializacion <TModelo> .Deserializar(serializado);
}
}
return(objeto);
}
public List <TModelo> Get(String paramUrl = null)
{
//Lista de objetos
List <TModelo> lista;
var urlDest = url;
if (paramUrl != null)
{
urlDest += paramUrl;
}
//WebRequest hace peticiones solo por GET
var request = WebRequest.Create(urlDest);
//Si me tengo que autenticar sobre la WebApi...
if (auth)
{
//NetWorkCredential crea unas credenciales de autenticacion
//Genera una cabecera que pone basic y en base64 añade el user:pass
//Una API Rest siempre tiene que ir cifrada
request.Credentials = new NetworkCredential(user, pass);
}
request.Method = "GET";
var response = request.GetResponse();
//Cuando se necesita conectar con algun flujo de datos externo a la aplicacion se usa un stream
//stream es un flujo de datos
//Los stream abren un canal de comunicacion para que pueda leer o mandar datos hacia algo externo a nuestra aplicacion
using (var stream = response.GetResponseStream())
{
//StreamReader crea una herramienta para poder leer ese flujo de datos (lo que le llega son bytes y los transforma en texto)
using (var reader = new StreamReader(stream))
{
var serializado = reader.ReadToEnd();
lista = Serializacion <List <TModelo> > .Deserializar(serializado);
}
}
return(lista);
}
public List <TModel> Get(String paramUrl = null)
{
List <TModel> lista;
var urlDest = url;
if (paramUrl != null)
{
urlDest += paramUrl;
}
//para trabajar con peticiones hhtp tenemos WebRequest(trabaja con peticiones utilizando GET) y el HttpClient
var request = WebRequest.Create(urlDest);
if (auth)
{
//para autenticar
request.Credentials = new NetworkCredential(user, pass);
}
request.Method = "GET";
//obtiene la respuesta de la peticion
var response = request.GetResponse();
//desde la respuesta obtiene el stream(contenido en bytes) de la misma
using (var stream = response.GetResponseStream())
{
//crea un lector de stream para leer el contenido
using (var reader = new StreamReader(stream))
{
var serializado = reader.ReadToEnd();
lista = Serializacion <List <TModel> > .Deserializar(serializado);
}
}
return(lista);
}