Como trabajar con LinQ C # Lambda Expression


Si está utilizando LinQ como ORM y haciendo que su personal termine de forma orientada a objetos simples, ¡eso es bueno! ¿Has visto algún código mágico de un trazador de líneas que no parece muy familiar para nuestro código C # habitual? Esas son expresiones lambda, una forma genial de hacer las cosas de una manera simple y fácil. En el tutorial de hoy discutiremos sobre la comprensión básica de la expresión lambda C #, que juega un papel muy importante en .NET LinQ , una tecnología muy fácil, eficiente y efectiva para manejar datos.

¿Qué son expresiones Lambda?


(Input Parameters) => Method Expression

No te enojes con solo echar un vistazo a la declaración de expresión de lambda, no es un idioma extraño. ¡Es simplemente una función (o delegado)! Bueno, podemos llamarlo función anónima . Es una función sin nombre. Pero tiene un parámetro y un valor de retorno, pero son dinámicos, lo que significa que podemos poner cualquier cosa por ellos, está sobre nosotros. ¡Guauu! Que flexible Sí lo es.

Sin embargo, tendrás que recordar una cosa, tan pronto como la usemos en el código, donde sea que esté, su alcance termina allí mismo, no hay forma de reutilizarlo más, ¡ya que hay un nombre asignado a él! Por lo tanto, en su mayoría, utilizaremos esto en algunas tareas que necesitarán algunos cálculos y queremos escribir de manera fácil y eficiente, pero no es necesario volver a utilizarlo a menudo. Si es necesario, debe asignarse a un delegado o tipo 'Func'.


Uso general de C # Lambda Expression:

En general, la expresión lambda es útil al usar la consulta LinQ en su aplicación y aplicarla en una lista de datos, ya sea desde la base de datos, desde XML o dinámico. En otras palabras, lo usamos habitualmente para filtrar algunos datos específicos de una lista de datos que cumple con los criterios y usarlos en una operación LinQ. La expresión lambda se puede usar en un amplio rango de área como linq a sql, linq a xml, linq a entidad (marco de entidad), datos de matriz / lista, etc.

Un ejemplo simple:

Por favor, eche un vistazo a la siguiente expresión:

x => x >10

Este es un ejemplo muy simple de cómo puede ser una expresión lambda. La primera parte, antes del símbolo '=>', se considera como el parámetro de entrada. No necesita ser definido previamente, es dinámico. Decide el tipo de forma inteligente, incluso en tiempo de compilación, cuando lo está escribiendo, en función de la operación que se realiza en él.

Como dijimos, queremos filtrar algunos datos específicos de una lista de datos, este parámetro de entrada representa el tipo de cada elemento de la lista. Digamos, estamos tratando con una lista de datos enteros, entonces x es un número entero. Si estamos tratando con una lista de objetos 'A', entonces x también será del tipo 'A' y obtendrás soporte completo del estudio visual inteligente para ello.

Entonces veamos la declaración completa de la expresión anterior:

int[] somevalues = { 10, 20, 5, 2, 40, 1 };
int numberOfExpectedValues = somevalues.Count(x => x >10);

Como puede ver, la expresión lambda es un valor de retorno que se está aplicando en el método 'Cuenta' de la matriz de enteros de 'algunos valores'. Entonces, mencioné, ahora x será tratado como un número entero. Y la expresión devolverá un valor verdadero / falso al probar cada elemento de la matriz 'some values' y se usará como método delegado de recuento. finalmente, en la variable 'numberOfExpectedValues', recibiremos cuántos datos cumplen los criterios de ser mayores que 10.

Otro ejemplo de pseudo código:

¿Cómo podemos usarlo en una lista de objetos y qué tan útil sería? Veamos un pseudo código en c # (tienes que escribir algunos códigos más para hacerlo compilar):

List myUsers = New List();
//llene la lista myUsers con algún objeto User
List activeUsers = myUsers.Where(u => u.Active == True);
//la lista de Usuarios activos contendrá solo usuarios activos filtrados de la lista de todos los usuarios



Entonces, sin usar ninguna consulta SQL fea o pocas líneas de códigos para que una función lo haga manualmente, estamos teniendo esto en una sola línea de código práctico. ¿No es asombroso?

Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Como a usar la colección de diccionarios en C#




