115. Creando un redis en la nube

Gracias a la nube, en este caso Azure,  no necesitamos tener grandes equipos para usar las ventajas de redis cache, esta base de datos nosql que es muy rápida, y que nos sirve para manejar altos volúmenes de información no estructurada, a continuacion describiré la serie de pasos que se necesitan para poder crear una base de datos de redis en Azure.

Primero necesitamos una cuenta de Azure, una vez dentro

vallamos a el menú y seleccionemos nuevo

seleccionemos databases

y ahí seleccionemos Redis cache

en este punto ya solo es llenar algunos datos con las características de la base de datos que deseamos.

DNS Name : Es el nombre con el que estará publicada la base de datos de redis

Suscription : El tipo de suscripción que emplearemos para trabajar en la nube

Resource Group : El grupo de recursos en donde crearemos la base de datos

Location: La ubicación geográfica en donde se encontrara, es importante siempre buscar un lugar cercano al sitio en el que se publicada la aplicación

Pricing tier: El tamaño del redis que usaremos, es muy importante considerar esto, por que una vez creado se puede incrementar su tamaño, pero este no se puede reducir

Después de llenar esto datos creamos el redis

Azure tardara unos minutos en generar la nueva base de datos

Felices lineas

114. Margaret Hamilton

Lo he mencionado muchas veces en este blog, es importante la cultura de los desarrolladores, cultura para saber quienes fueron los que nos precedieron, y como lo hicieron, hemos caído en un gran problema en estos días, el hecho de querer resolver todo a maquinasos, buscamos tener el mejor equipo, rápido, con mucha memoria, los mejores procesadores, lo cual nos ha hecho flojos en muchos sentidos.

El enfoque de muchos cursos de programación es malo, enfocándose en desarrollar de una forma muy sucia, desarrollar rápido no quiere decir desarrollar de una forma eficiente.

A que viene todo esto, bueno a una persona que desarrollo el software para que el hombre llegara a la luna, estoy hablando de Margaret Hamilton, ella junto con su equipo del MIT desarrollaron el software de navegación del programa apollo (AGC), una computadora creada a principios de los años 60, hace ya mas de medio siglo, que tuvo la capacidad de enviar al hombre al espacio.

AGC - Programa Apollo

Margaret trabajo en el MIT dentro del Charles Stark Draper Laboratory el cual en 1965 se convirtió en el responsable de la construcción del software del AGC, el sistema era un sistema multitarea (capaz de ejecutar 8 tareas de manera simultanea) y en tiempo real.

Ella estuvo presente en la sala de control durante el alunizaje, y cuando el AGC comenzó a indicar los errores tomando ella la decisión de continuar con el alunizaje.

Muchos de los principios del AGC fueron los cimientos de lo que hoy en día es conocido como Ingeniería de Software.

Nació el 17 de Agosto de 1936, y es parte de la historia viva de sistemas.


Felices Lineas

113. Redist Cache 01

Las bases de datos han evolucionado, así como la información también ha crecido, la producción de información hoy en día es varias veces superior a la información que se producía hace 10 años.

La información es un tesoro, y es muy importante poder analizarlo de forma adecuada, el análisis es una tarea compleja, ya que acceder a la información estructurada puede ser muy costoso, además existe el hecho de que la información que se encuentra en la naturaleza no se encuentra estructurado.

La información en la naturaleza puede ser variable, e interpretarla puede ser complejo, es ahí cuando entran las bases de datos no estructuradas o noSQL, dichas bases nos permiten manipular datos sin que estos tengan una estructura como tal.

Se tiene un universo muy amplio de este tipo de bases de datos, y de la base que vamos ha hablar es una base de este universo, esta base es llamada Redist Cache, esta es una base de datos creada en C, que además de ser no SQL tiene una característica muy importante, es extremadamente rápida.

Cuando se habla de un alto procesamiento de datos los milisegundos cuentan, ya que estos al juntarse se convierten en segundos, minutos, horas o días.

La rapidez de esta base de datos se debe principalmente a su estructura, se encuentra estructurada como un gran diccionario de datos, y a que la base de datos se encuentra en la memoria.

Al ser una base de datos de estas características su velocidad es muy alta, hoy en día, el costo del hardware se abarata, y como consecuencia es fácil tener una base de datos in-memory.

