Explorando C #

Que es una clase

Una clase es una estructura de datos que utilizaremos para definir nuestros propios tipos que extenderán los primitivos que posee el lenguaje.

La mayoría de las veces, las clases se utilizan por medio de sus instancias, las cuales se denominan objetos. Los objetos del mismo tipo (diferentes instancias de la misma clase) compartirán una estructura común, pero podrán poseer valores distintos en sus variables miembro.

Podríamos trazar una analogía entre una clase y sus objetos con lo que es un molde y los elementos creados a partir de él. Una clase define una serie de variables y comportamientos por medio de los cuales podremos crear objetos que poseerán dichas variables y comportamientos.

La cantidad de objetos que podremos crear a partir de una clase sólo estará limitada por la cantidad de memoria que posea el sistema.

Cómo declarar una clase

En C# las clases se declaran dentro de archivos de código fuente con extensión CS. Se utiliza esta teminación por convención, y se trata de archivos que contienen texto y que pueden ser abiertos por cualquier editor de textos, como por ejemplo, Bloc de Notas.

class
{
//cuerpo de la clase
}

En primer término, debemos escribir la palabra reservada class, y luego, un identificador, un identificador válido que cumpla con las reglas que habíamos mencionado previamente. Algunos identificadores válidos podrían ser:

Clase1
Esta_es_una_clase
_mi_clase

Vale recordar que el hecho de que el nombre sea aceptado por el compilador no significa que éste sea un "buen nombre". Mejor sería que el identificador de la clase fuera seleccionado en función de un nombre que describiera mejor lo qie representa dentro del programa (por ejemplo, Cliente, Producto, Cuadrado, etc.).

Modificadores de acceso

Dentro de lo que llamamos "cuerpo" de la clase se colocarán la declaración y la definición de todos sus todos sus miembros, que serán datos y métodos.

Las variables miembro de una clase se declaran como variables convencionales (como vimos en el capítulo anterior), pero pueden poseer algunos modificadores especiales. Un modificador muy utilizado es el de acceso, que regula la visibilidad que posee la variable o el método desde otros objetos.

Siempre es posible acceder a las variables de una clase desde los métodos declarados en ella, más allá de su modificador de acceso. Para otros métodos de otras clases, éstos impondrán limitaciones, que son:

* public: si la variable es declarada como pública, entonces es posible acceder a su contenido desde cualquier objeto de cualquier tipo.
* protected: si la variable es declarada como protegida, entonces no es posible acceder a su contenido desde objetos externos, pero sí es posible hacerlo desde métodos de la clase y las clases derivadas.
* private: si la variable es declarada como privada, entonces sólo es posible acceder a su contenido desde métodos de la clase, pero no desde métodos de clases derivadas. Por default, si no se especifica otra cosa, una variable es privada.
* internal: si la variable es declarada como interna, entonces sólo es posible acceder a su contenido desde métodos de clases que se encuentren dentro del mismo assembly.
* protected internal: si la variable es declarada como protegida interna, entonces es posible acceder a su contenido desde métodos de clases que se encuentren ubicadas dentro del mismo assembly, métodos que se encuentren situados en la misma clase y en clases derivadas.

Veamos cómo declarar algunas variables:

class Foo
{
int a; //Variable del tipo entero llamada "a"
}

Ahora la clase Foo posee como uno de sus miembros a una variable del tipo número entero. Esta variable será privada, pues no se ha especificado otra cosa. Por defecto, la visibilidad es privada.

Veamos cómo incluir los modificadores de acceso:

class Foo
{
public int a;
protected int b;
private int c;
}

Veamos: ahora nuestra variable a fue declarada del tipo pública, la variable b como protegida, y la c como privada (aunque especificar private no es necesario, en ocasiones se realiza para remarcar su condición).

Instanciación

Una vez que hemos definido nuestra clase, para poder utilizarla debemos crear una instancia debemos crear una instancia de ella (aunque es posible acceder a variables y métodos estáticos sin la necesidad de crear objetos de la clase). La declaración de un objeto es muy similar a la de cualquier otra variable. Recordemos que una clase es, al fin y al cabo, la definición de un nuevo tipo. Pues bien, un objeto es una variable que lleva por tipo una clase.

Suponiendo que ya hemos definido la Foo, ahora podríamos crear un objeto de ella del siguiente modo:

Foo miObjeto; //Declaración del objeto

¡Pero esto no es suficiente! Si bien ya declaramos que miObjeto será una variable de tipo Foo, los objetos requieren ser definidos de manera explícita por medio del operador new.

miObjeto = new Foo(); //Definición del objeto

Ahora sí, podremos acceder a todos los elementos del objeto. También podríamos haber declarado y definido el objeto en la misma línea:

Foo miObjeto = new Foo();

Pero ¿qué sucedería si declaramos el objeto miObjeto pero no hiciéramos uso del operador new? El objeto poseería el valor no definido asociado a él y cualquier intento de acceso a sus elementos provocaría un error de compilación, ya que el compilador advertiría esta situación.

Veamos, ahora, cómo instanciar un par de objetos y acceder a variables de éstos. Supongamos que nuestra clase Foo posee una variable a y otra b, ambas enteras.

Foo obj1 = new Foo();
Foo obj2 = new Foo();
obj1.a = 10;
obj2.a = 20;
Console.WriteLine("Valor de la variable a del objeto obj1: {0}", obj1.a);
Console.WriteLine("Valor de la variable a del objeto obj2: {0}", obj2.a);

Tanto obj1 como obj2 son instancias de la clase Foo; sin embargo, ambos objetos son independientes entre sí. Poseen la misma estructura, pero el valor dentro de sus variables puede ser totalmente diferente.