El término 'Diccionario' en C # programación, tiene algunos otros sinónimos para referirse a él como "matriz asociativa", "key-value pair", "index-value pair", etc. Diccionario utiliza la estructura de datos ' tabla hash ' para construir subir el index/value pair. En realidad, este es un sistema de matriz extendida / avanzada donde puede definir el índice con otros tipos de datos que no sean int y configurar su estructura de datos de una manera más significativa. En este tutorial, veremos el uso básico de la clase de diccionario c#.





¡Espere! ¿Sabía que, por defecto, los objetos de diccionario en c # no se pueden serializar? Aquí, además de la introducción a la clase de diccionario c #, también le mostraré cómo puede hacer que su objeto de diccionario sea serializado / deserializado a / desde XML también. 

Inicializar un objeto de diccionario en C#:

Como el diccionario funciona con dos tipos de datos (uno para 'clave' y otro para 'valor'), requiere ambos tipos de datos para ser definidos en el momento de la inicialización. Además, se requiere el espacio de nombre "System.Collections.Generic" para usar el diccionario en su aplicación.

El siguiente fragmento inicializará un diccionario simple con cadena como ambos tipos de datos:

Dictionary myDictionaryData 
                      = new Dictionary();


También podemos definir algunos valores iniciales predeterminados en el momento de la inicialización. Los siguientes ejemplos agregarán dos pares de datos en el objeto en el momento de la inicialización:

Dictionary myDictionaryData 
                       = new Dictionary() {
                         {"testDictionaryIndex1","Test Dictionary Data Value 1"},
                         {"testDictionaryIndex2","Test Dictionary Data Value 2"}};


Agregar / eliminar pares en el objeto del diccionario:

Insertar y eliminar operaciones es bastante fácil con un objeto de diccionario. Para agregar un nuevo par, deberá pasar la clave y el valor como parámetro en el método "Agregar" en el objeto. La eliminación del objeto solo se realiza mediante la parte 'clave'. Solo tiene que pasarlo al método "Eliminar" del objeto. Compruebe los siguientes ejemplos de código c # para agregar / eliminar par de datos del diccionario al objeto:

//pasar tanto la clave como el valor para agregar un nuevo par
myDictionaryData.Add("test1", "test value 1");
 
//pasar solo la clave para eliminar un par
myDictionaryData.Remove("test1");

Atraviesa los pares en un objeto de diccionario:

También hay una versión de par de valor único para la clase de diccionario C #. Es la clase 'KeyValuePair' que puede contener un solo par. Cuando realizamos un desplazamiento con o para el bucle foreach , esta variable de clase se puede usar para mantener cada par y procesarlo más si es necesario.

foreach (KeyValuePair myItem in myDictionaryData)
{
    //Hacer lo necesario con myItem
    Console.WriteLine(myItem.Key + " : " + myItem.Value);
}

Fusionar dos diccionario:

¿Qué sucede si tenemos que fusionar dos diccionarios diferentes en un solo objeto de diccionario? Sí, podemos hacerlo. El siguiente ejemplo utiliza la técnica de expresión C # LinQ Lambda para fusionar dos diccionarios diferentes en un tercero diferente:

Dictionary myDictionaryData1 
                             = new Dictionary() {
                               {"testDictionary1Index1","Test Dictionary1 Data Value 1"},
                               {"testDictionary1Index2","Test Dictionary1 Data Value 2"}};
Dictionary myDictionaryData2 
                            = new Dictionary() {
                              {"testDictionary2Index1","Test Dictionary2 Data Value 1"},
                              {"testDictionary2Index2","Test Dictionary2 Data Value 2"}};
 
Dictionary mergedDictionary = new Dictionary();
myDictionaryData1.ToList().ForEach(x => mergedDictionary.Add(x.Key, x.Value));
myDictionaryData1.ToList().ForEach(x => mergedDictionary.Add(x.Key, x.Value));



Implementar diccionario serializable en C #:

Como por defecto .NET Framework no proporciona la facilidad de la serialización c # xml para los objetos del Diccionario, tendremos que implementarlo nosotros mismos. podemos hacerlo implementando la interfaz "IXMLSerializable". La siguiente clase personalizada debe hacer su trabajo bien:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
 
