Curso C Sharp desde Cero para Principiantes y Avanzados | C# .NET

DELEGADOS EN C# .NET | PUNTEROS A METODOS

2020-04-20T10:33:00.001-07:00

Delegados

Tal como hemos comentado, los eventos y los delegados están muy unidos en C#. De hecho no se pueden definir eventos si no definimos previamente un delegado; ya que por medio de ese delegado podremos crear o asignar el método que se encargará de interceptar el evento.

Por esa razón veremos primero que son los delegados para de esta forma comprender mejor todo lo que tenemos que hacer para definir eventos en nuestras clases y desde los objetos creados a partir de ellas asociarlos a un método.

Definición "formal" de delegado

Veamos algunas de las definiciones de la documentación de Visual Studio sobre los delegados:

"Los delegados habilitan escenarios que en otros lenguajes se han resuelto con punteros a función. No obstante, a diferencia de los punteros a función, los delegados están orientados a objetos y proporcionan seguridad de tipos."

"Un delegado es una clase que puede contener una referencia a un método. A diferencia de otras clases, los delegados tienen un prototipo (firma) y pueden guardar referencias únicamente a los métodos que coinciden con su prototipo."

De estas dos definiciones podemos sacar en claro que los delegados son clases especiales que pueden tener referencias a un método, y que ese método debe cumplir con el "prototipo" definido por el delegado. Y que esa referencia que contienen es como los punteros de otros lenguajes, pero que están enfocados a ser utilizados desde el punto de vista de .NET, es decir, a ser usados desde una perspectiva orientada a objetos.

Por tanto, cuando definimos un delegado, estamos definiendo la firma que debe tener una función (o método), con idea de que podamos crear un "puntero" a dicha función, pero de una forma "controlada" por el CLR de .NET. Por tanto, solo se admitirán "punteros" a funciones que concuerden con la definición que ha hecho el delegado.

Si retomamos la definición del delegado System.EventHandler definido por .NET para los eventos, veremos que ese delegado realmente está definiendo la "forma" que debemos declarar el método que intercepte un evento basado en ese delegado.

Analicemos con algo de detalle la definición tanto del delegado EventHandler como del evento TextChanged.

El delegado está definido de la siguiente forma:

public delegate void EventHandler(object sender, EventArgs e);

Si desechamos public delegate, nos quedamos con una definición de un método que bien podríamos incluir en una interfaz, ya que lo que hace es indicar que ese método debe ser de tipo void (no devuelve ningún valor), y que tiene dos parámetros, el primero de tipo object y el segundo de tipo EventArgs.

Ahora veamos la definición del evento TextChanged:

public event EventHandler TextChanged;

Si en esta ocasión también obviamos las dos primeras instrucciones, tendremos una declaración "típica" de C#, en la que el tipo de datos es EventHandler (el delegado, que al fin y al cabo es una clase de tipo especial), seguida de "la variable" que define el evento. Lo que notamos aquí es que no aparece por ningún lado los parámetros que hay que usar, y esa es una de las características de los delegados, y posiblemente lo que complica más su entendimiento.

Veamos ahora cómo asignamos el método al evento del control:

this.textBox1.TextChanged += new System.EventHandler(this.textBox1_TextChanged);

El evento lo conectamos por medio del constructor del delegado, el cual espera como parámetro un método, y lo que le pasamos es "un puntero al método", es decir, le indicamos dónde está ese método. Como hemos comentado antes, ese método debe cumplir con las especificaciones indicadas por el delegado, cosa que podemos comprobar si vemos el código del método que se utilizará cuando el evento se produzca:

private void textBox1_TextChanged(object sender, EventArgs e) {...}

Y tal como podemos ver, el método cumple a la perfección con la definición del delegado.

Utilizar un delegado para acceder a un método

Ahora veamos brevemente cómo usar los delegados, en este caso sin necesidad de que defina un evento.

Como hemos comentado, un delegado realmente es una clase que puede contener una referencia a un método, además define el prototipo del método que podemos usar como referencia. Sabiendo esto, podemos declarar una variable del tipo del delegado y por medio de esa variable acceder al método que indiquemos, siempre que ese método tenga la misma "firma" que el delegado. Parece complicado ¿verdad? Y no sólo lo parece, es que realmente lo es. Comprobemos esta "complicación" por medio de un ejemplo. En este código, que iremos mostrando poco a poco, vamos a definir un delegado, un método con la misma firma para que podamos usarlo desde una variable definida con el mismo tipo del delegado.

Definimos un delegado de tipo void que recibe un valor de tipo cadena:

delegate void Saludo(string nombre);

Definimos un método con la misma firma del delegado, el cual devolverá Hola, seguido del contenido del parámetro:

static private void mostrarSaludo(string elNombre)
{
    Console.WriteLine("Hola, " + elNombre);
}

Ahora vamos a declarar una variable para que acceda a ese método.
Para ello debemos declararla con el mismo tipo del delegado:

Saludo saludando;

La variable saludando es del mismo tipo que el delegado Saludo. La cuestión es ¿cómo o que asignamos a esta variable?

Primer intento:

Como hemos comentado, los delegados realmente son clases, por tanto podemos usar new Saludo y, según parece, deberíamos pasarle un nombre como argumento. Algo así:

saludando = new Saludo("Pepe");

Pero esto no funciona, entre otras cosas, porque hemos comentado que un delegado contiene (o puede contener) una referencia a un método, y "Pepe" no es un método ni una referencia a un método.

Segundo intento:

Por lógica y, sobre todo, por sentido común, máxime cuando hemos declarado un método con la misma "firma" que el delegado, deberíamos pensar que lo que debemos pasar a esa variable es el método, ya que un delegado puede contener una referencia a un método, por tanto podemos pensar que si creamos un nuevo objeto del tipo Saludo pasándole el nombre del método y el argumento...

saludando = new Saludo(mostrarSaludo("Pepe"));

Tampoco funciona, porque nos dice que espera un método.
Probemos entonces a indicarle sólo el nombre del método:

saludando = new Saludo(mostrarSaludo);

Ahora sí, al menos no da error de compilación, aunque, no muestra nada, cosa que es lógica porque en ningún sitio le hemos indicado la cadena que tiene que usar para el saludo.

¿Cómo podemos hacer que se muestre el saludo?

A ver, recapacitemos, tenemos una variable (saludando), que es del tipo del delegado (Saludo), y que "apunta" a un método (mostrarSaludo), que espera que le pasemos como argumento una cadena.

¿Podremos hacer esto?

saludando("Pepe");

¡Pues sí! Ahora muestra el saludo a "Pepe".

En realidad, cuando estamos usando la línea anterior, es como si estuviésemos llamando al método de esta forma:

mostrarSaludo("Pepe");

Qué forma de complicarnos la vida, ¿verdad?

Pero debemos pensar, que en este contexto funciona la llamada directa al método porque está definido en la misma clase que la variable declarada como el delegado.

EJEMPLO DEL VIDEO

CREAR EVENTOS EN CSHARP | C# .NET

2020-04-18T12:00:00.000-07:00

CREAR EVENTOS EN CSHARP | C# .NET

Eventos

En esta lección veremos cómo trabajar con los eventos producidos en una aplicación de Windows, con idea de que nos familiaricemos con ellos, y veamos la relación que tienen con los delegados; en la siguiente lección trataremos los delegados con más profundidad, para seguir con la forma de declararlos en nuestras clases.

Interceptar los eventos de los controles de un formulario

Debido a que aún no hemos visto el módulo dedicado a las aplicaciones de Windows, en las que se utilizan los "clásicos" formularios, no vamos a entrar en detalles sobre cómo crear un formulario ni como añadir controles, etc., todo eso lo veremos en el siguiente módulo. Para simplificar las cosas, veremos simplemente cómo definir un evento y asociarlo a un control e incluso al propio formulario, esto lo haremos de dos formas: usando el diseñador de Windows Forms, ya que esta será la manera más habitual de hacerlo, y la otra escribiendo el código directamente, ya que así empezaremos a adentrarnos en este mundo de los eventos y delegados, con idea de que lo que expliquemos a continuación sea más fácil de comprender.

Asociar un evento con un control

Cuando trabajamos con el diseñador de formularios, tenemos dos formas de asociar un evento con el código.

La primera es haciendo doble pulsación sobre el control en cuestión, de esta forma se creará un método que asociará el evento que esté predeterminado para ese control.

Por ejemplo, si hacemos doble-click en un botón, el evento predeterminado es el evento Click. Si esa misma acción la realizamos en una caja de textos, el evento predeterminado es TextChanged.

Si queremos asociar otros eventos con esos controles, tenemos que recurrir a la ventana de propiedades del diseñador de Windows Forms, que tal como podemos comprobar en la figura 2.12, nos muestra, entre otras cosas, un rayo el cual nos servirá para poder indicar los diferentes eventos que queramos interceptar en el control que actualmente tengamos seleccionado en el formulario.

En la figura 2.13 podemos ver algunos de los eventos que tenemos disponibles para un control TextBox.

Para crear un evento, simplemente haremos doble-click en el que nos interesa y el diseñador de formularios nos mostrará el método en el que podemos escribir nuestro código para cuando se produzca ese evento:

private void textBox1_TextChanged(object sender, EventArgs e)

{

}

Pero además de eso, el diseñador de formularios de Visual Studio .NET también ha añadido una línea de código que es la que realmente hace que se asocie un método con un evento, en el caso del evento TextChanged del control textBox1 que tenemos en el formulario, el código sería el siguiente:

this.textBox1.TextChanged += new System.EventHandler(this.textBox1_TextChanged);

Como vemos en los dos trozos de código, hay una relación entre el método que utilizaremos cuando se produzca el evento, el cual utiliza dos parámetros, que es la forma habitual de hacerlo en .NET. El primer parámetro es de tipo object y representa al control que ha producido el evento, el segundo parámetro es de una clase derivada de EventHandler que en algunos casos nos puede proporcionar información extra sobre el evento que se ha producido.

Para asociar el evento con ese método, en C# se utiliza el operador += seguido de la creación de un objeto al que se le pasa como argumento el nombre del procedimiento a usar para interceptar el evento.

La definición de la "clase" EventHandler que podemos encontrar en la ayuda de Visual C# .NET, es la siguiente:

public delegate void EventHandler(object sender, EventArgs e);

