ESTRUCTURAS EN CSHARP | Struct C# .NET

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

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

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

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

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

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

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

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 1038	7 dígitos	System.Single	0.0f
double	De ±5,0 × 10−324 a ±1,7 × 10308	15-16 dígitos	System.Double	0.0d
decimal	De ±1,0 x 10-28 to ±7,9228 x 1028	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