[XmlRoot("dictionary")]
public class SerializableDictionary : 
Dictionary, IXmlSerializable
{
 
    #region IXmlSerializable Members
 
    public System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }
            
    /// 
    /// Custom implementation to read xml data and assign into dictionary 
    /// 
    /// XmlReader object to be used
    public void ReadXml(System.Xml.XmlReader reader)
    {
        XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
        XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();
 
        if (wasEmpty)
        {
            return;
        }
 
        while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
        {
 
            reader.ReadStartElement("item");
            reader.ReadStartElement("key");
            TKey key = (TKey)keySerializer.Deserialize(reader);
            reader.ReadEndElement();
 
            reader.ReadStartElement("value");
            TValue value = (TValue)valueSerializer.Deserialize(reader);
            reader.ReadEndElement();
 
            this.Add(key, value);
 
            reader.ReadEndElement();
            reader.MoveToContent();
        }
        reader.ReadEndElement();
    }
 
    /// 
    /// Custom implementation to write dictionary into xml file
    /// 
    /// XmlWriter object to be used
    public void WriteXml(System.Xml.XmlWriter writer)
    {
        XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
        XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
        foreach (TKey key in this.Keys)
        {
            writer.WriteStartElement("item");
            writer.WriteStartElement("key");
            keySerializer.Serialize(writer, key);
            writer.WriteEndElement();
 
            writer.WriteStartElement("value");
            TValue value = this[key];
            valueSerializer.Serialize(writer, value);
            writer.WriteEndElement();
            writer.WriteEndElement();
        }
 
    }
    #endregion
 
}

Y esto es todo amigos!

Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Aplicar LinQ a datos XML usando C#




Hoy voy a mostrar cómo se puede aplicar linq en datos XML junto con ejemplos de código c #. Esto se conoce como 'Linq To XML'. Supongo que ya está familiarizado con el uso básico de Linq. Si no, mi sugerencia será estudiar los conceptos básicos de Linq primero. Aquí, en este tutorial, mostraré las operaciones más básicas, como recuperar datos (seleccionar), insertar datos, borrar datos y modificar datos existentes desde y hacia el archivo xml utilizando linq.




Data de muestra:

Para este ejercicio simple, utilizaremos una estructura de archivo xml muy básica de la siguiente manera:



  
    Test1    
  
  
    Test2    
  
  
    Test3     
    


Este archivo tiene un elemento raíz llamado 'estudiantes' que contiene un conjunto de elementos con la etiqueta 'estudiante', se refiere a cada estudiante en el conjunto de datos. Cada 'estudiante' tiene un atributo 'id' y un elemento interno 'nombre'. Para una estructura más compleja, podemos agregar tantos atributos / elementos internos que deseemos.


Recuperación de datos utilizando linq To XML:

Primero voy a poner un fragmento de código que realmente hará ese trabajo de recuperar datos del archivo xml. Luego explicaré cómo funciona en cada paso.
private string path = "TestData.xml";
 
        private void GetXMLData()
        {
            try
            {
                XDocument testXML = XDocument.Load(path);
                var students = from student in testXML.Descendants("Student")
                                select new
                                {
                                    ID = Convert.ToInt32(student.Attribute("ID").Value),
                                    Name = student.Element("Name").Value 
                                };
 
                foreach (var student in students)
                {
                   // Do other operations with each student object
                }
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }


Al principio, necesitaremos crear un objeto "XDocument" del archivo xml. Simplemente pasar la ubicación del archivo como parámetro del constructor funcionará bien. Aquí, dos cosas deben recordarse cuidadosamente:

  • Si el archivo xml no está en formato xml válido, arrojará una excepción.
  • El ejemplo anterior es para el formato de aplicación de escritorio, donde se requiere que el archivo xml esté en el directorio actual desde donde se ejecuta la aplicación. Si necesita especificar alguna otra ubicación, debe ser necesario especificar el URI absoluto para ese archivo. Si se trata de una aplicación web, es posible que deba utilizar el método Server.MapPath () para especificar el uri correctamente.

Ahora, tan pronto como obtengamos un objeto XDocument válido, estamos listos para aplicar la operación linq sobre él. Para especificar los elementos que se consultarán, necesitamos usar el patrón "xDocObject.Descendants (elementTagName)". Puede ver que hemos utilizado expresiones similares en la consulta de linq. Mientras selecciona, puede crear un objeto dinámico con las propiedades que necesita. O puede declarar de antemano, una clase con miembros y crear un objeto de esa clase. En el código anterior, hemos utilizado el enfoque de objeto dinámico simplificado.


Insertar datos usando Linq a XML:

Insertar datos en un archivo xml usando linq es bastante directo. primero necesitaremos preparar un objeto XElement apropiado que se insertará. De nuevo, hay que tener cuidado de que el XElement construido esté completamente sincronizado con el formato del archivo xml. Y luego, tenemos que agregarlo a la colección de elementos correspondientes de los objetos 'Xdocument' y finalmente sobrescribir el archivo xml existente. Aquí está el ejemplo de código para esto:
private void InsertXMLData(string name)
        {
            try
            {
                XDocument testXML = XDocument.Load(path);               
                 
                XElement newStudent = new XElement("Student",                                               
                                               new XElement("Name", name)                                               
                                           );
                var lastStudent = testXML.Descendants("Student").Last();
 
                int newID =  Convert.ToInt32(lastStudent.Attribute("ID").Value);
                newStudent.SetAttributeValue("ID",4);               
                testXML.Element("Students").Add(newStudent);
                testXML.Save(path);
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }

Modify Existing Data Using Linq To XML:

Para cambiar el registro existente en el archivo xml, primero necesitaremos recuperar el registro que coincida con algunas restricciones, como la coincidencia del atributo id o la coincidencia del valor del nombre. Guarde los datos recuperados en XElement, luego realice los cambios necesarios y finalmente aplique la operación de salvar en la clase de objeto XDocument. Tenga en cuenta que no es necesario reasignar el objeto XElement modificado como referencia interna desde el objeto XDocument y aplicar los cambios necesarios mientras se guarda. Lo siguiente es la muestra del código para hacer la modificación:

private void UpdateXMLData(string name,int id)
        {
            try
            {
                XDocument testXML = XDocument.Load(path);
                XElement cStudent = testXML.Descendants("Student").Where(c => c.Attribute("ID").Value.Equals(id.ToString())).FirstOrDefault();
 
                cStudent.Element("Name").Value = name;
                testXML.Save(path);
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }


Eliminar un registro del archivo XML utilizando Linq:

Para eliminar un registro, simplemente tenemos que recuperarlo y luego llamar al método "Eliminar" de este Objeto XElement. que hará la eliminación necesaria en el objeto XDocument y finalmente aplicará los cambios al sobreescribir el archivo xml. A continuación se muestra el ejemplo del código que eliminará un registro:


private void DeleteXMLData(int id)
       {
           try
           {
               XDocument testXML = XDocument.Load(path);
               XElement cStudent = testXML.Descendants("Student").Where(c => c.Attribute("ID").Value.Equals(id.ToString())).FirstOrDefault();
               cStudent.Remove();
               testXML.Save(path);
           }
           catch (Exception err)
           {
               MessageBox.Show(err.Message);
           }
       }


Eso es todo por hoy, espero que sea clara la información, si tienen alguna duda, escríbanme en los comentarios y pronto responderé!

Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Como trabajar con multiproceso en C # .NET



Al trabajar con el desarrollo de aplicaciones de escritorio, a veces es posible que tengamos que trabajar con programación multiproceso. También puede ayudar a optimizar el rendimiento del software ya que hace la mayor parte del uso de los núcleos de la CPU y, por lo tanto, proporciona un mejor rendimiento / resultados. Nos referimos a este tipo de implementación como 'multitarea' también.Como en tal caso, nuestra aplicación podrá realizar diferentes tipos de tareas al mismo tiempo, en paralelo.


Por ejemplo, solo considere un escenario de desarrollo de aplicaciones de escritorio basado en una base de datos simple, donde su aplicación recuperará una serie de datos y mostrará al usuario. Ahora, si la conectividad de la base de datos es lenta por alguna razón, su aplicación normalmente se atascará. El usuario no podrá hacer nada más que esperar a que el proceso finalice. En tales casos, podemos diseñar muy bien una implementación basada en subprocesos, que permitirá al usuario realizar otras acciones mientras la aplicación recupera datos de una base de datos, y mejora la usabilidad a gran escala.



Un simple hilo, clásico Ejemplo:

Comencemos con un ejemplo simple de un solo hilo. Los siguientes ejemplos de código mostrarán una estrategia simple de ejecución de hilos. El subproceso se ejecutará 50 veces con un intervalo de 500 milisegundos entre cada ejecución.



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
 
namespace TestConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadStart testThreadStart = new ThreadStart(new Program().testThread);
            Thread testThread = new Thread(testThreadStart);
 
            testThread.Start();
            Console.ReadLine();
        }
 
        public void testThread()
        {
            //executing in thread
            int count = 0;
            while (count++ < 50)
            {
                Console.WriteLine("Thread Executed "+count+" times");
                Thread.Sleep(500);
            }
        }
    }
}