Esta base de datos, se creo en el sistema Linux, posteriormente se migro una versión a Windows, pero la magia de ella no se encuentra ahí, la magia de ella se encuentra en la posibilidad de poderla contratar como un servicio server less en la nube, de esta forma se obtiene una base de datos muy rápida, para procesar, grandes cantidades de información, que se puede almacenar en una infraestructura a la medida, en la que se paga solo por lo que se ocupa.



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!!!!

109. Firmar con rsa - SHA256 C# - certificado del almacen de windows

Antes que nada, debo aclarar que la firma de una cadena se efectúa por medio de la clave privada, por lo que deben verificar que la clave privada se encuentren dentro del almacén para posteriormente hacer la firma de la cadena.

Veamos el código y expliquemoslo

//Establecemos el numero de certificado, que se empleara para la firma, dicho certificado deberá estar dentro del almacen de certificados de Windows y deberá tener su clave privada
 string noSerie = "3030323031303030303030313030303030383133";
//Establecemos la cadena que se firmara
 string CadenaAFirmar = "holaMundo";
//Buscamos el certificado que se empleara para la firma dentro del almacén de certificados
 X509Store almacen = null;
 almacen = new X509Store(StoreLocation.LocalMachine);
 almacen.Open(OpenFlags.OpenExistingOnly);
 X509Certificate2Collection Certificados = almacen.Certificates.Find(X509FindType.FindBySerialNumber, noSerie, false);
 X509Certificate2 CertificadoFirma = Certificados[0];
 almacen.Close();

//Se carga la clave privada
RSACryptoServiceProvider csp = null;
csp = (RSACryptoServiceProvider)CertificadoFirma.PrivateKey;
var enhCsp = new RSACryptoServiceProvider().CspKeyContainerInfo;
var cspparametro = new CspParameters(enhCsp.ProviderType, enhCsp.ProviderName, csp.CspKeyContainerInfo.KeyContainerName);
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(cspparametro))
            {
//Se firma la cadena
                rsa.PersistKeyInCsp = true;
                byte[] bytefirma = rsa.SignData(Encoding.UTF8.GetBytes(CadenaAFirmar), "SHA256");
                return bytefirma;
            }

Felices lineas

108. XDocument consulta rapida

XDocument nos presenta una forma rápida de consultar un XML, es mas rápido que un XMLDocument dado que este guarda toda la información en memoria, XMLDocument, permite la carga de documentos de gran tamaño, dado que guarda únicamente un puntero al documento, XML document trae un conjunto de funciones útiles, dado que es un objeto mas grande, una de ellas es la posibilidad de dar una ruta para que se encuentre un nodo en particular, esto no lo podemos hacer con XDocument, ya que debemos ir nodo a nodo para hacer el análisis.

La siguiente función busca emular esta característica de XMLDocument, para poder aprovechar las ventajas en velocidad que nos da XDocument.

       public string ObtenerAtributo(XDocument Documento, string rutaAtributos, string RutasEspacoNombres)
        {
            EspaciosDeNombres objEspaciosNombres = new EspaciosDeNombres();
            List<EspacioDeNombres> EspaciosDeNombres = objEspaciosNombres.CargarEspaciosDeNombres(RutasEspacoNombres);
            String[] rAtributos = rutaAtributos.Split('\\');
            int AtributoUbicacion = rAtributos.Count() - 1;
            int contador = 0;
            XElement objElement = null;
            while (contador < AtributoUbicacion)
            {
                string[] AtributosComponentes = rAtributos[contador].Split(':');
                XNamespace EsNombres = EspaciosDeNombres.Find(c => AtributosComponentes[0] == c.Nombre).EspacioNombres;
                if (contador == 0)
                {
                    objElement = Documento?.Element(EsNombres + AtributosComponentes[1]);
                }
                else
                {
                    objElement = objElement?.Element(EsNombres + AtributosComponentes[1]);
                }
                contador++;
            }
            //Obteniendo el atributo
            return objElement?.Attribute(rAtributos[AtributoUbicacion])?.Value;
        }

¿Qué hace el código?

Recorre todas las rutas del XML con el fin de buscar el atributo especificado, dando una cadena en la que se establezca la ruta de un atributo.

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

105. Cargar nodos de XML en renglones separados

Un query muy útil para casos en los que recibimos información en XML pero nos interesan los nodos, es el siguiente:

CREATE TABLE tablaXML
(
Id INT IDENTITY PRIMARY KEY,
Datos XML,
FechaInsercion DATETIME
)

DECLARE @x xml

