Etiqueta: <span>linq</span>

¿Cómo utilizar sentencias if dentro de una consulta LINQ? C# VB .Net

Para poder hacer uso de sentencias if dentro de nuestras consultas por LINQ, haremos uso de Lambda.

¿Cómo utilizar un try y catch dentro de una consulta LINQ?

A continuación con un ejemplo te muestro como es posible hacerlo:


EntityDB db= new EntityDB();
var lst = from d in db.tabla.ToList() //es importante hacerlo lista
                  select new TablaViewModel
                  {
                      id = d.id,
                      //campo es string por lo cual
                      //nuestra función delegada regresara igual string
                      campo = (new Func<string>(() => {
                                                            try {
                                                                 //utilizamos if
                                                                    if(d.alguncampo==1){
                                                                         return "Activo";
                                                                    }else{
                                                                         return "Inactivo";
                                                                    }

                                                                 }
                                                            catch {
                                                                 //si ocurre un error
                                                                   return "Error";
                                                            }
                                                        }
                                                  )
                                 )()
                  };

De esta manera podemos manipular la información para lograr el resultado deseado.

Aprende Entity Framework en 10 minutos

Te mostrare como comenzar de cero a utilizar Entity Framework, además a obtener, crear, editar y eliminar datos, y todo en menos de 10 minutos.

¿Cómo utilizar un try y catch dentro de una consulta LINQ? Excepción | Exception C# VB .Net

Para poder cachar excepciones dentro de una consulta LINQ y poder manipular el error para que no truene la consulta en si misma debemos hacer uso de Lambda, esto es útil cuando nuestra base de datos puede presentar inconsistencias las cuales pueden ocasionar una excepción en ciertos casos, y podemos evitarlo de la siguiente forma:


EntityDB db= new EntityDB();
var lst = from d in db.tabla.ToList() //es importante hacerlo lista
                  select new TablaViewModel
                  {
                      id = d.id,
                      //campo es string por lo cual
                      //nuestra función delegada regresara igual string
                      campo = (new Func<string>(() => {
                                                            try {
                                                             // suponiendo que exista una referencia
                                                             // a una tabla secundaria la cual no siempre exista
                                                             // lo cual puede ocasionar una excepción
                                                             // de esta manera lo podemos manipular
                                                                 return d.tablaSecundaria.campo2;
                                                                 }
                                                            catch { return "No existe"; }
                                                        }
                                                  )
                                 )()
                  };

De esta manera nuestra consulta no tronara y podemos darle un resultado a la vista donde mostraremos nuestros datos.

¿Cómo realizar un join entre 2 base de datos distintas con entity framework y LINQ? C# #linq

No es bueno para el rendimiento hacer este tipo de consultas ya que las tablas están en bases de datos distintas, pero muchas veces es necesario para el hecho de crear un reporte, o cuando se expande un sistema con nueva tecnología y al final el cliente desea un reporte combinado entre sus sistemas viejos y los nuevos, yo les mostrare una manera de poder lograr un join entre dos bases de datos distintas.
El problema es el siguiente(es hipotético no necesariamente es real solo sirve para el ejemplo), tenemos una base de datos (BD1) con las ventas diarias guardadas en una tabla llamada ventas, se nos pide que sea mostrada la venta y a su lado los datos del domicilio de la tienda, pero nos damos cuenta que no contamos con esos datos, esos datos están en una tabla llamada tienda en una base de datos distinta (BD2), entonces necesitamos hacer un join entre las 2 bases de datos, y para hacerlo debemos tomar a consideración lo siguiente:
Debemos evaluar cual tabla tiene menos registros ya que haremos primero la consulta sobre esa tabla primero y esos datos los tendremos en memoria. En este caso la tabla tienda es la que tiene menos datos (una tienda tiene muchas ventas así que el universo es menor por sentido común). Así que primero vamos por las tiendas de la siguiente forma:

//creamos nuestro contexto de la bd2 ya que ahi esta la tabla tienda
var db2= new entitiesTiendaDB();
//obtenemos las tiendas con una consulta simple de linq
var lstTiendas = from d in db2.tiendas.ToList()
                  select d;

Ahora que a tenemos las tiendas, de la siguiente manera hacemos el join con los datos que ya tenemos en la variable lstTienda:


//creamos el contexto de db1 el cual contiene la tabla ventas
var db = new entitiesVentasDB();