Como puede ver, primero tenemos que definir una instancia 'ThreadStart' con la función que necesitaremos ejecutar en el hilo. Entonces, esta instancia se requiere como parámetro en nuestra inicialización de la clase 'Thread'. Después de llamar al método 'start', la función se ejecutará en paralelo a otros procesos.
Además, recuerde que la función se llamará solo una vez. mantenerlo vivo es nuestra propia responsabilidad. Eso significa que tendremos que ejecutarlo dentro de un ciclo for hasta que satisfaga ciertos criterios. El método 'Sleep' espera ese hilo en particular durante la cantidad de tiempo dada (en milisegundos) antes de ejecutar la siguiente instrucción.

Programación multiproceso con hilos clásicos:

Vamos a avanzar un paso para ver cómo se pueden ejecutar más de un hilo en paralelo. El siguiente fragmento de código demostrará dicho escenario. Sin embargo, estoy usando dos hilos solo aquí, puede agregar tantos como desee según su necesidad.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
 
namespace TestConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadStart testThread1Start = new ThreadStart(new Program().testThread1);
            ThreadStart testThread2Start = new ThreadStart(new Program().testThread2);
 
            Thread[] testThread = new Thread[2];
            testThread[0] = new Thread(testThread1Start);
            testThread[1] = new Thread(testThread2Start);
 
            foreach (Thread myThread in testThread)
            {
                myThread.Start();
            }
 
            Console.ReadLine();
        }
 
        public void testThread1()
        {
            //executing in thread
            int count = 0;
            while (count++ < 10)
            {
                Console.WriteLine("Thread 1 Executed "+count+" times");
                Thread.Sleep(1);
            }
        }
 
        public void testThread2()
        {
            //executing in thread
            int count = 0;
            while (count++ < 10)
            {
                Console.WriteLine("Thread 2 Executed " + count + " times");
                Thread.Sleep(1);
            }
        }
    }
}


Después de ejecutar la aplicación, debería ver un resultado como el siguiente: 






Tenga en cuenta que, la salida no será siempre exacta, depende completamente de cómo el sistema operativo proporciona las programaciones a la CPU para la ejecución de la secuencia.



Trabajando con ThreadPool:

Entonces, como hemos visto hasta ahora en los ejemplos de código anteriores, usa 'Thread' en modo raw. Sin embargo, podemos simplificar el proceso de ejecución de subprocesos con el uso de la clase 'ThreadPool' que proporciona .NET framework y es muy útil para la implementación rápida de la programación multiproceso. Todo lo que tenemos que hacer es poner en cola la función que queremos ejecutar en el hilo. Y automáticamente comenzará a ejecutarlos. El siguiente código demostrará este uso simplificado de 'ThreadPool'.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
 
namespace TestConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadPool.QueueUserWorkItem(new Program().testThread1);
            ThreadPool.QueueUserWorkItem(new Program().testThread2);
 
            Console.ReadLine();
        }
 
        public void testThread1(Object threadContext)
        {
            //executing in thread
            int count = 0;
            while (count++ < 10)
            {
                Console.WriteLine("Thread 1 Executed "+count+" times");
                Thread.Sleep(100);
            }
        }
 
        public void testThread2(Object threadContext)
        {
            //executing in thread
            int count = 0;
            while (count++ < 10)
            {
                Console.WriteLine("Thread 2 Executed " + count + " times");
                Thread.Sleep(100);
            }
        }
    }
}


Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Como crear e implementar una interfaz en C#



El día de hoy les compartiré un concepto muy interesante y se trata nada mas y nada menos que de las interfaces en C#, por lo cual comenzaremos con su concepto y pasaremos a un sencillo ejemplo:

Hablando en llano, una interfaz no es más que una estructura de datos que muestra únicamente las firmas de los métodos de una clase. A partir de ahí, una clase que herede de la interfaz estará obligada a “rellenar” la implementación de dichos métodos. De forma simple, una interfaz sería algo así:



   interface IPruebaInterfaz
    {
        void MetodoHola();
    }


Esta interfaz únicamente dice QUÉ acciones se van a realizar, pero no CÓMO se realizarán. Para saber cómo realizarlas, crearemos clases que implementen esta interfaz, obligando a “rellenar” el contenido de los métodos que declaramos previamente.

Primero definimos la interfaz:
   interface IPruebaInterfaz
    {
        void MetodoHola();
    }