Como podemos apreciar realmente no es una clase normal, sino que es un "delegado". Y como también podemos ver, en ningún sitio se indica que reciba un solo parámetro. Aunque de esto nos ocuparemos más adelante, por ahora solo debemos saber que en C# los eventos siempre están ligados a los delegados.

Si seguimos buscando en la ayuda de Visual C# .NET, nos encontramos con esta definición del evento TextChanged:

public event EventHandler TextChanged;

Es decir, el evento TextChanged es del tipo del delegado EventHandler.

Para mantener un poco el suspense, dejemos aquí las explicaciones. Por ahora, simplemente debemos saber que para asociar un evento con un método, debemos usar el operador += para asignar el "manejador" de eventos al evento en cuestión, y lo que asignamos es un nuevo objeto basado en un tipo declarado como delegado al que le pasamos el nombre del procedimiento que se usará cuando se produzca el evento.

Asociar varios eventos a un mismo procedimiento

Algunas veces nos encontraremos en la situación de que estamos utilizando el mismo código para interceptar el mismo tipo de evento en controles diferentes, en esos casos nos puede interesar utilizar un solo método, en el que haremos el trabajo.

Asociarlos usando el diseñador de Windows Forms

La forma más fácil de asociar un mismo método con varios controles es hacerlo usando la ventana de propiedades, ver figura 2.13, en esa ventana de propiedades, además de crear nuevos métodos donde interceptar los eventos, podemos asociar un evento con un método ya existente.
Por ejemplo, si tenemos varios controles del tipo TextBox en los que nos interesa utilizar un solo método para seleccionar todo el texto cuando el control recibe el foco, podríamos escribir este código que inicialmente estaría asociado con el evento Enter del control textBox1:

private void textBox1_Enter(object sender, EventArgs e)

{

((TextBox)sender).SelectAll();

}

Lo que tenemos que hacer es lo siguiente:
-Seleccionamos el control al que queremos asociar ese mismo evento.
-En la ventana de propiedades, (con la opción de eventos seleccionada), buscamos el evento Enter, y en lugar de hacer doble pulsación, (porque si lo hacemos crearía un nuevo procedimiento), lo que tenemos que hacer es presionar el combo que es lo que se usa para indicar el método usado, de la lista desplegable que se muestra, (ver figura 2.14), seleccionamos el método que nos interese. En nuestro ejemplo, seleccionaríamos textBox1_Enter.

Como podemos apreciar en la figura 2.14, en la lista desplegable se muestran tres métodos, esto es así porque todos ellos tienen los parámetros adecuados al tipo de evento que hemos seleccionado.

Asociarlos usando código

Si en lugar de asociar un mismo método usando el diseñador de Windows Forms, queremos hacerlo por código, lo podemos añadir en el constructor del formulario después de la llamada al método InitializeComponent().
El IDE de Visual C# .NET nos ayuda a la hora de crear el manejador de eventos, tal como podemos ver en la figura 2.15:

Figura 2.15. Ayuda del IDE de C# para crear manualmente manejadores de eventos

Si presionamos la tecla TAB se añadirá automáticamente el código necesario para "ligar" ese evento con el método que el IDE de C# "cree" que debe ser, en este caso, sería textBox2_Enter, pero una vez que el IDE ha añadido el código podemos cambiarlo para que apunte al que realmente nos interesa.

En caso de que ese evento ya esté asociado con otro método, el IDE nos avisará de ese hecho.

EVENTOS Y DELEGADOS EN CSHARP | C# .NET

2020-04-17T09:20:00.001-07:00

EVENTOS Y DELEGADOS EN CSHARP | C# .NET

Introducción

La forma que tienen nuestras clases y estructuras de comunicar que algo está ocurriendo, es por medio de eventos. Los eventos son mensajes que se lanzan desde una clase para informar al "cliente" que los utiliza de que está pasando algo.

Seguramente estaremos acostumbrados a usarlos, incluso sin tener una noción consciente de que se tratan de eventos, o bien porque es algo tan habitual que no le prestamos mayor atención, es el caso de las aplicaciones de escritorio, cada vez que presionamos un botón, escribimos algo o movemos el mouse se están produciendo eventos.

En Visual C# .NET podemos definir eventos en nuestras clases, pero como comprobaremos, estos están totalmente relacionados con los delegados.

En esta lección veremos que son los delegados y que relación tienen con los eventos, también veremos que podemos tener mayor control sobre cómo se interceptan los eventos e incluso cómo y cuándo se asocian los eventos en la aplicación cliente, aunque primero empezaremos viendo cómo declarar y utilizar eventos en nuestros tipos de datos.

Eventos y delegados

Eventos

Interceptar los eventos de los controles de un formulario
Asociar un evento con un control
Asociar varios eventos a un mismo procedimiento

Asociarlos usando el diseñador de Windows Forms
Asociarlos usando código

Delegados

Definición "formal" de delegado
Utilizar un delegado para acceder a un método
Cómo producir eventos
Los delegados y los métodos anónimos
¿Qué ocurre cuando se asigna y se produce un evento?

TRY CATCH FINALLY EN CSHARP | C# .NET

2020-04-13T16:31:00.000-07:00

Manejo de Excepciones en C# .NET

Es indiscutible que por mucho que nos lo propongamos, nuestras aplicaciones no estarán libres de errores, y no nos referimos a errores sintácticos, ya que, afortunadamente, el IDE (Integrated Development Envirnment, entorno de desarrollo integrado) de Visual Studio nos avisará de cualquier error sintáctico e incluso de cualquier asignación no válida, pero de lo que no nos avisará, como es lógico, será de los errores que se produzcan en tiempo de ejecución. Para estos casos, C# pone a nuestra disposición el manejo de excepciones, veamos pues cómo utilizarlo.

En Visual C# .NET se utiliza un tratamiento estructurado de excepciones, de esta forma podemos detectar los errores que se produzcan en nuestras aplicaciones de una forma más "ordenada".

Manejo de excepciones estructuradas

Las excepciones en C# las podemos controlar usando las instrucciones try / catch / finally. Estas instrucciones realmente son bloques de instrucciones, y por tanto estarán delimitadas con un par de llaves.

Cuando queramos controlar una parte del código que puede producir un error lo incluimos dentro del bloque try, si se produce un error, éste lo podemos detectar en el bloque catch, por último, independientemente de que se produzca o no una excepción, podemos ejecutar el código que incluyamos en el bloque finally.

Cuando creamos una estructura de control de excepciones no estamos obligados a usar los tres bloques, aunque el primero: try si es necesario, ya que es el que le indica al compilador que tenemos intención de controlar los errores que se produzcan. Por tanto, podemos crear un "manejador" de excepciones usando los tres bloques, usando try y catch o usando try y finally.

Veamos ahora con más detalle cada uno de estos bloques y que es lo que podemos hacer en cada uno de ellos.

Bloque try

En este bloque incluiremos el código en el que queremos comprobar los errores.
El código a usar será un código normal, es decir, no tenemos que hacer nada en especial, ya que en el momento que se produzca el error se usará (si hay) el código del bloque catch.

Bloque catch

Si se produce una excepción, ésta la capturamos en un bloque catch.

En el bloque catch podemos indicar que tipo de excepción queremos capturar, para ello usaremos una variable de tipo Exception, la cual puede ser del tipo de error específico que queremos controlar o de un tipo genérico.

Por ejemplo, si sabemos que nuestro código puede producir un error al trabajar con ficheros, podemos usar un código como éste:

try

    // código para trabajar con ficheros, etc.

catch(System.IO.IOException ex)

    // el código a ejecutar cuando se produzca ese error

Si nuestra intención es capturar todos los errores que se produzcan, es decir, no queremos hacer un filtro con errores específicos, podemos usar la clase Exception como tipo de excepción a capturar. La clase Exception es la más genérica de todas las clases para manejo de excepciones, por tanto, capturará todas las excepciones que se produzcan.

try

    // código que queremos controlar

catch(System.Exception ex)

    // el código a ejecutar cuando se produzca cualquier error

Aunque si no vamos usar la variable indicada en el bloque Catch, pero queremos que no se detenga la aplicación cuando se produzca un error, podemos hacerlo de esta forma:

try

    // código que queremos controlar

catch

    // el código a ejecutar cuando se produzca cualquier error

La variable indicada en el bloque catch la podemos usar para mostrar un mensaje al usuario o para obtener información extra sobre el error, pero no siempre vamos a hacer uso de esa variable, en ese caso podemos utilizar el código anterior, en el que no se usa una variable y tampoco se indica el tipo de error que queremos interceptar. Pero es posible que nuestra intención sea capturar errores de un tipo concreto sin necesidad de utilizar una variable, en ese caso podemos crear un bloque catch como el siguiente, en el que solo se indica el tipo de excepción:

try

    // código que queremos controlar

catch(FormatException)

    // interceptar los errores del tipo FormatException

Varias capturas de errores en un mismo bloque try/catch

En un mismo try/catch podemos capturar diferentes tipos de errores, para ello podemos incluir varios bloques catch, cada uno de ellos con un tipo de excepción diferente.

Es importante tener en cuenta que cuando se produce un error y usamos varios bloques catch, el CLR de .NET buscará la captura que mejor se adapte al error que se ha producido, pero siempre lo hará examinando los diferentes bloques catch que hayamos indicado empezando por el indicado después del bloque try, por tanto deberíamos poner las más genéricas al final, de forma que siempre nos aseguremos de que las capturas de errores más específicas se intercepten antes que las genéricas.

Aunque el propio compilador de C# detectará si hay capturas de errores genéricas antes que las más específicas, avisándonos de ese hecho.

En el siguiente código capturamos un error específico y también uno genérico, con idea de que tengamos siempre controlado cualquier error que se produzca:

try

    // código que queremos controlar

catch(FormatException)

    // captura de error de formato

catch(Exception ex)

    // captura del resto de errores

Bloque finally

En este bloque podemos indicar las instrucciones que queremos que se ejecuten, se produzca o no una excepción. De esta forma nos aseguramos de que siempre se ejecutará un código, por ejemplo, para liberar recursos, se haya producido un error o no.

En este código tenemos tres capturas de errores diferentes y un bloque finally que siempre se ejecutará, se produzca o no un error:

int i, j;

//

try

    Console.Write("Un numero ");

    i = Convert.ToInt32(Console.ReadLine());

    Console.Write("Otro numero ");

    j = Convert.ToInt32(Console.ReadLine());

    int r = i / j;

    Console.WriteLine("El resultado es: {0}", r);