SELECT @x = BulkColumn FROM (
SELECT CONVERT(XML, BulkColumn) AS BulkColumn
FROM OPENROWSET(BULK 'C:\0\millones\0000000002.xml', SINGLE_BLOB) AS x) AS y

INSERT INTO tablaXML(Datos, FechaInsercion)
SELECT T.c.query('.') AS result,GETDATE() 
FROM   @x.nodes('/comprobantes/*') T(c) 
GO 

Que debo sustituir, hay que sustituir la ruta de donde se tomara el archivo, por la ruta de su archivo, y además el nombre del nodo, en mi caso fue comprobantes, por la ruta de XML de su nodo.

Que es lo que hace, bueno en primer lugar carga el XML de un archivo a una variable de tipo XML que podemos manipular, después tomando esa variable buscamos el nodo en particular con el que deseamos separar el XML, esto nos permite obtenerlo por renglones e insertarlo en una base de datos.

Esta es una forma rápida de separar XML de gran tamaño

Felices líneas

104. C# 7.0 Local Functions

Funciones locales, esta nueva característica de C# 7.0 también es muy interesante, por que nos permite crear funciones dentro de una función, preguntaran ¿Para que quiero hacer esto?, simplemente nos da una nueva forma de organización, que nos permite reducir el acceso a ciertas partes del código.

Una aplicación seguridad, reduciendo el acceso a una función solo para la función que la ocupa.

Bueno veamos un ejemplo:

Creemos una función que necesita ser llamada múltiples veces en un mismo fragmento de código

        static int SumaEspecial(int x)
        {
            int a = 0;
            for (int i = 0; i < 100; i++)
            {
                a = x + a;
            }
            return a;           
        }

Podemos observar que  la función suma especial esta haciendo un ciclo y este ciclo efectúa una actividad compleja, ahora por orden podemos agrupar esa actividad compleja en una función local.

Las funciones locales las escribimos dentro de la misma función, pero después del ultimo return, asi podemos sustituir la función por lo siguiente:

        static int SumaEspecial(int x)
        {
            int a = 0;
            for (int i = 0; i < 100; i++)
            {
                a = suma(x, a);
            }
            return a;

            int suma(int i,int y)
            {
                return i + y;
            }
        }

Como podemos ver, se ha creado una función dentro de otra, para efectuar esa característica compleja que solo estará disponible para esta función.

Ejecutando la aplicación

Felices Lineas

103. C# 7.0 Tuples

Una de las características interesantes de C# 7.0 es el uso de tuples, algo que los desarrolladores hemos pedido por mucho tiempo.

¿Qué es esto?

Bueno es la posibilidad de poder obtener del return, mas de un valor, sin necesidad de emplear una clase intermedia o un objeto complejo.

Su implementación es muy sencilla.

Necesitamos agregar de Nuget el paquete llamado System.ValueTuple

Ahora solo es cuestión de codificar un poco.

Escribamos algo asi

        static (int,int,int) Calcular(int x)
        {
            return (1 * x, 2 * x, 3 * x);
        }

Como pueden ver estoy creando un método que obtiene 3 valores y que estos pueden ser usados de manera independiente, se ha roto esa barrera que heredamos desde C de que directamente solo podíamos obtener un solo valor.

Hagamos una función que invoque esto, para el caso de la tuple, la invocaremos de la siguiente forma:

var a = Calcular(3);

En donde podremos acceder a cada uno de los valores por medio de unos métodos que se generaran automáticamente, llamados item1, item2, itemn

Console.WriteLine("Valores: {0},{1},{2}", a.Item1, a.Item2, a.Item3);

ejecutemos ahora nuestro programa

Felices líneas

102. Visual Studio 2017 (Lanzamiento)

Visual Studio es la herramienta por excelencia para todos aquellos que desarrollamos dentro del ecosistema de Microsoft, por ello cada vez que se anuncia una nueva versión,  estamos esperando ver las novedades que trae este ambiente de desarrollo.

A lo largo de estos años (20 para ser exactos) Visual Studio ha presentado una continua evolución, convirtiéndose en la herramienta preferida para desarrollar, el día de hoy prácticamente cualquier tipo de aplicaciones.

Visual Studio se ha convertido en una herramienta, que mas allá de la mera creación de aplicaciones, busca simplificar la vida de los desarrolladores, permitir adaptar el desarrollo del software a una era en la que las entregas son cada vez mas rápidas, para ello, Visual Studio ha evolucionado, incorporando las nuevas filosofías que se presentan dentro de la profesión.