La clase anterior muestra una interfaz con el método “MetodoHola” el cual aun no esta implementado, el paso siguiente sera definir la clase que implemente dicho método:
   class ClaseImplementa : IPruebaInterfaz
    {
        void IPruebaInterfaz.MetodoHola()
        {
            Console.WriteLine("Hola TheCodingCookBook!!!");
        }
    }


Finalmente para ocupar nuestra interfaz, definimos una instancia de la misma e invocamos al método.
   static void Principal()
        {
            IPruebaInterfaz obj = new ClaseImplementa();

            obj.MetodoHola();
        }


Y esta una forma simple de definir una interfaz
Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Que es asterisk y con que se come?



Curso de asterisk y .NET C#

Queridos csharpedianos, estamos aquí reunidos para ser testigos de la integración de .NET en su máximo esplendor con LINUX, en algunas épocas esto parecería imposible, pero hoy comenzaremos una travesía que terminara en un software capaz de acceder a un equipo LINUX y realizar modificaciones en nuestro sistema de comunicaciones personal. Para esto es indispensable que aprendamos primeramente que es asterisk, para que lo usaremos, en que nos ayudara y con que nos lo comemos, aquí vamos:


Asterisk, es una plataforma de tecnología de código abierto y gratuito que puede convertir tu casi obsoleto pc en un sistema de comunicaciones VoIP que te permitirá desde intercomunicar por extensiones los cuartos de tu casa, hasta crear complejos sistemas de marcadores automáticos con Text To Speech e IVR Transaccionales.

Asterisk es básicamente un programa que trabaja bajo linux CENTOS el cual proporciona funcionalidades de central telefónica (PBX), se puede conectar a teléfonos para hacer llamadas entre si y hacer llamadas externas, recibir llamadas, conectar softphones, contestar llamadas, crear IVR, y todo lo que se te pueda ocurrir con una centralita telefonica.

No les hablare acerca de la historia de asterisk ya que para ser sinceros en este curso eso no nos importa en lo absoluto, seremos prácticos para hacer el curso lo mas entendible posible y que podamos sentar las bases para crear nuestro propio sistema de comunicación.

Antes de comenzar necesitaremos descargar la imagen de Linux, para asterisk debemos usar CentOS, la versión con la que trabajaremos aquí sera la 7. La imagen de linux CentOS 7 la puede descargar desde la web oficial.

La instalacion de CentOS escapa de los fines de este curso. Pero hare un tutorial de como instalarlo.













Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Crear Extensiones para chrome con bootstrap y HTML



Bienvenidos nuevamente, he estado un poco ausente (Esta bien, bastante ausente) del blog por temas laborales y personales pero hoy es un día glorioso para escribir un nuevo articulo y que se unan algunas neuronas para formar nuevo conocimiento, y que mejor forma de retomar el blog que con nuestro gran amigo google Chrome, y es que hoy aprenderemos a crear extensiones para chrome con HTML, BOOTSTRAP, JQUERY Y CSS.

Hay varios puntos que debemos seguir para crear estas extensiones, tratare de ser breve y que podamos lograr nuestro objetivo, el ejemplo que plateo es crear una barra de búsqueda, que al escribir algo, abra una pestaña nueva con la búsqueda en nuestro glorioso blog de C# AL EXTREMO. Es algo muy simple a nuestro parecer pero sentara las bases para que puedas hacer lo que quieras con estas extensiones.