catch (FormatException)

    Console.WriteLine("No es un número válido");

    // Salimos de la función, pero se ejecutará el finally

    return;

catch (DivideByZeroException)

    Console.WriteLine("La división por cero no está permitida.");

catch (Exception ex)

    // Captura del resto de excepciones

    Console.WriteLine(ex.Message);

finally

    // Este código siempre se ejecutará

    Console.WriteLine("Se acabó");

Nota:
Hay que tener en cuenta de que incluso si usamos return dentro de un bloque de control de errores, se ejecutará el código indicado en el bloque finally.

Captura de errores no controlados

Como es lógico, si no controlamos las excepciones que se puedan producir en nuestras aplicaciones, éstas serán inicialmente controladas por el propio runtime de .NET, en estos casos la aplicación se detiene y se muestra el error al usuario. Pero esto es algo que no deberíamos consentir, por tanto, siempre deberíamos detectar todos los errores que se produzcan en nuestras aplicaciones, pero a pesar de que lo intentemos, es muy probable que no siempre podamos conseguirlo.

Una forma de hacerlo es iniciando nuestra aplicación dentro de un bloque try/catch, de esta forma, cuando se produzca el error, se capturará en ese bloque catch, porque cuando el runtime de .NET se encuentra con una excepción, lo que hace es revisar "la pila" de llamadas y buscar algún try/catch, si lo encuentra, lo utiliza, y si no lo encuentra, se encarga de lanzar la excepción deteniendo el programa.

Esto es importante saberlo, no ya por detectar esos errores que no hemos tenido la previsión de controlar, sino porque es posible que, si un error se produce dentro de un método en el que no hay captura de errores, pero antes de llamar a ese método hemos usado un try/catch, el error será interceptado por ese catch, aunque posiblemente ni siquiera lo pusimos pensando que podía capturar errores producidos en otros niveles más profundos de nuestra aplicación.

* EJEMPLOS DEL VIDEO *

EJEMPLO 1

EJEMPLO 2

EJEMPLO 3

INTERFACES EN CSHARP | C# .NET

2020-04-11T13:53:00.000-07:00

Interfaces en CSharp

Las interfaces son un elemento bastante importante en .NET Framework, ya que de hecho se utiliza con bastante frecuencia, en esta lección veremos que son las interfaces y como utilizarlas en nuestros proyectos, también veremos qué papel juegan en .NET y cómo aplicar algunas de las definidas en la biblioteca base.

¿Qué es una interfaz?

Las interfaces son una forma especial de una clase, aunque la diferencia principal con las clases es que las interfaces no contienen código ejecutable, solo definen los miembros y, en el caso de los métodos, si reciben parámetros y de qué tipo son.

Las interfaces se utilizan para indicar el "comportamiento" que tendrá una clase, o al menos qué miembros debe definir esa clase.

Para definir una interfaz en C# tenemos que usar la instrucción interface seguida del nombre y encerrado entre un par de llaves los miembros que define:

public interface ICamara

{

//...

}

Tal como comentamos en el apartado de la accesibilidad, los miembros de una interfaz siempre son públicos, pero no debemos indicarlo, ya que se sobreentiende que es así y el compilador produciría un error indicándonos que el modificador de accesibilidad no se puede aplicar a ese tipo de elementos.

Como los miembros de las interfaces no contienen código ejecutable, solo debemos definir la "firma" del método, propiedad o evento que queremos definir. En el caso de las propiedades, tendremos que indicar los bloques get y/o set que la clase o tipo que la implemente debe definir.

public interface ICamara

{

void Mostrar();

void TomarFotografia();

string NombreDeFoto { get; set;}

int CantidadDeFotos { get;}

}

Nota:
Según las indicaciones de nomenclatura de .NET Framework, se recomienda que todas las interfaces empiecen con una I mayúscula seguida del nombre al que hacer referencia la interfaz.

¿Qué puede contener una interfaz?

Tal como hemos visto anteriormente, una interfaz pude contener cualquiera de los miembros que una clase puede contener, salvo los campos; por tanto, también puede contener eventos, sin embargo para poder definir un evento en una interfaz, antes debemos definir el delegado que se usará con ese evento.

En el siguiente ejemplo tenemos una interfaz que define todos los tipos de miembros posibles, también debemos implementar tanto el bloque get como el set y en el otro, que devuelve un valor del mismo tipo que la interfaz, solo define el bloque get:

// Declaración del delegado para el evento de la interfaz

public delegate void EjecutantoAppCamara();

public interface ICamara

{

void Mostrar();

void TomarFotografia();

string NombreDeFoto { get; set;}

int CantidadDeFotos { get;}

event EjecutandoAppCamara AbrirCamara;

}

Una interfaz es un contrato

Siempre que leemos sobre las interfaces, lo primero con lo que nos solemos encontrar es que una interfaz es un contrato. Veamos que nos quieren decir con esa frase.

Tal como acabamos de ver, las interfaces solo definen los miembros, pero no el código a usar en cada uno de ellos, esto es así precisamente porque el papel que juegan las interfaces es el de solo indicar que es lo que una clase o estructura puede, o mejor dicho, debe implementar.

Si en una clase indicamos que queremos "implementar" una interfaz, esa clase debe definir cada uno de los miembros que la interfaz expone. De esta forma nos aseguramos de que, si una clase implementa una interfaz, también implementa todos los miembros definidos en dicha interfaz.

Cuando una clase implementa una interfaz está firmando un contrato con el que se compromete a definir todos los miembros que la clase define, de hecho, el propio compilador nos obliga a hacerlo.

Usar una interfaz en una clase

Para poder utilizar una interfaz en una clase, o dicho de otra forma: para "implementar" los miembros expuestos por una interfaz en una clase debemos hacerlo a continuación del nombre de la clase, separándola con dos puntos y a continuación el nombre de la interfaz:

public class Celulares : ICamara

{

}

Para implementar la Interface solo seleccionamos ICamara y nos aparecerán las opciones de implementación, seleccionamos “Implementar Interfaz:”:

Y como Resultado tendremos la implementación de la interfaz ICamara en nuestra clase Celulares

EJEMPLOS DEL VÍDEO:

EJEMPLO 1

EJEMPLO 2

EJEMPLO 3

CREAR PROPIEDADES EN CSHARP | C# .NET

2020-04-09T14:13:00.000-07:00

Propiedades

Las propiedades son los miembros de los tipos que nos permiten acceder a los datos que dicho tipo manipula. Normalmente una propiedad está relacionada con un campo, de forma que el campo sea el que realmente contenga el valor y la propiedad simplemente sea una especie de método a través del cual podemos acceder a ese valor.

Debido a que el uso de las propiedades realmente nos permite acceder a los valores de una clase (o tipo), se suelen confundir los campos con las propiedades, pero realmente un campo (o variable) público no es una propiedad, al menos en el sentido de que el propio .NET Framework no lo interpreta como tal, aunque en la práctica nos puede parecer que es así, ya que se utilizan de la misma forma. Pero no debemos dejarnos llevar por la comodidad y si no queremos perder funcionalidad, debemos diferenciar en nuestro código las propiedades de los campos.

Lo primero que debemos tener presente es que gracias a esta diferenciación que hace .NET Framework, podemos poner en práctica una de las características de la programación orientada a objetos: la encapsulación, de forma, que la manipulación de los datos que una clase contiene siempre se deben hacer de forma "interna" o privada a la clase, dejando a las propiedades la posibilidad de que externamente se manipulen de forma controlada, esos datos. De esta forma tendremos mayor control sobre cómo se acceden o se asignan los valores a esos datos, ya que, al definir una propiedad, tal como hemos comentado, realmente estamos definiendo un procedimiento con el cual podemos controlar cómo se acceden a esos datos.

Definir una propiedad en C# .NET

Debido a que una propiedad realmente nos permite acceder a un dato que la clase (o estructura) manipula, siempre tendremos un campo relacionado con una propiedad. El campo será el que contenga el valor y la propiedad será la que nos permita manipular ese valor.

En C#, las propiedades las declaramos como cualquier otra función, con la diferencia de que no podemos usar paréntesis después del nombre y que en el cuerpo de la propiedad, que estará limitado por las típicas llaves, tendremos que indicar dos bloques de código, los cuales servirán para diferenciar el código que el compilador utilizará para recuperar el valor de la propiedad o el usado para hacer la asignación.

Esos dos bloques estarán indicados por la instrucción get, para recuperar el valor, y la instrucción set, para asignar el valor.

El bloque set tendrá un parámetro implícito que representa al valor indicado a la derecha del signo igual de la asignación y se llama value.

La mejor forma de aclarar cómo se define una propiedad es viendo un ejemplo.

public class Celulares