Cualquier Lenguaje cualquier plataforma

Esa es la base de ese nuevo Visual Studio, un Visual Studio en un mundo globalizado, en donde es mejor buscar siempre lo mejor de cada mundo, en donde la colaboración es base del desarrollo sin importar en que parte del mundo se encuentren los colaboradores.

Un Visual Studio en el que el programador héroe que podía en el pasado hacer todo ha pasado a la historia y en el que se consideran verdaderamente los equipos de desarrollo.

Un Visual Studio que forma parte de una metodología, y de una filosofía, en la que el orden del desarrollo importa, por que el orden se transforma en calidad.

Un Visual Studio listo para una evolución de arquitecturas, en la que estas se transforman para buscar una arquitectura escalable, no tan costosa, en donde realmente los recursos se aprovechen, en el que se puede crear una buena idea, construirla y evolucionarla.

Tenemos una evolución que no nos decepciona, en un mundo en que la capacidad de asombro sigue disminuyendo Visual Studio nos sigue asombrando.

Y por cierto, si no somos una gran empresa, la versión gratuita, no deja nada que desear.

Felices Líneas

101. Transferir esquema SQL (ayuda rapida)

Los esquemas en la base de datos juegan un papel primordial dentro de la organización de la base de datos, su función es describir es si misma la base de datos.

El uso de esquemas es importante, por que también nos ayuda a determinar el verdadero dueño de la información y con ello podemos asignar los permisos correspondientes a cada conjunto de datos.

Por eso es muy importante que las tablas se creen en el esquema correcto.

¿Pero que pasa si no se crearon en el esquema correcto?

Pues solo es necesario transferirlo, para ello es necesario.

1. Crear el nuevo esquema

IF (NOT EXISTS (SELECT 1 FROM sys.schemas WHERE name = 'adm'))
BEGIN
    EXEC ('CREATE SCHEMA [adm] AUTHORIZATION [dbo]')
END

2. Transferir el esquema

ALTER SCHEMA adm
    TRANSFER dbo.ReglaNegocio


Felices Lineas

100. Resumen (Primera meta numero 100)

Por increíble que parezca hemos llegado a las primeras 100 entradas en el blog, pese a que en algunos momentos, por motivos laborales no he podido escribir a la velocidad que desearía y que existen muchos temas que tenemos abiertos.

Llegar a 100 números en menos de 2 años inicie el proyecto el 22 de junio de 2015 y hoy 01 de Marzo de 2017 llegue a la primer meta de esta aventura, aventura que ha tenido como principal motivo, compartir y aprender cada día, aprender lo que ocurre en este frenético mundo del computo, comentar puntos de vista, y escribir sobre ese tema en el que trabajo y tanto me apasiona.

Les dejo la lista de estos primeros 100 numeros