Cabe mencionar que puedes usar el editor de código que quieras, desde notepad hasta visual estudio si te apetece. Ahora sin mas chachara y sin mas cuento, comencemos:

  1.  Comenzaremos creando una carpeta en la que guardaremos los archivos de nuestra extensión y el primer archivo que guardaremos sera uno llamado manifest.json, el cual crearemos y le agregaremos el siguiente código:  

    {
    
      "manifest_version": 2,
    
      "name": "Búsqueda en C# AL EXTREMO",
    
      "short_name": "Busquedacsharpalextremo",
    
      "description": "Most",
    
      "version": "0.0.1",
    
      "minimum_chrome_version": "38",
    
      "permissions": ["topSites"],
    
      "browser_action": {
    
        "default_icon": "icon.png",
    
        "default_popup": "popup.html"
    
      },
    
      "content_scripts": [
    
        {
    
          "matches": ["<all_urls>"],
    
          "css": ["assets/bootstrap.min.css"],
    
          "js": ["assets/jquery.js", "main.js"],
    
          "run_at": "document_start"
    
        }
    
      ]
    
    }
    

    Vale recalcar que la información que se ingresa aquí es muy sencilla, tales como el nombre, la versión de la extensión y la mínima versión del chrome. En nuestra carpeta también debemos agregar el icono que usara nuestra extensión, este debe ser de 19px X 19px y es el que llamaremos icon.png. El resto de información agréguenla tal cual esta en el ejemplo y luego iremos desenmarañando el archivo.
  2. POPUP: Ahora explicaremos esta session del manifest, y es la que se encarga de que salga una ventana emergente al presionar click sobre la extension:

    "browser_action": {
    
        "default_icon": "icon.png",
    
        "default_popup": "popup.html"
    
      },


    Crearemos un archivo llamado popup.html y pegaremos el siguiente fragmento de código:

     <!doctype html>
    <html>
    <head>
        <title>Buscar en c sharp al extremo</title>
        <link rel="stylesheet" href="assets/bootstrap.min.css">
        <link href='https://fonts.googleapis.com/css?family=Lato' rel='stylesheet' type='text/css'>
        <script src="assets/jquery.js"></script>
        <script src="main.js"></script>
    
        <style>
            body {
                overflow: hidden;
                margin: 0px;
                padding: 0px;
                width: 400px;
                height: 35px;
            }
    
            .body {
                padding: 15px;
            }
    
            .footer {
                background-color: #f0f0f0;
                color: #636363;
                font-size: 13px;
                margin-top: 9px;
                padding: 10px;
                text-align: center;
            }
    
                .footer img {
                    margin-right: 20px;
                    width: 90px;
                    text-align: left;
                }
        </style>
    </head>
    <body>
        <div class="row body">
            <div class="col-lg-12">
                <div class="input-group">
                    <input type="text" id="txtbuscar" class="form-control" placeholder="Buscar">
                    <span class="input-group-btn">
                        <button id="btnbuscar" class="btn btn-primary" type="button">Buscar</button>
                    </span>
                </div>
            </div>
        </div>
        <div class="row">
            <div class="col-lg-12 footer">
                <img src="logo.png" />
                <small><a href="http://csharpalextremo.blogspot.com.co" target"_blank">http://csharpalextremo.blogspot.com.co</a></small>
            </div>
        </div>
    </body>
    </html>
    
    
  3. Crearemos una carpeta llamada assets en la que estaran nuestros archivos js y css, dentro de esta carpeta guardaremos el archivo css de bootstrap y el js de jquery, los cuales encontraran dentro de los archivos de ejemplo de este proyecto.

    En la carpeta raiz, crearemos un archivo llamda main.js y pegaremos el siguiente fragmento de codigo

    $(document).ready(function(){
    
      $("#txtbuscar").focus();
     
     $('#txtbuscar').keyup(function(e){
        if(e.keyCode == 13)
        {
       $("#btnbuscar").click();       
        }
    }); 
     $("#btnbuscar").click(function(){
        var search = $("#txtbuscar").val();
       chrome.tabs.create({ url: "http://csharpalextremo.blogspot.com.co/search?q="+search  });  
     }); 
    
    }); 
    


    Instalemos la extensión en tu computador para verificar que todo va bien. Escribe en la barra de navegación chrome://extensions y si está inactivo, activa el modo programador del lado derecho de la página. Aparecerán inmediatamente abajo tres botones, haz clic en el primero Cargar extensión sin empaquetar y navega hasta seleccionar la carpeta donde tienes la extensión que estás desarrollando. Si lo has hecho bien, aparecerá en la parte superior de tu navegador el icono de tu extensión, el cual en estos momentos no hace función alguna.
  4. Publicar en la tienda de chrome store:
    Ahora que tenemos las bases de la aplicacion, seguramente quieres montarlo en la chrome store para que todos puedan descargarla, pues hagamoslo:

    Primero, escoge todos los archivos y comprímelos en un zip. Después, ingresa al Dashboard de Google Chrome y sigue los pasos para publicarla, si no te has registrado antes, te pedirá en este momento que lo hagas. Te pedirá información y unos screenshots de tu extensión para una mejor visualización a los usuario, es recomendable llenar toda la información y adjuntar todos los screenshot posibles, esto ayudara a raquear tu app y a que mas usuarios la descarguen. 

Ahora que has hecho esta sencilla aplicación para google chrome, puedes comenzar a explorar agregándole mas código al jquery o al html, puedes agregar los estilos que quieras y disfrutar las maravillas que te ofrece internet.
Recomiendo que recibes la documentación oficial de chrome store y que no le pongas limites a tu imaginación ;).