//teniendo un viewmodel llamado VentasViewModel el cual tenga solo los campos que necesitamos creamos la consulta
List<VentasViewModel> lst= from d in db.ventas.ToList()
                          //nuestra tienda se une por el campo codigTienda de lstTiendas y por el mismo campo en
                          //la tabla ventas
                          join t in lstTiendas on d.codigoTienda equals t.codidoTienda into un
                          //esto hace que sea un left join,
                          // si no ponen esto solo les regresara todo como inner join
                          from x in un.DefaultIfEmpty()
                          orderby t.nombreTienda
                     select new VentasViewModel
                      {
                          idTienda = (x!=null) ? x.id : 0, //como hicimos left join podría haber datos nullos y debemos evaluar
                          nombreTienda =(x!=null) ? x.nombre : "",
                          domicilioTienda =(x!=null) ? x.domicilio : "", //asi obtenemos el domicilio
                          codigo = (x!=null )? x.codigoTienda : "",
                          total= d.total //este viene en ventas así que accedo con d
                          subtotal=d.subtotal //igual que arriba

                      };

Y así se hace la magia. Dudas en los comentarios.

Linq, introducción y ejemplos rápidos en C# .Net

Esta entrada hablare sobre LINQ, lo necesario para que comprendas fácilmente y rápido, sin tanta teoría ni palabras raras.

Linq nació por allá del 2008 y desde entonces nos ha facilitado la vida, ya que agrega funcionalidades al lenguaje de c# o Visual Basic .Net respecto cualquier almacen de datos, es decir, nos permite aplicar algo parecido a consultas de SQL a una lista, un xml, o ¿porque no?, a la misma base de datos.
Algo que el mismo Microsoft recalca en todos sus cursos es que Linq se divide en tres acciones que son:

Obtención de origen de datos.
Creación de la consulta
Ejecución de la consulta.

Terminemos de la palabrería y vayamos a los ejemplos.

El primer ejemplo es cómo podemos ordenar una lista de enteros con Linq y se puede hacer de la siguiente manera.

1. Obtención de origen de datos:

 int[] arregloEnteros = { 1, 2, 3, 5, 3, 2, 8, 9 };

2. Creación de la consulta

 
IEnumerable<int> lstEnterosOrdenados = from nums in arregloEnteros 
                                       orderby nums 
                                       select nums;

En este punto aún no se ejecuta la consulta solo la guardamos en este caso en una colección de la instancia IEnumerable. Cualquier tipo de dato que admita implícitamente la interfaz IEnumerable o alguna de sus derivaciones, se le puede aplicar LINQ.

3. Ejecución de la consulta (ahora si aquí se ejecuta la magia de LINQ)

 

foreach(int n in lstEnterosOrdenados){      
 Console.WriteLine(n);            
}

De esta manera nuestro resultado es el siguiente:

Como vemos de una manera rápida podemos realizar operaciones que son el pan de cada día.

Ahora veamos otros ejemplos para comprender mejor el alcance de LINQ:

Filtrar elementos

 
//Origen de datos 
int[] arregloEnteros = { 1, 2, 3, 5, 3, 2, 8, 9 }; 

//Consulta, utilizamos where como en sql para obtener numeros menores a 5 

IEnumerable<int> lstEnterosMenoresCinco = from nums in arregloEnteros                                                      
                                          where nums < 5                                                      
                                          select nums;

//Ejecucion 
foreach (int n in lstEnterosMenoresCinco) {         
            Console.WriteLine(n); 
}

Linq en elementos complejos


//clase Complejo, una clase que nos servirá para el ejemplo
 public class Complejo
        {
             public int numero{get;set;}
             public string cadena{get;set;}

             public Complejo(int numero, string cadena)
             {
                 this.numero = numero;
                 this.cadena = cadena;
             }

             public string imprime()
             {
                 return numero + " " + cadena;
             }
        }

          

//origen de datos            
Complejo[] lstComplejos={ 
new Complejo(1,"pato"),                                   
new Complejo(5,"perro"),                                      
new Complejo(9,"pajaro"),                                      
new Complejo(10,"pez"),                                      
new Complejo(2,"ave"),                                      
new Complejo(4,"gusano"),                                    
};       

//consulta            
IEnumerable<Complejo> lstComplejosConP =from d in lstComplejos                                                  
where d.cadena.StartsWith("p")                                                    select d;            

//ejecución de consulta            
foreach(Complejo c in lstComplejosConP){                  
   Console.WriteLine(c.imprime());            

}

Linq en elementos complejos obtener una colección reducida

//utilizamos la misma clase Complejo

//origen de datos            
Complejo[] lstComplejos={ 
new Complejo(1,"pato"),                                      
new Complejo(5,"perro"),                                      
new Complejo(9,"pajaro"),                                      
new Complejo(10,"pez"),                                      
new Complejo(2,"ave"),                                      
new Complejo(4,"gusano"),                                    
};

//Consulta, reducimos la clase Complejo a una lista de cadenas

IEnumerablex lstSoloCadenas = from d in lstComplejos
select d.cadena; 

//ejecución de consulta   

foreach (string s in lstSoloCadenas){
   
    Console.WriteLine(s);    

}

Con esto es más que suficiente para que hayan entendido LINQ y su potencial, de aquí en adelante solo les queda practicar y ver lo practico que es esta característica en .Net.