Numero	Titulo	Seccion
99	SQL Server Always Encripted	Construyendo en el espacio
98	Microservicios	Construyendo en el espacio
97	DevOps (3) - Infraestructura como codigo	Construyendo en el espacio
96	Pruebas cudradas	Desde el divan del gato
95	Visual Studio 2017	Noticias
94	Configurar el IIS para https	Ayuda Rapida
93	DevOps (2)	Construyendo en el espacio
92	Bases de datos noSQL	Construyendo en el espacio
91	Nuevo amanecer - BITCOIN	Desde el divan del gato
90	SQL Padres sin hijos	Ayuda Rapida
89	Eliminando duplicados en una base de datos	Ayuda Rapida
88	Aplicaciones Universales Dia 1	Aplicaciones Universales
87	Arreglo de caracteres a cadena C#	Ayuda Rapida
86	Aplicaciones Universales	Construyendo en el espacio
85	Insertar a SQL una fecha por un Query	Ayuda Rapida
84	Desarrollando CFDI	Noticias
83	DevOps(1)	Construyendo en el espacio
82	Dia del programador	Noticias
81	Telefonia movil	Desde el divan del gato
80	Creando una dll desde un programa	Ayuda Rapida
79	SQL Server Configuration Manager	Ayuda Rapida
78	Saltos de linea	Ayuda Rapida
77	sql EXEC master..xp_cmdshell ¿Usarlo?	Construyendo en el espacio
76	Zen de Python	Ayuda Rapida
75	Home Office	Desde el divan del gato
74	Buid 2016	Desde el divan del gato
73	Xamarin - Visual Studio	Noticias
72	Cientifico de datos	Desde el divan del gato
71	Control de excepciones	Construyendo en el espacio
70	HoloLents - build 2016?	Noticias
69	Andrew S. Grove 1936 - 2016	Nuestra historia
68	Windows 10 mobile - el sentido de pertenencia	Desde el divan del gato
67	SQL Llenar con ceros un numero	Ayuda Rapida
66	GhostDoc	Construyendo en el espacio
65	Microsoft adquiere Xamarin	Noticias
64	Validar mi HTML	Construyendo en el espacio
63	Microsoft holographic academy	Noticias
62	This platform could not be created becouse a solution platform of the same name alrready exists	Ayuda Rapida
61	Motivacion	Desde el divan del gato
60	Ondas Gravitacionales de Einstein	Noticias
59	¿Que contiene una actualización de Windows?	Construyendo en el espacio
58	BCP (BulkCopy) Unicode en SQL	Ayuda Rapida
57	Eliminar la parte de tiempo de una fecha	Ayuda Rapida
56	Formato Universal de Fecha en SQL	Construyendo en el espacio
55	HoloLents y superbowl	Noticias
54	Alto vuelo	Desde el divan del gato
53	Determinar si una constraint existe en SQL	Ayuda Rapida
52	Discos duros virtuales	Ayuda Rapida
51	Alan Turing	Nuestra historia
50	Split	Ayuda Rapida
49	Diferencia entre 2 fechas sql	Ayuda Rapida
48	Reflexion sobre seguridad	Desde el divan del gato
47	Getfiles Vs EnumerateFiles	Ayuda Rapida
46	Sia inicial de un mes SQL	Ayuda Rapida
45	C# 6.0 Null-Conditional Operators	Construyendo en el espacio
44	Reinstalar todos los paquetes de nuget	Ayuda Rapida
43	Deuda tecnica	Construyendo en el espacio
42	Fin de soporte Windows8	Noticias
41	.NET 4.5 Compesion de directorios	Construyendo en el espacio
40	C# 6.0 Dictionary Initializers	Construyendo en el espacio
39	C# 6.0 Property Initializers	Construyendo en el espacio
38	C# 6.0 Interpolated Strings	Construyendo en el espacio
37	Concatenar Archivos	Construyendo en el espacio
36	Patrones Proxy	Construyendo en el espacio
35	Buen software	Desde el divan del gato
34	Kenneth Thompson	Nuestra historia
33	Distinct en una lista	Ayuda Rapida
32	Buid 2016	Noticias
31	Ciclo de vida Internet explorer	Noticias
30	Usabilidad	Construyendo en el espacio
29	Diferencia entre 2 fechas	Ayuda Rapida
28	Dennis Ritchie	Nuestra historia
27	Parpadeo en DataGridView	Ayuda Rapida
26	Ada Lovelance	Nuestra historia
25	Nuestra historia	Nuestra historia
24	FileSystemWatcher	Ayuda Rapida
23	Calculo de SHA1 para un archivo	Ayuda Rapida
22	WinForm - ListBox - Copiar todos los elementos	Ayuda Rapida
21	Agua en marte	Noticias
20	Metricas (Indice de Mantenibilidad)	Construyendo en el espacio
19	Metricas (numero de lineas)	Construyendo en el espacio
18	Metricas (profundidad de herencia)	Construyendo en el espacio
17	¿Qué nos hace programadores?	Desde el divan del gato
16	Metricas (Cohesion y Acoplamiento)	Construyendo en el espacio
15	Metricas (complejidad ciclomatica)	Construyendo en el espacio
14	Calidad	Desde el divan del gato
13	Plan de ejecucion	Construyendo en el espacio
12	Patrones Facade	Construyendo en el espacio
11	Visual Studio Threads	Construyendo en el espacio
10	Instaladores	Ayuda Rapida
9	Patrones Decorador	Construyendo en el espacio
8	Base de datos	Desde el divan del gato
7	Programar en paralelo	Construyendo en el espacio
6	Pensamiento Magico	Desde el divan del gato
5	Herramientas - Mi propio NuGet	Construyendo en el espacio
4	Patrones	Construyendo en el espacio
3	Desarrollando	Noticias
2	Optimizar el performance	Construyendo en el espacio
1	Reflexión sobre el papel del Arquitecto	Desde el divan del gato

Felices lineas