252. Separar una lista en listas mas pequeñas de un tamaño definido

 Les dejo este codigo para separar una lista en listas mas pequeñas esto llega a ser util cuando se desea dividir el procesamiento de forma fisica

public static IEnumerable<List<T>> DivideLista<T>(List<T> lista, int tamano)  
{        
    for (int contador = 0; contador < lista.Count; contador += tamano) 
    { 
        yield return lista.GetRange(i, Math.Min(tamano, lista.Count - i)); 
    }   

} 

Felices lineas

251. Buscar un archivo en todos los subdirectorios en c#

 Una actividad muy sencilla, se emplea la siguiente instruccion:

List<string> Archivos = Directory.GetFiles(args[0],"*", SearchOption.AllDirectories).ToList();

Felices Lineas

227. Unir pdfs

En algunas ocasiones necesitamos manipular pdfs como desarrolladores en este caso una de las herramientas que mas nos ayuda es itextsharp, y es la que emplearemos en este caso.

El caso que presento yo tengo pdf, y estos se deben unir en un solo pdf mayor, para ello vamos ha hacer lo siguiente, primero, vamos a agregar la referencia a nuestro proyecto.

Ahora lo que vamos ha hacer es lo siguiente:

1. Vamos a crear un nuevo pdf
2. Vamos a abrir los pdf y a copiar su contenido el nuevo pdf
3. Cerramos el pdf

Así de sencillo.

Les dejo el código para hacer esto

using iTextSharp.text;
using iTextSharp.text.pdf;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace UnirPdf
{
    class Program
    {
        static void Main(string[] args)
        {
            List<string> pdf = new List<string>();
            pdf.Add(@"C:\f\A.pdf");
            pdf.Add(@"C:\f\B.pdf");
            UnirPdf(pdf, @"C:\f\C.pdf");
        }
        public static void UnirPdf(List<string> archivos, string salida)
        {
            Document document = new Document();
            using (FileStream newFileStream = new FileStream(salida, FileMode.Create))
            {
                PdfCopy writer = new PdfCopy(document, newFileStream);
                if (writer == null)
                {
                    return;
                }
                document.Open();
                foreach (string archivo in archivos)
                {
                    PdfReader reader = new PdfReader(archivo);
                    reader.ConsolidateNamedDestinations();
                    for (int i = 1; i <= reader.NumberOfPages; i++)
                    {
                        PdfImportedPage page = writer.GetImportedPage(reader, i);
                        writer.AddPage(page);
                    }
                    PRAcroForm form = reader.AcroForm;
                    if (form != null)
                    {
                        writer.CopyDocumentFields(reader);
                    }
                    reader.Close();
                }
                writer.Close();
                document.Close();
            }
        }
    }
}

Felices lineas

217. Convertir JSON a las clases correspondientes en C#

Json.Net se ha convertido en una biblioteca muy útil para poder hacer uso de JSON, entre las funciones de la biblioteca se encuentra el hecho de serializar y deserializar clases.

En este ejemplo vamos a suponer que tenemos un JSON y queremos serializarlo para poder manipularlo, ¿Cómo haremos esto? es sencillo, consideremos el siguiente JSON

[{"faceId":"bbb1c3d3-7e0b-4d03-826e-b5cef7afc660","faceRectangle":{"top":241,"left":271,"width":187,"height":187},"faceAttributes":{"smile":0.0,"headPose":{"pitch":-0.4,"roll":-2.2,"yaw":7.7},"gender":"male","age":40.0,"facialHair":{"moustache":0.6,"beard":0.4,"sideburns":0.1},"glasses":"ReadingGlasses","emotion":{"anger":0.0,"contempt":0.001,"disgust":0.0,"fear":0.0,"happiness":0.0,"neutral":0.984,"sadness":0.015,"surprise":0.0},"blur":{"blurLevel":"low","value":0.24},"exposure":{"exposureLevel":"goodExposure","value":0.66},"noise":{"noiseLevel":"low","value":0.01},"makeup":{"eyeMakeup":false,"lipMakeup":true},"accessories":[{"type":"glasses","confidence":0.99}],"occlusion":{"foreheadOccluded":false,"eyeOccluded":false,"mouthOccluded":false},"hair":{"bald":0.17,"invisible":false,"hairColor":[{"color":"brown","confidence":0.99},{"color":"black","confidence":0.81},{"color":"gray","confidence":0.31},{"color":"blond","confidence":0.25},{"color":"red","confidence":0.13},{"color":"other","confidence":0.09}]}}}]