A continuación, analicemos de qué manera hemos realizado la asignación de valores a las variables de los objetos.

No podríamos haber colocado sólo el nombre de la variable, pues el compilador no podría haber determinado a qué objeto nos estabamos refiriendo. Entonces, la sintaxis correcta es colocar el nombre del objeto, el operador de selección (el punto), la variable, el operador de asignación y, finalmente, la expresión.

Constantes de una clase

Así como hablamos de constantes locales que se pueden declarar en un trozo de código, también es posible declarar constantes en el cuerpo de una clase. Las constantes pueden poseer los mismos modificadores de acceso que las variables.

class Foo
{
public const int a = 0;
}

Ahora a ya no es variable, sino constante, para todos los objetos del tipo Foo.

Nótese que hemos inicializado la constante en la misma línea en que la declaramos. Esto es algo obligatorio en este tipo de dato.

Pero además tiene una característica adicional: puede ser accedida o consultada sin requerir instanciación alguna, es decir, sin la necesidad de crear un objeto de Foo. ¿Por qué? porque no tiene sentido almacenar en objetos valores que serán iguales para todos ellos sin excepción.

Veamos, entonces, cómo acceder a una constante:
int b = Foo.a;

Como podemos apreciar en la línea de código anterior, creamos una variable temporal b y le asignamos el valor de la constante de la clase Foo. Nótese que no creamos un objeto de Foo, sino que utilizamos directamente el identificador de la clase seguido del operador selección y la constante.

Variables estáticas

Las variables estáticas, al igual que las constantes, pueden ser accedidas sin la necesidad de instanciar un objeto. Sin embargo, su valor puede ser modificado como cualquier otra variable. Podríamos pensar en ellas como variables de clase, siendo las variable tradicionales variables de objeto.

Este tipo de variables, al igual que las constantes o las variables convencionales, pueden poseer los mismos modificadores de acceso (public, private, protected, etc.).

Para declarar una variable como estática, bastará con agregarle el modificador static como prefijo al tipo de dato.

class Foo
{
int a = 1;
const int b = 1;
static int c = 1;
}

En el listado de código anterior, hemos declarado:

* La variable a como un número entero. Nótese que hemos inicializado dicha variable en 1 en la misma línea que su declaración.
* La variable b como una constante entera.
* Y, finalmente, a c como una variable estática entera. También la hemos inicializamos a un valor conocido, aunque esto no es obligatorio.

Veamos cómo hacer uso de este nuevo tipo de variables:

Foo.c = 30; //Accedo a la variable estático
Foo obj1 = new Foo(); //Creo un objeto
obj1.a = 10; //Accedo a su variable a
//Muestro el valor de c
Console.WiteLine("El valor de c es: {0}", Foo.c);
//Muestro el valor de a
Console.WriteLine("El valor de obj1.a es: {0}", obj1.a);

/////Inicializadores////
Cuando una variable se inicializa en la misma línea que su declaración dentro del cuerpo de la clase, se dice que posee un inicializador. Como vimos anteriormente, las constantes de una clase se deben poseer un inicializador.
///////////////////////////////////////////////////////////////////////////////

Los métodos

Las clases sólo con variables y constantes no resultan demasiado interesantes. También es posible declarar funciones dentro de una clase. Estas funciones (más conocidos como métodos) contienen el código que será ejecutado por nuestro programa cuando éstas sean invocadas.
Una función miembro o método posee:
* Un tipo de dato: es el devuelto por la función cuando ésta finaliza.
* Un identificador: es el nombre por medio del cual referenciarnos al método dentro de nuestro programa; lo utilizaremos para invocarlo.
* Parámetros: es una lista de variables que recibe el método. Esta lista puede estar vacía o poseer tantos elementos como queramos.

Para invocar un método en un programa, siendo éste un método convencional de un objeto, deberemos anteponer su nombre y operador de selección de miembros (el punto); luego se deberá colocar entre paréntesis todos los parámetros que requiera la función (si la función no recibe parámetros, simplemente se abren y se cierran los paréntesis). Tal y como hicimos en el ejemplo anterior de la función Main.

Métodos estáticos

Así como las variables estáticas pueden ser consideradas como variables de clase, existen métodos estáticos que pueden ser considerados como métodos de clase. Estos métodos deben poseer como prefijo al tipo de dato de retorno la palabra reservada static. Claro éstos tendrán algunas limitaciones: no podrán acceder a variables de objeto (es decir, no estáticas) o métodos de objetos (métodos convencionales no estáticos).

El modo de invocar un método estático es por medio del identificador de la clase en lugar del identificador del objeto (así como sucede con las variables estáticas).

Muchas clases de la librería BCL definen métodos estáticos. Ejemplo de esto es el método estático WriteLine de la clase Console.

Como se pasa un objeto a otro objeto:
http://stackoverflow.com/questions/12997635/object-passed-as-parameter-to-another-class-by-value-or-reference

Retornar valores

Hemos mencionado que los métodos pueden retornar valores o no. Si no devuelven ningún valor, simplemente se especifica que el tipo de dato de retorno sea void.

Explorando C #

miércoles, 5 de marzo de 2014

Validaciones (Regex)

Best Practices for Regular Expressions in the .NET Framework

How to: Verify that Strings Are in Valid Email Format

Obtener todos los puertos COM automáticamente del PC

sábado, 1 de marzo de 2014

Clases y Objetos

jueves, 23 de mayo de 2013

Consejos General de Compilación y Pruebas

Intaladores & Ruta Instalación Aplicación MSI

miércoles, 22 de mayo de 2013

Correr Aplicación como Administrador

jueves, 2 de mayo de 2013

Enumeraciones

Archivo del blog

Links de mucho interes!!