{

private string marca;

public string Marca

{

get

{

return marca;

}

set

{

marca = value;

}

Como podemos comprobar tenemos dos bloques de código, el bloque get que es el que se usa cuando queremos acceder al valor de la propiedad, por tanto devolvemos el valor del campo privado usado para almacenar ese dato. El bloque set es el usado cuando asignamos un valor a la propiedad, este bloque tiene predefinido un parámetro (value) que representa al valor que queremos asignar a la propiedad.

Nota:
En este ejemplo, estamos usando marca (con eme minúscula) para el campo privado, y Marca con la eme en mayúsculas para el nombre de la propiedad, esta es la recomendación que se hace para los desarrolladores de .NET, y en C# se puede seguir "al pie de la letra" porque, como sabemos, C# considera diferentes a las variables que solo se diferencian por las mayúsculas y minúsculas.

Propiedades de sólo lectura

En ciertas ocasiones nos puede resultar interesante que una propiedad sea de sólo lectura, de forma que el valor que representa no pueda ser cambiado.

Para definir una propiedad de solo lectura en C# basta con definir solo el bloque get de la propiedad.

En el siguiente código definimos una propiedad de solo lectura llamada FechaDeHoy:

public DateTime FechaDeHoy

{

get

{

return DateTime.Now;

}

Propiedades de sólo escritura

De igual forma, si queremos definir una propiedad que sea de sólo escritura, solo definiremos el bloque set, tal como podemos ver en este código:

public string Clave

{

set

{

if( value == "1234ABCD" )

{

// Entrar al Sistema

}

Diferente accesibilidad para los bloques get y set

Una de las novedades de Visual C# .NET con respecto a las versiones anteriores de este lenguaje es que en las propiedades normales (de lectura y escritura), podemos definir diferentes niveles de accesibilidad a cada uno de los dos bloques que forman una propiedad.

Por ejemplo, podríamos definir el bloque get como público, (siempre accesible), y el bloque set como private, de forma que solo se puedan realizar asignaciones desde dentro de la propia clase.

Por ejemplo, los MensajesNoLeidos de un Celular podríamos declararlo para que desde cualquier punto se pueda saber dicha cantidad, pero la asignación de dicho importe solo estará accesible para los procedimientos definidos en la propia clase:

public class Celulares

{

private int mensajesNoLeidos;

public decimal MensajesNoLeidos

{

get

{

return mensajesNoLeidos;

}

private set

{

mensajesNoLeidos = value;

}

Para hacer que el bloque set sea privado, lo indicamos con el modificador de accesibilidad private, al no indicar ningún modificador en el bloque get, éste será el mismo que el de la propiedad.

Nota:
El nivel de accesibilidad de los bloques get o set debe ser igual o inferior que el de la propiedad, por tanto si la propiedad la declaramos como private, no podemos definir como público ninguno de los bloques get o set.

EJEMPLOS DEL VÍDEO

Ejemplo 1

Ejemplo 2

Ejemplo 3

ACCESIBILIDAD Y AMBITOS EN CSHARP .NET

2020-04-04T16:36:00.000-07:00

Accesibilidad y Ámbitos en C# .NET

Tal y como comentamos anteriormente, dependiendo de dónde y cómo estén declarados los tipos de datos y los miembros definidos en ellos, tendremos o no acceso a esos elementos.

Recordemos que el ámbito es el alcance con el que podemos acceder a un elemento y depende de dónde esté declarado; por otro lado, la accesibilidad depende de cómo declaremos cada uno de esos elementos.

Ámbito

Dependiendo de donde declaremos un miembro o un tipo, éste tendrá mayor alcance o cobertura, o lo que es lo mismo, dependiendo del ámbito en el que usemos un elemento, podremos acceder a él desde otros puntos de nuestro código.
A continuación veremos con detalle los ámbitos en los que podemos declarar los distintos elementos de Visual C# .NET.

Ámbito de bloque: Disponible únicamente en el bloque de código en el que se ha declarado.
Por ejemplo, si declaramos una variable dentro de un bucle for o un if, esa variable solo estará accesible dentro de ese bloque de código.
Ámbito de procedimiento: Disponible únicamente dentro del procedimiento en el que se ha declarado. Cualquier variable declarada dentro de un procedimiento (método o propiedad) solo estará accesible en ese procedimiento y en cualquiera de los bloques internos a ese procedimiento.
Ámbito de módulo: Disponible en todo el código de la clase o la estructura donde se ha declarado. Las variables con ámbito a nivel de módulo, también estarán disponibles en los procedimientos declarados en el módulo (clase o estructura) y por extensión a cualquier bloque dentro de cada procedimiento.
Ámbito de espacio de nombres: Disponible en todo el código del espacio de nombres. Este es el nivel mayor de cobertura o alcance, aunque en este nivel solo podemos declarar tipos como clases, estructuras y enumeraciones, ya que los procedimientos solamente se pueden declarar dentro de un tipo.

Nota:
Por regla general, cuando declaramos una variable en un ámbito, dicha variable "ocultará" a otra que tenga el mismo nombre y esté definida en un bloque con mayor alcance, aunque veremos que en C# existen ciertas restricciones dependiendo de dónde declaremos esas variables.

En Visual C# .NET podemos definir una variable dentro de un bloque de código, en ese caso dicha variable solo será accesible dentro de ese bloque. Aunque, como veremos a continuación, en un procedimiento solamente podremos definir variables que no se oculten entre sí, estén o no dentro de un bloque de código.

Ámbito de bloque

En los siguientes ejemplos veremos cómo podemos definir variables para usar solamente en el bloque en el que están definidas.

Los bloques de código en los que podemos declarar variables son los bucles, (for,foreach, do, while), y los bloques condicionales, (if, switch), o en cualquier otro bloque formado por un par de llaves.
Por ejemplo, dentro de un procedimiento podemos tener varios de estos bloques y por tanto podemos definir variables "internas" a esos bloques:

int n = 3;
//
for(int i = 1; i <= 10; i++ )
{
    int j = 0;
    j += 1;
    if( j < n )
    {
        //...
    }
}
//
if( n < 5 )
{
    int j = n * 3;
}
//
do
{
    int j = 0;
    for(int i = 1; i <= n; i++)
    {
        j += i;
    }
    if( j > 10 ) break;
}while(true);

La variable n estará disponible en todo el procedimiento, por tanto podemos acceder a ella desde cualquiera de los bloques.
En el primer bucle for, definimos la variable i como la variable a usar de contador, esta variable solamente estará accesible dentro de este bucle for. Lo mismo ocurre con la variable j.
En el primer if definimos otra variable j, pero esa solo será accesible dentro de este bloque y por tanto no tiene ninguna relación con la definida en el bucle for anterior.
En el bucle do volvemos a definir nuevamente una variable j, a esa variable la podemos acceder solo desde el propio bucle do y cualquier otro bloque de código interno, como es el caso del bucle for, en el que nuevamente declaramos una variable llamada i, que nada tiene que ver con el resto de variables declaradas con el mismo nombre en los otros bloques.

Nota:
El código del bucle do mostrado anteriormente se convertirá en un bucle infinito, ya que la variable j siempre se pone a cero en cada repetición del bucle do/while, por tanto solo hay que tomarlo como un ejemplo para probar lo del ámbito de las variables.

Lo único que no podemos hacer en cualquiera de esos bloques, es declarar una variable llamada n, ya que, al estar declarada en el procedimiento, el compilador de C# nos indicará que no podemos ocultar una variable previamente definida fuera del bloque, tal como podemos ver en la figura 1

Figura Error al ocultar una variable definida en un procedimiento

Esta restricción solo es aplicable a las variables declaradas en el procedimiento, ya que, si declaramos una variable a nivel de módulo, no habrá ningún problema para usarla dentro de un bloque, esto es así porque en un procedimiento podemos declarar variables que se llamen de la misma forma que las declaradas a nivel de módulo, aunque éstas ocultarán a las del "nivel" superior.

Ámbito de procedimiento

Las variables declaradas en un procedimiento tendrán un ámbito o cobertura que será el procedimiento en el que está declaradas, y como hemos visto, ese ámbito incluye también cualquier bloque de código declarado dentro del procedimiento.
Estas variables ocultarán a las que se hayan declarado fuera del procedimiento, si bien, dependiendo del tipo de módulo, podremos acceder a esas variables "externas" indicando el nombre completo del módulo o bien usando la instrucción this seguida del nombre de la variable.

Pero mejor veámoslo con un ejemplo. En el siguiente código, definimos una clase en la que tenemos un campo llamado Nombre, también definimos un método en el que internamente se utiliza una variable llamada Nombre, para acceder a la variable declarada en la clase, tendremos que usar la instrucción o palabra clave this.

public class Celulares
{
    public string Marca = "MAXCEL";
    public string MostrarEspecificaciones()
    {
        string Marca= "PROTOTIPO";
        return "Externo= " + this.Marca + ", interno= " + Marca;
    }
}

Ámbito de módulo

Cuando hablamos de módulos, nos estamos refiriendo a una clase, a una estructura o a cualquier otro tipo de datos que nos permita .NET.
En estos casos, las variables declaradas dentro de un tipo de datos serán visibles desde cualquier parte de ese tipo, siempre teniendo en cuenta las restricciones mencionadas en los casos anteriores.

Ámbito de espacio de nombres

Los espacios de nombres son los contenedores de tipos de datos de mayor nivel, y sirven para contener definiciones de clases, estructuras, enumeraciones y delegados. Cualquier tipo definido a nivel de espacio de nombres estará disponible para cualquier otro elemento definido en el mismo espacio de nombres.
Al igual que ocurre en el resto de ámbitos "inferiores", si definimos un tipo en un espacio de nombres, podemos usar ese mismo nombre para nombrar a un procedimiento o a una variable, en cada caso se aplicará el ámbito correspondiente y, tal como vimos anteriormente, tendremos que usar nombres únicos para poder acceder a los nombres definidos en niveles diferentes.

Accesibilidad

La accesibilidad es la característica que podemos aplicar a cualquiera de los elementos que definamos en nuestro código. Dependiendo de la accesibilidad declarada tendremos distintos tipos de accesos a esos elementos.

Los modificadores de accesibilidad que podemos aplicar a los tipos y elementos definidos en nuestro código pueden ser cualquiera de los mostrados en la siguiente lista:

public: Acceso no restringido. Este es modificador de accesibilidad con mayor "cobertura", podemos acceder a cualquier miembro público desde cualquier parte de nuestro código. Aunque, como veremos, este acceso no restringido puede verse reducido dependiendo de dónde lo usemos.
protected: Acceso limitado a la clase contenedora o a los tipos derivados de esta clase. Este modificador solamente se usa con clases que se deriven de otras.
internal: Acceso limitado al proyecto actual (o ensamblado).
protected internal: Acceso limitado al proyecto actual o a los tipos derivados de la clase contenedora. Una mezcla de los dos modificadores anteriores.
private: Acceso limitado al tipo contenedor. Es el más restrictivos de todos los modificadores de accesibilidad.

Estos modificadores de accesibilidad los podemos usar tanto en clases, estructuras, interfaces, enumeraciones, delegados, eventos, métodos, propiedades y campos. Aunque no serán aplicables en espacios de nombres (Namespace) ni en los miembros de las interfaces y enumeraciones.

Accesibilidad de las variables en los procedimientos

Las variables declaradas dentro de un procedimiento solo son accesibles dentro de ese procedimiento, en este caso solo se puede aplicar el ámbito privado, aunque no podremos usar la instrucción private, sino declararlas de la forma habitual.

Las accesibilidades predeterminadas

La accesibilidad de un tipo, variable o procedimiento en la que no hemos indicado el modificador de accesibilidad dependerá del sitio en el que lo hemos declarado.

Por ejemplo, las clases y estructuras definidas a nivel de un espacio de nombres solo pueden ser declaradas como public o internal, y si no llevan un modificador de accesibilidad, por defecto serán internal, es decir serán visibles en todo el proyecto actual. Por otro lado, las interfaces y enumeraciones por defecto serán públicas.
Cuando la clase, estructura, interfaz o enumeración está definida dentro de otro tipo, la accesibilidad predeterminada será private, pero admitirán cualquiera de los modificadores, salvo las interfaces y enumeraciones que no pueden ser protected.

Por otro lado, los miembros de esos tipos también permiten diferentes niveles de accesibilidad, en el caso de las interfaces y enumeraciones, siempre serán públicos, aunque no se permite el uso de esa instrucción. Los miembros de as clases y estructuras serán privados de forma predeterminada, en el caso de las clases, en esos miembros podemos indicar cualquiera de los cinco niveles de accesibilidad, mientras que en las estructuras no podremos declarar ningún miembro como protected o protected internal, ya que una estructura no puede usarse como base de otro tipo de datos.

Anidación de tipos

Tal como hemos comentado en la sección, podemos declarar tipos dentro de otros tipos, por tanto el ámbito y accesibilidad de esos tipos dependen del ámbito y accesibilidad del tipo que los contiene. Por ejemplo, si declaramos una clase con acceso internal, cualquier tipo que esta clase contenga siempre estará supeditado al ámbito de esa clase, por tanto si declaramos otro tipo interno, aunque lo declaremos como public, nunca estará más accesible que la clase contenedora, aunque en estos casos no habrá ningún tipo de confusión, ya que para acceder a los tipos declarados dentro de otros tipos siempre tendremos que indicar la clase que los contiene.

En el siguiente código podemos ver cómo declarar dos clases "anidadas". Tal como podemos comprobar, para acceder a la clase Salario debemos indicar la clase Cliente, ya que la única forma de acceder a una clase anidada es mediante la clase contenedora.

internal class Celulares
{
    public string Marca;

    public class Pantalla
    {
        public float Medida;
    }
}

// Para usar la clase Celulares debemos declararla de esta forma:
Celulares.Marca s = new Celulares.Marca();
s.Pantalla = 6.3F;

Los tipos anidables

Las clases y estructuras pueden contener otros tipos, mientras que las interfaces y enumeraciones no pueden contener otros tipos anidados.

Los espacios de nombres pueden anidarse dentro de otros espacios de nombres y estos pueden contener definiciones de cualquiera de los tipos que C# nos permite crear.

El nombre completo de un tipo

Tal como hemos visto, al poder declarar tipos dentro de otros tipos y estos a su vez pueden estar definidos en espacios de nombres, podemos decir que el nombre "completo" de un tipo cualquiera estará formado por el/los espacios de nombres y el/los tipos que los contiene, por ejemplo si la clase Cliente definida anteriormente está a su vez dentro del espacio de nombres Ambitos, el nombre completo será: Ambitos.Cliente y el nombre completo de la clase Salario será: Ambitos.Cliente.Salario.
Aunque para acceder a la clase Cliente no es necesario indicar el espacio de nombres, al menos si la queremos usar desde cualquier otro tipo declarado dentro de ese espacio de nombres, pero si nuestra intención es usarla desde otro espacio de nombre externo a Ambitos, en ese caso si que tendremos que usar el nombre completo.

Por ejemplo, en el siguiente código tenemos dos espacios de nombres que no están anidados, cada uno de ellos declara una clase y desde una de ellas queremos acceder a la otra clase, para poder hacerlo debemos indicar el nombre completo, ya que en caso contrario, el compilador de Visual C# .NET sería incapaz de saber a que clase queremos acceder.

namespace Uno
{
    public class Clase1
    {
        public string Marca;
    }
}

namespace Dos
{
    public class Clase2
    {
        public string Marca;
        public void Prueba()
        {
            Uno.Clase1 c1 = new Uno.Clase1();
            c1.Marca = "MAXCEL";
        }
    }
}

Esto mismo lo podemos aplicar en el caso de que tengamos dos clases con el mismo nombre en espacios de nombres distintos.

Nota:
En el mismo proyecto podemos tener más de una declaración de un espacio de nombres con el mismo nombre, en estos casos el compilador lo tomará como si todas las clases definidas estuvieran dentro del mismo espacio de nombres, aunque estos estén definidos en ficheros diferentes.

Importación de espacios de nombres

Tal como hemos comentado, los espacios de nombres pueden contener otros espacios de nombres y estos a su vez también pueden contener otros espacios de nombres o clases, y como hemos visto, para poder acceder a una clase que no esté dentro del mismo espacio de nombres debemos indicar el "nombre completo".

Para evitar estar escribiendo todos los espacios de nombres en los que está la clase que nos interesa declarar, podemos usar una especie de acceso directo o para que lo entendamos mejor, podemos crear una especie de "Path", de forma que al declarar una variable, si esta no está definida en el espacio de nombres actual, el compilador busque en todos los espacios de nombres incluidos en esas rutas (paths).

Esto lo conseguimos usando la instrucción using seguida del espacio de nombres que queremos importar o incluir en el path de los espacios de nombres.
Podemos usar tantas importaciones de espacios de nombres como necesitemos y estas siempre deben aparecer al principio del fichero.

Por ejemplo, si tenemos el código anterior y hacemos la importación del espacio de nombres en el que está definida la clase Clase1:

using Uno;

podremos acceder a esa clase de cualquiera de estas dos formas:

Uno.Clase1 c1 = new Uno.Clase1();

Clase1 c1 = new Clase1();

Alias de espacios de nombres

Si hacemos demasiadas importaciones de nombres, el problema con el que nos podemos encontrar es que el IntelliSense de Visual C# .NET no sea de gran ayuda, ya que mostrará una gran cantidad de clases, y seguramente nos resultará más difícil encontrar la clase a la que queremos acceder, o también podemos encontrarnos en ocasiones en las que nos interese usar un nombre corto para acceder a las clases contenidas en un espacio de nombres, por ejemplo, si queremos indicar de forma explícita las clases de un espacio de nombres como el de System.IO, podemos hacerlo de esta forma:

using io = System.IO;

De esta forma podemos usar el "alias" io para acceder a las clases y demás tipos definidos en ese espacio de nombres. En la figura 2 podemos ver que al escribir esa palabra, el IntelliSense nos muestra un mensaje de que realmente esa palabra es el espacio de nombres System.IO.
En la figura 2 al escribir el punto, podemos ver los miembros del espacio de nombres al que hace referencia el alias io.

Figura 2 IntelliSense y los alias a los espacios de nombres

ALGUNOS EJEMPLOS SOBRE ÁMBITO DE VARIABLES:

ESTRUCTURAS EN CSHARP | Struct C# .NET

2020-03-31T08:33:00.000-07:00

Ejemplos de Struct C#

Hola Amigos, en la publicación anterior hemos aprendido que las clases son un tipo de referencia. C# incluye una entidad de tipo de valor igual a la clase llamada "struct". Las estructuras son principalmente útiles para mantener valores de datos pequeños. Se puede definir una estructura utilizando el operador struct. Puede contener un constructor parametrizado, un constructor estático, constantes, campos, métodos, propiedades, indexadores, operadores, eventos y tipos anidados.

Una estructura se declara usando la palabra clave struct con un modificador público o interno. El modificador predeterminado es interno para la estructura y sus miembros. Sin embargo, puede usar un modificador privado o protegido cuando se declare dentro de una clase.

A continuación se declara la estructura simple que contiene datos para los celulares.

Ejemplo de declaración:

struct Celulares

{

public int MemoriaInterna;

public string Marca;

public string Modelo;

}

Se puede crear un objeto struct con o sin el operador new, igual que las variables de tipo primitivo. Cuando crea un objeto struct utilizando el operador new, se llama a un constructor apropiado.

Ejemplo:

struct Celulares

{

public int MemoriaInterna;

public string Marca;

public string Modelo;

}

Celulares cel = new Celulares();

Console.WriteLine(cel.MemoriaInterna); // imprime 0

En el código anterior, se crea un objeto de la estructura Celular utilizando palabra clave new. A esto se le llama al constructor sin parámetros predeterminado que inicializa a todos los miembros a su valor predeterminado.

Cuando se crea un objeto de estructura sin usar la palabra clave new, no llama a ningún constructor y por lo tanto, todos los miembros permanecen sin asignar. Por lo tanto, debe asignar valores a cada miembro antes de acceder a ellos, de lo contrario dará un error de tiempo de compilación.

Ejemplo:

Constructores: Struct

Una estructura no puede contener un constructor sin parámetros. Solo puede contener constructores parametrizados o un constructor estático. Puede declarar un constructor parametrizado para inicializar miembros de estructura, como se muestra a continuación.

Ejemplo:

Tenga en cuenta que debe asignar valores a todos los miembros de una estructura en el constructor parametrizado, de lo contrario, dará un error en tiempo de compilación si algún miembro permanece sin asignar.

Una estructura puede incluir un constructor estático sin parámetros y campos estáticos.

Ejemplo:

Métodos y Propiedades: Struct

La estructura puede contener propiedades, propiedades automáticas o métodos, igual que la clase.

Ejemplo:

INSTANCIAR UNA CLASE EN CSHARP

2020-03-28T12:06:00.000-07:00

Como Instanciar una Clase: Crear un objeto en la memoria

Una vez que tenemos una clase definida, lo único de lo que disponemos es de una especie de plantilla o molde a partir del cual podemos crear objetos en memoria.

Para crear esos objetos en Visual C# .NET lo podemos hacer de dos formas, pero como veremos siempre será mediante la instrucción new que es la encargada de crear el objeto en la memoria y asignar la dirección del mismo a la variable usada en la parte izquierda de la asignación.

Declarar primero la variable y después instanciarla
Lo primero que tenemos que hacer es declarar una variable del tipo que queremos instanciar, esto lo hacemos de la misma forma que con cualquier otro tipo de datos:

Celular objCelular;

Con esta línea de código lo que estamos indicando a C# es que tenemos intención de usar una variable llamada objCelular para acceder a una clase de tipo Celular. Esa variable, cuando llegue el momento de usarla, sabrá todo lo que hay que saber sobre una clase Celular, pero hasta que no tenga una "referencia" a un objeto de ese tipo no podremos usarla.

La asignación de una referencia a un objeto Celular la haremos usando la instrucción new seguida del nombre de la clase:

objCelular = new Celular();

A partir de este momento, la variable objCelular tiene acceso a un nuevo objeto del tipo Celular, por tanto podremos usarla para asignarle valores y usar cualquiera de los miembros que ese tipo de datos contenga:

objCelular.MarcaCelular = "MAXCEL";

objCelular.TomarLLamada("9999999999");

Declarar e instanciar en un solo paso

La otra forma de instanciar una clase es haciéndolo al mismo tiempo que la declaramos. En C# esto se hace como si uniéramos la declaración y la instanciación en una sola instrucción:

Celular objCelular = new Celular();

De esta forma se asignará a la variable objCelular una referencia a un nuevo objeto creado en la memoria, el cual será totalmente independiente del resto de objetos creados con esa misma clase.

El constructor: El punto de inicio de una clase
Cada vez que creamos un nuevo objeto en memoria estamos llamando al constructor de la clase. En Visual C# .NET el constructor es una especie de método que se llama de la misma forma que la clase.

En el constructor de una clase podemos incluir el código que creamos conveniente, pero realmente solamente deberíamos incluir el que realice algún tipo de inicialización, en caso de que no necesitemos realizar ningún tipo de inicialización, no es necesario definir el constructor, ya que el propio compilador lo hará por nosotros. Esto es así porque todas las clases deben implementar un constructor, por tanto si nosotros no lo definimos, lo hará el compilador de C#.

Si nuestra clase Celular tiene un campo para almacenar la fecha de creación del objeto podemos hacer algo como esto:

class Celular
{
private string marcaCelular;

public Celular() { }
public Celular(string MarcaCelular) { }
}

De esta forma podemos crear un objeto de la Clase Celular.

Celular objCelular = new Celular();

Código de Ejemplo Completo

CREAR UN CLASE EN CSHARP | C# NET

2020-03-27T10:42:00.000-07:00

Como Crear una clase

En Visual C#, todo el código que queramos escribir, lo tendremos que hacer en un archivo con la extensión .cs, dentro de ese archivo es donde escribiremos nuestro código, el cual, tal como dijimos anteriormente siempre estará incluido dentro de una clase, aunque un archivo de código de C# puede contener una o más clases, es decir, no está limitado a una clase por archivo.

En C# las clases se definen usando la palabra clave class seguida del nombre de la clase, el cuerpo de la clase estará encerrada entre un par de llaves, que por otra parte es la forma habitual de definir bloques de código en C#.

En el siguiente ejemplo definimos una clase llamada Celular que tiene dos campos públicos.

class Celular
{
    public string Marca;
    public int MemoriaRAM;
}

Una vez definida la clase podemos agregar los elementos (o miembros) que creamos conveniente.
En el ejemplo anterior, para simplificar, hemos agregado dos campos públicos, aunque también podríamos haber definido cualquiera de los miembros permitidos en las clases.

Los miembros de una clase

Una clase puede contener cualquiera de estos elementos (miembros):

Enumeraciones
Campos
Métodos (funciones o procedimientos)
Propiedades
Eventos

Las enumeraciones, como vimos en la lección anterior, podemos usarlas para definir valores constantes relacionados, por ejemplo para indicar los valores posibles de cualquier "característica" de la clase.
Los campos son variables usadas para mantener los datos que la clase manipulará.
Los métodos son las acciones que la clase puede realizar, normalmente esas acciones serán sobre los datos que contiene. Los métodos pueden devolver valores como resultado de la "acción" realizada o también pueden devolver un valor void, que significa que realmente no devuelve nada.
Las propiedades son las "características" de las clases y la forma de acceder "públicamente" a los datos que contiene. Por ejemplo, podemos considerar que el AlmacenamientoExterno y MedidaPantalla de un Celular son dos características del Celular.
Los eventos son mensajes que la clase puede enviar para informar que algo está ocurriendo en la clase.

Características de los métodos y propiedades

Accesibilidad, ámbito y miembros compartidos

Aunque estos temas los veremos en breve con más detalle, para poder comprender mejor las características de los miembros de una clase (o cualquier tipo que definamos), daremos un pequeño adelanto sobre estas características que podemos aplicar a los elementos que definamos.
Accesibilidad y ámbito son dos conceptos que están estrechamente relacionados. Aunque en la práctica tienen el mismo significado, ya que lo que representan es la "cobertura" o alcance que tienen los miembros de las clases e incluso de las mismas clases que definamos.
Si bien cada uno de ellos tienen su propia "semántica", tal como podemos ver a continuación:

Ámbito

Es el alcance que la definición de un miembro o tipo puede tener. Es decir, cómo podemos acceder a ese elemento y desde dónde podemos accederlo.
El ámbito de un elemento de código está restringido por el "sitio" en el que lo hemos declarado. Estos sitios pueden ser:

Ámbito de bloque: Disponible únicamente en el bloque de código en el que se ha declarado.
Ámbito de procedimiento: Disponible únicamente dentro del procedimiento, (función o propiedad), en el que se ha declarado.
Ámbito de módulo: Disponible en todo el código de la clase o la estructura donde se ha declarado.
Ámbito de espacio de nombres: Disponible en todo el código del espacio de nombres.

Accesibilidad

A los distintos elementos de nuestro código (ya sean clases o miembros de las clases) podemos darle diferentes tipos de accesibilidad. Estos tipos de "acceso" dependerán del ámbito que queramos que tengan, es decir, desde dónde podremos accederlos.
Los modificadores de accesibilidad son:

public: Acceso no restringido.
protected: Acceso limitado a la clase contenedora o a los tipos derivados de esta clase.
internal: Acceso limitado al proyecto actual.
protected internal: Acceso limitado al proyecto actual o a los tipos derivados de la clase contenedora.
private: Acceso limitado al tipo contenedor.

Por ejemplo, podemos declarar miembros privados a una clase, en ese caso, dichos miembros solamente los podremos acceder desde la propia clase, pero no desde fuera de ella.

Nota:
En C# cuando declaramos una variable sin indicar el modificador de accesibilidad, el ámbito será privado.

EJEMPLO DECLARAR MIEMBROS DE UNA CLASE

LAS CLASES: EL CORAZON DE .NET FRAMEWORK

2020-03-25T07:41:00.001-07:00

LAS CLASES .NET FRAMEWORK

Todo lo que podemos hacer en .NET Framework lo hacemos mediante clases. La librería de clases de .NET Framework es precisamente el corazón del propio .NET, en esa librería de clases está todo lo que podemos hacer dentro de este marco de programación; para prácticamente cualquier tarea que queramos realizar existen clases, y si no existen, las podemos definir nosotros mismos, bien ampliando la funcionalidad de alguna clase existente mediante la herencia, bien implementando algún tipo de funcionalidad previamente definida o simplemente creándolas desde cero.

La herencia: Característica principal de la Programación Orientada a Objetos

El concepto de Programación Orientada a Objetos (POO) es algo intrínsico al propio .NET Framework, por tanto es una característica que todos los lenguajes basados en este "marco de trabajo" tienen de forma predeterminada, entre ellos el Visual C#. De las características principales de la POO tenemos que destacar la herencia, que en breve podemos definir como una característica que nos permite ampliar la funcionalidad de una clase existente sin perder la que ya tuviera previamente. Gracias a la herencia, podemos crear una nueva clase que se derive de otra, esta nueva clase puede cambiar el comportamiento de la clase base y/o ampliarlo, de esta forma podemos adaptar la clase, llamémosla, original para adaptarla a nuestras necesidades.

El tipo de herencia que .NET Framework soporta es la herencia simple, es decir, solo podemos usar una clase como base de la nueva, si bien, como veremos más adelante, podemos agregar múltiple funcionalidad a nuestra nueva clase. Esta funcionalidad nos servirá para aprovechar la que ya tienen muchas de las clases existentes en .NET Framework, funcionalidad que solamente podremos aplicar si previamente hemos firmado un contrato que asegure a la clase de .NET que la nuestra está preparada para soportar esa funcionalidad, esto lo veremos dentro de poco con más detalle.

Encapsulación y Polimorfismo

La encapsulación y el polimorfismo son otras dos características de la programación orientada a objetos. La encapsulación nos permite abstraer la forma que tiene de actuar una clase sobre los datos que contiene o manipula, para poder lograrlo se exponen como parte de la clase los métodos y propiedades necesarios para que podamos manejar esos datos sin tener que preocuparnos cómo se realiza dicha manipulación.

El polimorfismo es una característica que nos permite realizar ciertas acciones o acceder a la información de los datos contenidos en una clase de forma semi-anónima, al menos en el sentido de que no tenemos porqué saber sobre que tipo de objeto realizamos la acción, ya que lo único que nos debe preocupar es que podemos hacerlo, por la sencilla razón de que estamos usando ciertos mecanismos que siguen unas normas que están adoptadas por la clase.

Object: La clase base de todas las clases de .NET

Todas las clases de .NET se derivan de la clase Object, es decir, lo indiquemos o no, cualquier clase que definamos tendrá el comportamiento heredado de esa clase. El uso de la clase Object como base del resto de las clases de .NET es la única excepción a la herencia simple soportada por .NET, ya que de forma implícita, todas las clases de .NET se derivan de la clase Object independientemente de que estén derivadas de cualquier otra.

Esta característica nos asegura que siempre podremos usar un objeto del tipo Object para acceder a cualquier clase de .NET, aunque no debemos abrumarnos todavía, ya que en el texto que sigue veremos con más detalle que significado tiene esta afirmación.

De los miembros que tiene la clase Object debemos resaltar el método ToString útil para convertir un tipo primitivo en una cadena. Este método está pensado para devolver una representación en formato cadena de un objeto. El valor que obtengamos al usar este método dependerá de cómo esté definido en cada clase y por defecto lo que devuelve es el nombre completo de la clase, si bien en la mayoría de los casos el valor que obtendremos al usar este método debería ser más intuitivo, por ejemplo los tipos de datos primitivos tienen definido este método para que devuelva el valor que contienen, de igual forma, nuestras clases también deberían devolver un valor adecuado al contenido almacenado.

MATRICES EN CSHARP | C# Arrays

2020-03-20T09:08:00.000-07:00

C# Matrices - Arrays

Una variable solo puede contener un valor literal, ejemplo: int x = 100; Si desea almacenar múltiples valores literales, será engorroso crear múltiples variables.

Para superar este problema, C# incluye la matriz (Array).

Un Array es la estructura de datos que almacena un número fijo de valores literales del mismo tipo de datos.

Un Array se declara de la misma manera que la variable, pero con corchetes []. Lo siguiente declara matrices de diferentes tipos.

Ejemplos de declaración de Matrices - Arrays

int[] numeros;  // almacena valores enteros
string[] nombres; // almacena valores tipo cadena
double[] salarios; // almacena valores tipo double
object[] objs; // almacena objetos
Estudiante[] estudiantes; // almacena objeto de tipo de clase Estudiante

El ejemplo anterior solo declara matrices. Para insertarle valores, debemos crear un objeto de una matriz. Lo siguiente crea una matriz del tipo int.

int[] nums = new int[5];

La matriz de números anterior puede almacenar hasta cinco enteros. 5 entre corchetes new int [5] especifica el tamaño de una matriz. Una matriz no puede almacenar más elementos que el tamaño especificado. Intentar agregar más elementos dará como resultado un error. La matriz nums todavía no almacena enteros. Una forma de agregar elementos en el momento de la declaración es la siguiente.

int[] nums = new int[5]{ 10, 15, 16, 8, 6 };

Arriba, agregamos cinco literales enteros separados por una coma en las llaves {}.

También podemos crear una matriz y agregar elementos sin especificar el tamaño, como se muestra a continuación.

int[] nums = new int[]{ 10, 15, 16, 8, 6 };
int[] nums = { 10, 15, 16, 8, 6 };

En el ejemplo anterior, no hemos especificado el tamaño de una matriz. El tamaño se deducirá de la cantidad de elementos que incluye en el momento de la declaración.

Una matriz almacena el número fijo de elementos. Por lo tanto, debe especificar el tamaño de una matriz o agregar elementos al momento de la declaración; de lo contrario, dará un error en tiempo de compilación. Lo siguiente dará un error en tiempo de compilación.

int[] nums = new int[]; // error: La declaracion de un Array debe tener una longuitud o inicializador de Array

Índice de matriz

La matriz almacena elementos secuencial-mente en la memoria, y es por eso que es más rápido que cualquier otro tipo de colección en C #. Cada elemento tiene un índice único que comienza con 0 y aumenta en 1 posteriormente. Un índice del primer elemento (predeterminado a 0) se denomina límite inferior, y un índice del último elemento se denomina límite superior de una matriz. La figura ilustra la matriz.

Acceso a elementos de un Array

Podemos agregar, insertar, actualizar y acceder a valores utilizando el índice, como se muestra a continuación.

//Ejemplo: Agregando valores unando el indice
int[] nums = new int[5];
nums[0] = 7;
nums[1] = 42;
nums[2] = 12;
nums[3] = 1;
nums[4] = 22;
//nums[5] = 100;  // Lanzara un Error, Indice fuera de Rango

Del mismo modo, podemos recuperar valores en un índice particular, como se muestra a continuación:

//Ejemplo: Accesando a elementos del Array
int[] nums = new int[5]{ 7, 42, 12, 1, 22 };
nums[0];  //obtenemos 7
nums[1];  //obtenemos 42
nums[2];  //obtenemos 12
nums[3];  //obtenemos 1
nums[4];  //obtenemos 22
//nums[5];  //Lanzara un Error, Indice fuera de Rango

ENUMERACIONES EN CSHARP | enum

2020-03-12T08:15:00.002-07:00

Enumeraciones en C# Sharp | enum

En C #, enum es un tipo de datos de tipo de valor. La enumeración se utiliza para declarar una lista de constantes enteras con nombre. Se puede definir usando la palabra clave enum directamente dentro de un espacio de nombres, clase o estructura. La enumeración se usa para dar un nombre a cada constante para que el entero constante se pueda referir usando su nombre.

Por defecto, el primer miembro de una enumeración tiene el valor 0 y el valor de cada miembro de enumeración sucesivo aumenta en 1. Por ejemplo, en la siguiente enumeración, el lunes es 0, el martes es 1, el miércoles es 2 y así sucesivamente.

Es necesaria una conversión explícita para convertir del tipo enum a un tipo integral. Por ejemplo, para obtener el valor int de una enumeración:

Un cambio en el valor del primer miembro enum asignará automáticamente valores incrementales a los otros miembros secuencialmente. Por ejemplo, cambiando el valor de lunes a 10, asignará 11 a martes, 12 a miércoles, y así sucesivamente:

La enumeración puede incluir constantes con nombre del tipo de datos numéricos, p. byte, sbyte, corto, ushort, int, uint, long o ulong.

Declaración de variables tipo enum

NOTA: enum no se puede usar con el tipo de cadena.

VARIABLES Y CONSTANTES EN C# SHARP .NET

2020-03-10T17:57:00.000-07:00

Como definir Variables y Constantes en C#

VARIABLES

Una variable es un elemento de datos con nombre cuyo valor puede cambiar durante el curso de la ejecución de un programa. Un nombre de variable debe seguir el convenio de denominación de un identificador (carácter alfabético o número y el signo de subrayado). Cuando se define más de una variable en una sola declaración, el nombre debe ir separado por comas. Cada declaración de variable debe finalizar con un signo de punto y coma. Los nombres de variables no pueden coincidir con una palabra reservada.

CONSTANTES

Una constante es un elemento de datos con nombre con un valor predefinido. No se puede cambiar el valor asignado a una constante predefinida. Las constantes predefinidas son:

NULL

Una referencia vacía. Parecido a un puntero vacío. Tenga en cuenta que no es lo mismo que una cadena de caracteres nula "".

TRUE

Equivalente al número 1.

FALSE

Equivalente al número 0.

Una constante es un elemento de datos con nombre con un valor predefinido, mientras que una variable es un elemento de datos con nombre cuyo valor puede cambiar durante el curso de la ejecución de un programa. Las variables pueden ser globales o locales.

Todos los tipos de datos se representan como uno de estos tres tipos de datos básicos:

Int: Tipo de datos entero ( + - seguido de 1 o más dígitos entre 0 y 9).
Real: Coma flotante (+- seguido de cero o más dígitos 0–9). Coma decimal seguida de 1 o más dígitos 0-9. Tenga en cuenta que todos los números se almacenan internamente como Float.
String: Cualquier cadena de caracteres Unicode válida especificada entre comillas.

EJEMPLO:

Los Sufijos a utilizar en los valores:

//SUFIJOS
//Tipo de datos Sufijo de C#
// short N.A.
// int N.A.
// long L
// float F
// double D
// decimal M
// ushort N.A.
// uint UI
// ulong UL
// string N.A.

Ejemplos de Declaración de Variables y Constantes

class Program
    {
        static void Main(string[] args)
        {
            //VARIABLES
            char vocal = 'a';
            string vocales = "aeiou";
            byte edad = 20;
            int digito = 5;
            double cotizacionPlata = 20.02554545;
            decimal pequenaFraccion = 0.000000000000000000000000112123515M;
            long reservas = 9223372036854775807;
            bool esProgramador = false;

            //Aquí cambiamos los valores de estas 2 Variables
            vocal = 'e';
            vocales = "uoiea";

            //CONSTANTES
            const float PI = 3.1416F;
            const int INVENTARIO_MINIMO_ACEPTABLE = 50;
            const int INVENTARIO_MAXIMO_ACEPTABLE = 200;

            Console.WriteLine("el valor de vocales es {0}", vocales);
            Console.ReadKey();
        }
    }

TIPOS DE DATOS EN CSHARP | C# .NET

2020-03-10T06:08:00.001-07:00

Tipos de Datos en CSharp .NET

El fundamento de todo lenguaje de programación son precisamente los tipos de datos y sus precisiones del almacenaje. Pero en esta ocasión quiero profundizar un poco mas. En CSharp los tipos de datos son mas que eso, son también una compleja estructura de valores y funciones que permiten interactuar de forma dinámica entre todos los tipos de datos .NET

Para entender un poco mejor de lo que estamos hablando, veamos el siguiente vídeo.

Esta tabla es una referencia de Tipos de datos de CSharp .NET

Tipo C#	Intervalo	Tamaño / Precisión	Tipo .NET	Default
sbyte	De -128 a 127	Entero de 8 bits con signo	System.SByte	0
byte	De 0 a 255	Entero de 8 bits sin signo	System.Byte	0
short	De -32 768 a 32 767	Entero de 16 bits con signo	System.Int16	0
ushort	De 0 a 65.535	Entero de 16 bits sin signo	System.UInt16	0
int	De -2.147.483.648 a 2.147.483.647	Entero de 32 bits con signo	System.Int32	0
uint	De 0 a 4.294.967.295	Entero de 32 bits sin signo	System.UInt32	0
long	De -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807	Entero de 64 bits con signo	System.Int64	0
ulong	De 0 a 18.446.744.073.709.551.615	Entero de 64 bits sin signo	System.UInt64	0
float	De ±1,5 x 10^-45 a ±3,4 x 10³⁸	7 dígitos	System.Single	0.0f
double	De ±5,0 × 10⁻³²⁴ a ±1,7 × 10³⁰⁸	15-16 dígitos	System.Double	0.0d
decimal	De ±1,0 x 10^-28 to ±7,9228 x 10²⁸	28-29 dígitos significativos	System.Decimal	0m
char	U+0000 a U+FFFF	Carácter Unicode de 16 bits	System.Char	\x0000
bool	Booleano	true, false	System.Boolean	false

Notemos lo siguiente:

Los tipos de datos en C# (primera columna) son simplemente Alias lenguaje C#, En realidad los datos que estamos usando son los de Tipo .NET y lo debemos tener en cuenta.

Tenemos otros tipos de datos en C# .NET

Tipo C#

Descripción

Tipo .NET

`object`

Es la clase base para todos los demás tipos, incluidos los tipos integrados simples.

`System.Object`

`string`

Una secuencia de caracteres Unicode.

`System.String`

`dynamic`

Es un tipo diseñado para ser usado con assemblies escritos en lenguajes dinámicos

No corresponde a un tipo .NET

Comentarios

El alias y su tipo .NET son intercambiables. Por ejemplo, puede declarar una variable de tipo entero de dos formas:

int varInt1 = 1; // Usando un alias

System.Int32 varInt2 = 2; // Usando un tipo .NET Framework

Programa Hola Mundo en CSharp | C#.NET

2020-03-06T17:07:00.001-08:00

En este programa se muestra la impresion por pantalla de la frase "Hola Mundo" en lenguaje C-Sharp. Se utiliza la Clase Console para imprimir y leer datos.

Si no tienes Visual Studio para seguir estos videos te dejo este enlace para la descarga e Instalacion, es muy sencillo.

Siga estos Pasos:

1- Descargar Visual Studio Community en este enlace: https://visualstudio.microsoft.com/es/vs/
2- Instalar Visual Studio: Ver Video https://youtu.be/LHSycwITBnI

Caracteristicas del Lenguaje CSharp

2020-03-06T09:25:00.000-08:00

Características del Lenguaje CSharp | C#

Contenido

Lección 1: El sistema de tipos
Tipos primitivos
Variables y constantes
Enumeraciones
Arrays (matrices)

Lección 2: Clases y estructuras
Clases
Definir una clase
Instanciar una clase
Estructuras
Accesibilidad
Propiedades
Interfaces

Lección 3: Manejo de excepciones
Manejo de excepciones

Lección 4: Eventos y delegados
Eventos
Delegados

La biblioteca de clases de .NET

2020-03-05T15:12:00.000-08:00

La biblioteca de clases de .NET

Todo lo que se ha estado comentando hasta ahora en el curso constituye la base de la plataforma .NET. Si bien es muy interesante y fundamental, por sí mismo no nos serviría de mucho para crear programas si debiésemos crear toda la funcionalidad desde cero.

Obviamente esto no es así, y la plataforma .NET nos ofrece infinidad de funcionalidades "de fábrica" que se utilizan como punto de partida para crear las aplicaciones. Existen funcionalidades básicas (por ejemplo todo lo relacionado con la E/S de datos o la seguridad) y funcionalidades avanzadas en las que se fundamentan categorías enteras de aplicaciones (acceso a datos, creación de aplicaciones Web...).

Toda esta funcionalidad está implementada en forma de bibliotecas de funciones que físicamente se encuentran en diversas DLL (bibliotecas de enlazado dinámico). A su conjunto se le denomina Base Classes Library (Biblioteca de clases base o BCL) y forman parte integral de la plataforma .NET, es decir, no se trata de añadidos que se deban obtener o adquirir aparte.

La siguiente figura ilustra a vista de pájaro la arquitectura conceptual de la plataforma .NET. En ella se pueden observar los elementos que se han mencionado en apartados anteriores (lenguajes, CLR, CLS...) y en qué lugar de se ubican las bibliotecas de clases base:

Distintos elementos de la plataforma .NET y cómo se relacionan entre sí.

Resulta muy útil para comprender lo explicado hasta ahora. No se preocupe si hay elementos que no conoce, más adelante los estudiaremos todos.

Todo lo que se encuentra en la BCL forma parte de la plataforma .NET. De hecho existe tal cantidad de funcionalidad integrada dentro de estas bibliotecas (hay decenas de miles de clases) que el mayor esfuerzo que todo programador que se inicia en .NET debe hacer es el aprendizaje de las más importantes. De todos modos Visual Studio ofrece mucha ayuda contextual (documentación, Intellisense...) y una vez que se aprenden los rudimentos resulta fácil ir avanzando en el conocimiento de la BCL a medida que lo vamos necesitando.

Los espacios de nombres

Dada la ingente cantidad de clases que existen debe existir algún modo de organizarlas de un modo coherente. Además hay que tener en cuenta que podemos adquirir más funcionalidades (que se traducen en clases) a otros fabricantes, por no mencionar que crearemos continuamente nuevas clases propias.

Para solucionar este problema existen en todos los lenguajes .NET los espacios de nombres o namespaces.

Un espacio de nombres no es más que un identificador que permite organizar de modo estanco las clases que estén contenidas en él así como otros espacios de nombres.

Así, por ejemplo, todo lo que tiene que ver con el manejo de estructuras de datos XML en la plataforma .NET se encuentra bajo el espacio de nombres System.Xml. La funcionalidad fundamental para crear aplicaciones Web está en el espacio de nombres System.Web. Éste a su vez contiene otros espacios de nombres más especializados como System.Web.Caching para la persistencia temporal de datos, System.Web.UI.WebControls, que contiene toda la funcionalidad de controles Web para interfaz de usuario, etc...

Introducción a la plataforma .NET

2020-03-05T14:59:00.000-08:00

Introducción a la plataforma .NET

Simplificando mucho las cosas para poder dar una definición corta y comprensible, se podría decir que la plataforma .NET es un amplio conjunto de bibliotecas de desarrollo que pueden ser utilizadas por otras aplicaciones para acelerar enormemente el desarrollo y obtener de manera automática características avanzadas de seguridad, rendimiento, etc...

En realidad .NET es mucho más que eso ya que ofrece un entorno gestionado de ejecución de aplicaciones, nuevos lenguajes de programación y compiladores, y permite el desarrollo de todo tipo de funcionalidades: desde programas de consola o servicios Windows hasta aplicaciones para dispositivos móviles, pasando por desarrollos de escritorio o para Internet. Son estos últimos de los que nos ocuparemos en este curso. Pero antes conviene conocer los fundamentos en los que se basa cualquier aplicación creada con .NET, incluyendo las que nos interesan.

El entorno de ejecución CLR

.NET ofrece un entorno de ejecución para sus aplicaciones conocido como Common Language Runtime o CLR. La CLR es la implementación de Microsoft de un estándar llamado Common Language Infrastructure o CLI. Éste fue creado y promovido por la propia Microsoft pero desde hace años es un estándar reconocido mundialmente por el ECMA.

El CLR/CLI esencialmente define un entorno de ejecución virtual independiente en el que trabajan las aplicaciones escritas con cualquier lenguaje .NET. Este entorno virtual se ocupa de multitud de cosas importantes para una aplicación: desde la gestión de la memoria y la vida de los objetos hasta la seguridad y la gestión de subprocesos.

Todos estos servicios unidos a su independencia respecto a arquitecturas computacionales convierten la CLR en una herramienta extraordinariamente útil puesto que, en teoría, cualquier aplicación escrita para funcionar según la CLI puede ejecutarse en cualquier tipo de arquitectura de hardware. Por ejemplo Microsoft dispone de implementación de .NET para Windows de 32 bits, Windows de 64 bits e incluso para Windows Mobile, cuyo hardware no tiene nada que ver con la arquitectura de un ordenador común.

Bienvenida al Blog CSharp desde Cero

2020-03-05T13:30:00.000-08:00

Hola Estimados Alumnos, me siento muy emocionado de poder nuevamente compartir con ustedes conocimiento que puede ser útil para todos ustedes.

Inicio este nuevo Proyecto de este nuevo Blog CSharp desde Cero que será dedicado al aprendizaje del Lenguaje Multiplataforma C#.NET

Agradezco a todos los que me han seguido desde hace ya un tiempo, ahora les invito a comenzar una etapa nueva de conocimiento y alcanzar sus Metas Profesionales propuestas.

Mil Gracias

Arturo Chapa

Tipo C#	Descripción	Tipo .NET
`object`	Es la clase base para todos los demás tipos, incluidos los tipos integrados simples.	`System.Object`
`string`	Una secuencia de caracteres Unicode.	`System.String`
`dynamic`	Es un tipo diseñado para ser usado con assemblies escritos en lenguajes dinámicos	No corresponde a un tipo .NET

Curso C Sharp desde Cero para Principiantes y Avanzados | C# .NET

DELEGADOS EN C# .NET | PUNTEROS A METODOS

Delegados

Definición "formal" de delegado

Utilizar un delegado para acceder a un método

EJEMPLO DEL VIDEO

CREAR EVENTOS EN CSHARP | C# .NET

CREAR EVENTOS EN CSHARP | C# .NET

Eventos

Interceptar los eventos de los controles de un formulario

Asociar un evento con un control

Asociar varios eventos a un mismo procedimiento

Asociarlos usando el diseñador de Windows Forms

Asociarlos usando código

EVENTOS Y DELEGADOS EN CSHARP | C# .NET

EVENTOS Y DELEGADOS EN CSHARP | C# .NET

TRY CATCH FINALLY EN CSHARP | C# .NET

Manejo de Excepciones en C# .NET

Manejo de excepciones estructuradas

Bloque try

Bloque catch

Varias capturas de errores en un mismo bloque try/catch

Bloque finally

Nota: Hay que tener en cuenta de que incluso si usamos return dentro de un bloque de control de errores, se ejecutará el código indicado en el bloque finally.

Captura de errores no controlados

*** EJEMPLOS DEL VIDEO ***

EJEMPLO 1

EJEMPLO 2

EJEMPLO 3

INTERFACES EN CSHARP | C# .NET

Interfaces en CSharp

EJEMPLOS DEL VÍDEO:

CREAR PROPIEDADES EN CSHARP | C# .NET

Propiedades

EJEMPLOS DEL VÍDEO

ACCESIBILIDAD Y AMBITOS EN CSHARP .NET

Accesibilidad y Ámbitos en C# .NET

Ámbito de bloque

Ámbito de procedimiento

Ámbito de módulo

Ámbito de espacio de nombres

Accesibilidad

Accesibilidad de las variables en los procedimientos

Las accesibilidades predeterminadas

Anidación de tipos

Los tipos anidables

El nombre completo de un tipo

Importación de espacios de nombres

Alias de espacios de nombres

ESTRUCTURAS EN CSHARP | Struct C# .NET

Ejemplos de Struct C#

Constructores: Struct

Métodos y Propiedades: Struct

INSTANCIAR UNA CLASE EN CSHARP

Como Instanciar una Clase: Crear un objeto en la memoria

Declarar e instanciar en un solo paso

CREAR UN CLASE EN CSHARP | C# NET

Como Crear una clase

Los miembros de una clase

Características de los métodos y propiedades

Accesibilidad, ámbito y miembros compartidos

Ámbito

Accesibilidad

EJEMPLO DECLARAR MIEMBROS DE UNA CLASE

LAS CLASES: EL CORAZON DE .NET FRAMEWORK

LAS CLASES .NET FRAMEWORK

La herencia: Característica principal de la Programación Orientada a Objetos

Encapsulación y Polimorfismo

Object: La clase base de todas las clases de .NET

MATRICES EN CSHARP | C# Arrays

C# Matrices - Arrays

Un Array es la estructura de datos que almacena un número fijo de valores literales del mismo tipo de datos.

Ejemplos de declaración de Matrices - Arrays

Índice de matriz

Acceso a elementos de un Array

ENUMERACIONES EN CSHARP | enum

Enumeraciones en C# Sharp | enum

VARIABLES Y CONSTANTES EN C# SHARP .NET

Como definir Variables y Constantes en C#

VARIABLES

Nota:
Hay que tener en cuenta de que incluso si usamos return dentro de un bloque de control de errores, se ejecutará el código indicado en el bloque finally.

* EJEMPLOS DEL VIDEO *