El primer paso es obtener las clases correspondientes a el, esto lo podemos hacer de forma manual o entrar en la pagina:

http://json2csharp.com/

Y en esta pagina vamos a colocar el JSON generándonos las clases necesarias

public class FaceRectangle
{
    public int top { get; set; }
    public int left { get; set; }
    public int width { get; set; }
    public int height { get; set; }
}
public class HeadPose
{
    public double pitch { get; set; }
    public double roll { get; set; }
    public double yaw { get; set; }
}
public class FacialHair
{
    public double moustache { get; set; }
    public double beard { get; set; }
    public double sideburns { get; set; }
}
public class Emotion
{
    public double anger { get; set; }
    public double contempt { get; set; }
    public double disgust { get; set; }
    public double fear { get; set; }
    public double happiness { get; set; }
    public double neutral { get; set; }
    public double sadness { get; set; }
    public double surprise { get; set; }
}
public class Blur
{
    public string blurLevel { get; set; }
    public double value { get; set; }
}
public class Exposure
{
    public string exposureLevel { get; set; }
    public double value { get; set; }
}
public class Noise
{
    public string noiseLevel { get; set; }
    public double value { get; set; }
}
public class Makeup
{
    public bool eyeMakeup { get; set; }
    public bool lipMakeup { get; set; }
}
public class Occlusion
{
    public bool foreheadOccluded { get; set; }
    public bool eyeOccluded { get; set; }
    public bool mouthOccluded { get; set; }
}
public class HairColor
{
    public string color { get; set; }
    public double confidence { get; set; }
}
public class Hair
{
    public double bald { get; set; }
    public bool invisible { get; set; }
    public List<HairColor> hairColor { get; set; }
}
public class FaceAttributes
{
    public double smile { get; set; }
    public HeadPose headPose { get; set; }
    public string gender { get; set; }
    public double age { get; set; }
    public FacialHair facialHair { get; set; }
    public string glasses { get; set; }
    public Emotion emotion { get; set; }
    public Blur blur { get; set; }
    public Exposure exposure { get; set; }
    public Noise noise { get; set; }
    public Makeup makeup { get; set; }
    public List<object> accessories { get; set; }
    public Occlusion occlusion { get; set; }
    public Hair hair { get; set; }
}
public class RootObject
{
    public string faceId { get; set; }
    public FaceRectangle faceRectangle { get; set; }
    public FaceAttributes faceAttributes { get; set; }
}

Estas clases las agregamos a nuestro proyecto.

Ahora únicamente efectuamos esta llamada

List<RootObject> caras= JsonConvert.DeserializeObject<List<RootObject>>(contentString);


Felices lineas

206. Obtener el audio de un video C#

El siguiente código es muy útil ya que nos permite extraer el sonido de un video, una gota mas de código para este acordeon.


        static void Main(string[] args)
        {
            var inputFile = new MediaFile { Filename = args[0] };
            var outputFile = new MediaFile { Filename = args[1] };
            using (var engine = new Engine())
            {
                engine.GetMetadata(inputFile);
                engine.Convert(inputFile, outputFile);
            }
        }


Felices líneas

203. Descargar un video de youtube con C#

Este codigo es muy sencillo, pero muy útil cuando se requiere conservar una serie de videos que se encuentran en la plataforma YouTube.

Para poder descargar un video primero debemos instalar el paquete nuget llamado