A continuación les dejo el videotutorial, suscribanse al canal para recibir mas contenido como este:



Si quieres consultar el codigo, puedes descargar todo el html, css, js y todo el fuente usado en este proyecto desde aqui:

Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Guardar y obtener Texto dentro de imagen como propiedad


Criptografia con C# - Guardar y obtener Texto dentro de imagen como propiedad

Hoy les traigo dos funciones interesantes, que les servira mucho a aquellos que trabajan mucho con procesamiento de imagenes (jpg;jpeg;png;bmp;etc), sobre todo cuando necesitamos guardar descripciones o comentarios para cada imagen que queremos procesar.

Imaginense que tenemos una pagina web que ofrece productos y tenemos imagenes para cada uno de los productos, realizar rutinas que guarden la descripcion para cada imagen de cada producto nos puede acarrear mucho trabajo, sobre todo al momento de crear la logica para que se guarde en la base de datos y luego para leer cada registro y relacionarlo con cada una de las imagenes.

Pues bien, les traigo una solución fácil y practica con la que nos  evitaremos horas de desarrollo y consiste en guardar la descripción de cada imagen dentro de la misma imagen como un metatag o mas bien una propiedad.

El enlace para descargar el código de ejemplo, se encuentra al final del post.

Con este primer método puedes agregarle la descripción a una imagen creando una propiedad con la información deseada:
        
        ///         
        /// Método usado para entrar a las propiedades de una imagen 
        /// y crear una nueva propiedad con información personalizada
        ///         /// 
        /// 
        private void SetDescription(Image Pic, string NewDescription)
        {
            byte[] bDescription = new Byte[NewDescription.Length];

            // Se copia la descripcion dentro de un byte array
            for (int i = 0; i < NewDescription.Length; i++) bDescription[i] = (byte)NewDescription[i];

            //Descomentar para cargar la imgen como stream
            //System.Drawing.Image Pic = Image.FromStream(Filename);

            //Descomentar la siguiente linea si se desea trabajar con rutas de archivos
            // System.Drawing.Image Pic = Image.FromFile(Filename);

            //Si la imagen ya tiene la propiedad con el id especificado, se elimina esta propiedad de la imagen 
            //para crearla nuevamente
            if (Pic.PropertyItems.Any(p => p.Id == NuevaPropiedad)) Pic.RemovePropertyItem(NuevaPropiedad);

            //Se genera la nueva propiedad
            PropertyItem PropertyItems = (PropertyItem)FormatterServices.GetUninitializedObject(typeof(PropertyItem));
           
           //0815 es el código de la nueva propiedad, puedes usar cualquiera 
            //siempre y cuando la imagen no tenga otra propiedad con ese código
            PropertyItems.Id = 0815;
            PropertyItems.Type = 2;
            PropertyItems.Len = bDescription.Length;
            PropertyItems.Value = bDescription;
            Pic.SetPropertyItem(PropertyItems);

            NombreImagen = Guid.NewGuid().ToString() + Ext;
            Pic.Save(NombreImagen, ImageFormat.Jpeg);

            //pbload es el nombre de un picture box que tengo en la aplicación, 
           //al que le voy a asignar la imagen para mostrarla
            pbload.Image = Image.FromFile(NombreImagen);
            pbload.SizeMode = PictureBoxSizeMode.StretchImage;

            //Limpio los recursos usados
            Pic.Dispose();
            Pic = null;
        }


Este otro método, obtiene el texto guardado en la imagen:
        
        /// 
        /// Metodo usado para leer cualquier propiedad de una imagen
        /// 
        /// 
        /// 
        static public string GetDescription(Image img)
        {
            string text = string.Empty;
            System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();

            try
            {
                //Descomentar esta linea si se desea cargar la imagen por medio de path
                //System.Drawing.Image img = new System.Drawing.Bitmap(ImgPath);

                //Se lee la propiedad donde se almaceno la informacion. 0815 es el identificador que le asignamos a la propiedad
                PropertyItem item = img.GetPropertyItem(0815);

                //Se lee el valor y se almacena en una variable para ser devuelto.
                text = encoding.GetString(item.Value);

                //Se liberan los recursos usados.
                img.Dispose();
                GC.SuppressFinalize(img);

                return text;
            }
            catch { return ""; }
        }


Muy pronto agregare el ejemplo de un proyecto detallado junto con un vídeo de explicación: Esperenlo...

Por ahora, les dejo el código de un ejemplo: Descargarlo aqui

Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...
Google