VideoLibrary

Una vez que tenemos instalado el paquete, escribiremos el siguiente codigo

 static void Main(string[] args)
        {
            Console.WriteLine("Este programa emplea un parametros, la ruta del video ");
            var videodescarga= YouTube.Default;
            var videodescargado= videodescarga.GetVideo(args[0]);
            File.WriteAllBytes(videodescargado.FullName, vid.GetBytes());
        }

Como pueden observar el código es muy sencillo, ya que establece primero la fuente de donde obtendremos el video

var videodescarga= YouTube.Default;

Obtiene el video

var videodescargado= videodescarga.GetVideo(args[0]);

y escribe el video en una ruta

File.WriteAllBytes(videodescargado.FullName, vid.GetBytes());



La mano invisible controla el mundo

185. Obtener todas las columnas de un datareader C#

Cuando tenemos un datareader, es muy común que necesitemos conocer las columnas que lo integran, para ello se emplea el siguiente codigo



                        SqlDataReader dr = cm.ExecuteReader();
                        Console.WriteLine("Determinando los campos de la tabla");
                        List<string> Columnas = new List<string>();
                        Console.Write("\n");
                        for (int i=0;i<dr.FieldCount;i++)
                        {
                            Columnas.Add(dr.GetName(i));
                            Console.Write(dr.GetName(i));
                            Console.Write(" ");
                        }


La mano invisible controla el mundo

181. Obtener los nombres de las columnas de una tabla desde SQL.

Siempre la forma mas rápida de acceso a una base de datos es usar características del lenguaje mas cercanas a código maquina, en este caso ADO.Net forma parte del núcleo de .net, por lo que siempre sera mas rápido.

Dentro del mismo ADO.Net hay funciones mas rápidas que otras, el dataReader, por su tamaño es mas pequeño y mas rápido que algún otro método de acceso a datos, por ello el siguiente código, es muy rápido para obtener los nombres de todos los campos.


                        SqlDataReader dr = cm.ExecuteReader();
                        Console.WriteLine("Determinando los campos de la tabla");
                        List<string> Columnas = new List<string>();
                        Console.Write("\n");
                        for (int i=0;i<dr.FieldCount;i++)
                        {
                            Columnas.Add(dr.GetName(i));
                            Console.Write(dr.GetName(i));
                            Console.Write(" ");
                        }

La mano invisible controla el mundo

174. Ajustar tamaño de una imagen C#

La siguiente función, permite ajustar el tamaño de un bitmap en C#


public Bitmap AjustarImagen(Bitmap imagen, Size Tamano)
{
                Bitmap imagenproceso = new Bitmap(Tamano.Width, Tamano.Height);
                using (Graphics g = Graphics.FromImage((Image)imagenproceso))
                {
                    g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                    g.DrawImage(imgagen, 0, 0, Tamano.Width, Tamano.Height);
                }
                return imagenproceso ;
   }


La mano invisible controla al mundo

146. Lynq transformar objetos

Lynq nos permite manipular datos de una manera ágil y sencilla, en este ejemplo lo que vamos a aprender es como copiar datos entre 2 objetos que tienen una estructura diferente.

El select que estamos haciendo desde lynq lo que nos permite es crear un nuevo objeto (el objeto se crea al efectuar el select) y se asigna a un nuevo objeto, de esta manera se deja que el compilador se encargue de establecer la mejor opción para la copia entre objetos, evitando establecer una lógica de forma manual.

Veamos el ejemplo

namespace CopiarDatos
{
 
    public class Primaria
    {
        public string Nombre { get; set; }
        public string sexo { get; set; }
        public int Numero { get; set; }
        public Boolean paso { get; set; }
    }
 
    public class Secundaria
    {
        public string Nombre { get; set; }
        public string sexo { get; set; }
        public int grupo { get; set; }
        public int ubicacion { get; set; }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            List<Primaria> primaria = new List<Primaria>();
            primaria.Add(new Primaria() { Nombre = "Juan Perez", 

                             Numero = 15, sexo = "H",paso=true });
            primaria.Add(new Primaria() { Nombre = "Raquel Perez", 

                             Numero = 17, sexo = "H", paso = true });
            primaria.Add(new Primaria() { Nombre = "Alejandra Perez", 

                             Numero = 165, sexo = "H", paso = false });
            primaria.Add(new Primaria() { Nombre = "Miguel Perez", 

                             Numero = 145, sexo = "H", paso = true });
            primaria.Add(new Primaria() { Nombre = "Raciel Perez", 

                             Numero = 155, sexo = "M", paso = false });
            primaria.Add(new Primaria() { Nombre = "Juana Perez", 

                             Numero = 415, sexo = "M", paso = false });
            primaria.Add(new Primaria() { Nombre = "Leonardo Perez", 

                             Numero = 135, sexo = "M", paso = false });
            primaria.Add(new Primaria() { Nombre = "Miguel Perez", 

                             Numero = 135, sexo = "M", paso = false });
            primaria.Add(new Primaria() { Nombre = "Angel Perez", 

                             Numero = 135, sexo = "M", paso = false });
            primaria.Add(new Primaria() { Nombre = "Rafael Perez", 

                             Numero = 115, sexo = "M", paso = false });
 
            List<Secundaria> x = (from a in primaria 

                 where a.paso == false select new Secundaria { 

                              Nombre = a.Nombre, sexo = a.sexo }).ToList();
 
            foreach(Secundaria objloop in x)
            {
                Console.WriteLine(objloop.Nombre + " - " + 

                                  objloop.grupo + " - " + 

                                  objloop.sexo + " - " + 

                                  objloop.ubicacion);                
            }
            Console.ReadLine();
        }
    }
}

¿Cual es la magia?

 List<Secundaria> x = (from a in primaria where a.paso == false 

       select new Secundaria { Nombre = a.Nombre, sexo = a.sexo }).ToList();

Esta linea es la magia, al momento de generar el select, indicamos que se cree un nuevo objeto y la asignación que tendrá de los valores

 select new Secundaria { Nombre = a.Nombre, sexo = a.sexo }).ToList();

Así llenamos los objetos de una manera eficiente, tanto para el compilador como para el programador.


Felices Lineas

140. Lamda I

Así como lo mencione en el post anterior, nuestra labor es manejar datos, comprender analizar, .net nos brinda gran apoyo al momento de describir las instrucciones que queremos emplear, pero debemos saber de que herramientas contamos.

Las expresiones Lamda, es una forma en que se puede describir una serie de instrucciones de una forma concisa, que facilita la lectura al momento de efectuar una operación, la expresión lamda simplifica la escritura del código, escribiendo en este mismo operaciones que antes requerían una mayor estructura (uso de delegados).

¿Como la construimos?

C# nos entrega funciones preparadas para el uso de expresiones lambda, la expresión lamda es sencilla, se requiere solo una invocación al objeto y después al elemento del mismo siguiendo la estructura de la función que invocamos.

hagamos un ejemplo:

La aplicación tiene exactamente el mismo comportamiento qe la que usamos en el post 139. la diferencia es la forma en la que escribimos en código, en este caso en ves de emplear una expresión de lynq usamos expresiones lamda

var lista =  lstAlumno.Where(c => c.Edad > 10);

si la comparamos contra la expresión de linq

var lista = from c in lstAlumno where c.Edad > 15 select c;

en este caso se ve mas sencilla la representación con lamda, pero conforme la complejidad se incrementa linq ofrece grandes ventajas, en próximos post incrementaremos la complejidad de las consultas para compararlas entre ellas.


Felices lineas

139. Linq I

Estamos en un mundo en el que la información cobra vida, nunca antes en la historia de la humanidad se había tenido tal acceso a la información, sin embargo, la información es tanta que ha perdido el orden, como desarrolladores debemos poder analizar esta información, día a día se nos dan mas herramientas para hacer este tipo de análisis.

Así pues revisemos que opciones tenemos para poder manipular eficientemente la información.

¿Que es Lynq? 

Es un componente de la plataforma .NET que permite agregar capacidades de consulta de manera nativa a los lenguajes de .NET

Lynq nos permite tener acceso a objetos de datos y explorarlos de una manera sencilla.

Si sabes SQL sabes Lynq

veamos un ejemplo::

Revisemos la consulta

var lista = from c in lstAlumno where c.Edad > 15 select c;

Que hace, crea un objeto c que toma los datos de lstAlumno, busca en ese todos aquellos que tengan una edad mayor a 15 años y genera el nuevo objeto

Si ejecutamos el programa:

Felices Lineas

136.Generar una cadena aleatoria de manera agil

Esta es una función rápida para generar una cadena alfanumérica aleatoria

 public string GeneraCadenaAleatoria(int longitud)

        {

            using (MD5 md5Hash = MD5.Create())

            {

                

                StringBuilder sb = new StringBuilder();

                while (sb.Length < longitud)

                {

                    byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(Guid.NewGuid().ToString());

                    byte[] hash = md5Hash.ComputeHash(inputBytes);

                    sb.Append(Convert.ToBase64String(hash));

                }

                return sb.ToString().Substring(0, longitud);

            }

        }

Felices lineas

112. Lynq Group by con multiples columnas

Lynq es una herramienta muy poderosa ya que nos permite manejar y manipular datos de una manera muy sencilla, es importante que todo desarrollador de C# la maneje de la manera correcta, en esta ayuda rápida, vamos a mostrar como agrupar una lista con mas de una columna.

En este caso es de gran ayuda un método anónimo, con el crearemos la estructura que entenderá Groupby para poder efectuar la agrupación.

Detalle.GroupBy(s => new { s.Impuesto, s.Factor, s.Tasa });

considerando que detalle es un tipo de datos complejo en un generic.


Felices líneas

111. Obtener los tributos duplicados de una lista

Un caso muy especial en las listas, es que muchas veces deseamos buscar los elementos duplicados, a que me refiero.

Supongamos que tenemos la siguiente lista

1,5,6,7,7,8,9

Yo esperaría obtener los números duplicados, es decir  7

¿Cómo lo hago?

Es muy fácil por medio de lynq

List<String> duplicados = Impuesto.GroupBy(s => s).SelectMany(grp => grp.Skip(1)).ToList();

Agrupamos la lista que deseamos validar, y le pedimos que se salte aquellos en los que solo encuentre 1

Felices Líneas

110. Unir archivos XSD

El esquema de un XML, nos da el formato del mismo, nos ayuda por que de esta forma tenemos el XML definido, sabemos que campos puede contener, de que tipo serán estos y en que lugar se deben encontrar estos.

Una ventaja de los archivos de formato XSD es que el esquema puede encontrarse definido en mas de un archivo, esto nos permite comprender el XML y separarlo en cada una de sus partes, pero una gran desventaja es que durante la validación es necesario unir el archivo en un solo XSD, eliminando todos aquellos atributos, tipos de datos o nodos duplicados

Una forma de eliminar estas entidades es por medio de la siguiente función:


//La función recibe un XMLSchemaSet que ya se encuentra cargado y un esquema que en ese momento se encuentra en disco
public XmlSchemaSet MergeSchemas(XmlSchemaSet schemaSet1, string schema2)
{
//Es necesario compilar el esquema para poderlo emplear y para validar que este es un esquema valido
     schemaSet1.Compile();
//Leemos el segundo esquema y lo compilamos
     XmlSchemaSet schemaSet2 = new XmlSchemaSet();
     schemaSet2.Add(null, schema2);
     schemaSet2.Compile();

//Se deben efectuar 3 validaciones por las variables que se encuentran en el XSD y se deben eliminar los elementos duplicados, es importante mencionar que se quitan los elementos duplicados pero este proceso no tiene la inteligencia para determinar cual de los 2 elementos tiene la ultima versión del mismo, este método se hace considerando que ambos elementos son iguales y que se busca que solo uno de ellos se conserve para que durante la validación de esquema no se genere un error de validación por un elemento duplicado. También es importante considerar que los tipos de dato se agreguen al XSD por medio de un import para que los XSD se encuentren completos al momento de compilarlos.

foreach (XmlSchemaElement el1 in schemaSet1.GlobalElements.Values)
{
     foreach (XmlSchemaElement el2 in schemaSet2.GlobalElements.Values)
     {
          if (el2.QualifiedName.Equals(el1.QualifiedName))
          {
               ((XmlSchema)el2.Parent).Items.Remove(el2);
               break;
           }
      }
}

foreach (XmlSchemaAttribute el1 in schemaSet1.GlobalAttributes.Values)
{
       foreach (XmlSchemaAttribute el2 in schemaSet2.GlobalAttributes.Values)
       {
             if (el2.QualifiedName.Equals(el1.QualifiedName))
             {
                   ((XmlSchema)el2.Parent).Items.Remove(el2);
                   break;
              }
       }
}
//Es muy importante que en este caso el valor se guarde en un tipo objeto, por que se pueden recibir diversos tipos de datos y estos deben ser analizados
foreach (Object el1 in schemaSet1.GlobalTypes.Values)
{
     foreach (Object el2 in schemaSet2.GlobalTypes.Values)
     {
          if (el1.GetType() == typeof(XmlSchemaSimpleType))
          {                      
                XmlSchemaSimpleType elt1 = (XmlSchemaSimpleType)el1;
                if (el2.GetType() == typeof(XmlSchemaSimpleType))
                {
                      XmlSchemaSimpleType elt2 = (XmlSchemaSimpleType)el2;
                      if (elt2.QualifiedName.Equals(elt1.QualifiedName))
                      {
                           ((XmlSchema)elt2.Parent).Items.Remove(elt2);
                           break;
                       }
                  }
             }
            
             if (el1.GetType() == typeof(XmlSchemaComplexType))
            {
                  XmlSchemaComplexType elt1 = (XmlSchemaComplexType)el1;
                  if (el2.GetType() == typeof(XmlSchemaComplexType))
                  {
                        XmlSchemaComplexType elt2 = (XmlSchemaComplexType)el2;
                        if (elt2.QualifiedName.Equals(elt1.QualifiedName))
                        {
                             if ((XmlSchema)elt2.Parent != null)
                            {
                                  ((XmlSchema)elt2.Parent).Items.Remove(elt2);
                                    break;
                            }
                       }
                  }
             }
        }
   }
  
   foreach (XmlSchema schema in schemaSet2.Schemas())
   {
        schemaSet2.Reprocess(schema);
   }
           
   schemaSet1.Add(schemaSet2);
   schemaSet1.Compile();
  
   return schemaSet1;
}

Felices Lineas!!!!

107. Obtener el nombre de un archivo de una URL

Muchas veces debemos obtener el nombre de un archivo de una URL, esto para poder trabajar con aplicaciones que se encuentran en la nube o simplemente en el ámbito de internet.

Bueno, el truco es muy sencillo.

1. Asignamos la dirección a un objeto tipo URI.

Uri uri = new Uri("https://midireccion.blob.core.windows.net/micontenedor/Comprobante_9e94ee40-b2e0-4900-afcc-7dc1e101a3f7.xml?sv=20rbCkWqTFp0gaGlpCwwXwI4DV3T46");

2. Obtenemos la parte de la dirección correspondiente a LocalPath, esto nos dará la siguiente dirección:

/micontenedor/Comprobante_9e94ee40-b2e0-4900-afcc-7dc1e101a3f7.xml

3. Obtenemos el nombre del archivo por medio de GetFileName

Nuestro código se convierte en algo como esto:

            Uri uri = new Uri("https://midireccion.blob.core.windows.net/micontenedor/Comprobante_9e94ee40-b2e0-4900-afcc-7dc1e101a3f7.xml?sv=20rbCkWqTFp0gaGlpCwwXwI4DV3T46");

            string filename = System.IO.Path.GetFileName(uri.LocalPath);

Felices Líneas

106. Hora local por país

Estamos en una época en la que las redes se globalizan cada día mas, y poco a poco perdemos mas el control del sitio en donde se encuentra una aplicación alojada, hace pocos años hablábamos de que la aplicación se alojaba dentro de un servidor que se encontraba en la misma empresa, poco después hablábamos de servidores que se encontraban en centros de datos en la misma región geográfica, pero hoy estos servidores se encuentran en cualquier parte del mundo.

Y el tiempo es uno de los puntos que debemos considerar, ya que la hora cambia de país a país, de una región geográfica a otra, es conveniente manejar siempre la hora UTC (Coodinated Universal Time), la hora UTC, es un estándar internacional que se obtiene partiendo del tiempo atomico internacional, y se considera la sucesora de la hora GTM (basada en el meridiano de Greenwish), la hora UTC es la hora que se emplea en internet, y para efectos de programación, es la hora universal.

Al programar en C# la hora UTC se obtiene invocando la siguiente función:

DateTime.Now.ToUniversalTime()

Sin embardo el mostrar hora UTC, o el comparar la hora UTC con la hora local puede traer algunas complicaciones, sobre todo para aquellas personas no familiarizadas con esto.

Esto además puede traer problemas en la información ya que la hora UTC no es la hora local.

Para poder manejar en la nube o en algún servidor la hora local, es necesario indicar al proceso la hora de la región que vamos a utilizar.

Para ello usaremos la siguiente función:

DateTime dt = TimeZoneInfo.ConvertTimeFromUtc(DateTime.Now.ToUniversalTime(),TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time (Mexico)"));

¿Qué es lo que hace?

Bueno le estamos pidiendo al servidor la hora del mismo en formato UTC, y este lo estamos transformando a la hora del país con el que deseamos trabajar, en este ejemplo estamos usando la hora central del Mexico, con ello, no importa en que país este el servidor, nos aseguramos de trabajar con la hora correcta para la región en la que se ejecuta nuestra aplicación.

Felices lineas

80. Creando una dll desde un programa

La creación de una dll dinámica nos puede ayudar algunas veces a construir procesos mas rápidos, esto por que podemos tener datos pre compilados en una dll, que cambie a través, del tiempo.

Una dll dinámica es mu sencilla de hacer.

El código es tan sencillo como esto:

Y que hace, hace algo muy simple toma el código que nosotros le damos, y lo convierte en una dll lista para ser utilizada por otro proceso.

Felices lineas

50. Split (Ayuda Rápida XII)

Una de las funciones mas útiles al momento de separar cadenas es split, esta nos permite separar textos por algún carácter o conjunto de caracteres, por ejemplo

string cadenas = Hola|mundo

si aplicamos la funcion split

string[] cadena = cadenas.Split('|');

obtenemos un arreglo en el que el primer elemento es Hola y el segundo Mundo

cadena[0] = Hola
cadena[1] = Mundo

Pero el Split puede hacer mas que separar una sola cadena, puede separar por un conjunto de caracteres, ¿Esto para que nos sirve?, para garantizar que el separador del campo es único y reducir la cantidad de errores.

¿y como se usa?

List<string> cfdi = c.Split(new string[] { "\t@@|@@\t" }, StringSplitOptions.None).ToList();

La linea anterior esta buscando una secuencia compleja que es tabulador @@|@@ tabulador, es decir si yo tengo una cadena que reúna esa secuencia la separara.

Esto se vuelve útil cuando un carácter único puede aparecer en la cadena, sobre todo cuando dejamos que el usuario capture en un campo cualquier cadena.

Felices lineas.