Apuntes .NET (C#) - Chapter 4 - Clases y Estructuras I

En C# la diferencia entre clases y estructuras es que las clases se usan para declarar un tipo por referencia, mientras que las estructuras uno por valor, mientras que en otros lenguajes hay mas diferencia de una cosa a otra. Por norma general, las estructuras son utilizadas para almacenar no muchos datos. Aunque es mas una pauta que una norma (Go Pratchett Go!! :D).

(No me convenze a mi eso de que son iguales.... supongo yo que la diferencia habra de ser mas radical que eso y en que unas llevan punto y coma y otras no, no?.... ya me enterare jejejeje)

Esta es la manera de definir una estructura en C#, Se escriben donde se escribiria una clase... es decir dentro del espacio de nombres (si tenemos).

struct nombre_estructura {
//Esto es un constructor
public nombre_estructura(int a,string b, double c) {
this.dato1=a;
this.dato2=b;
this.dato3=c;
}
//fin del constructor
 public int dato1;
 public string dato2;
 public double dato3;
};

Los constructores se aplican tanto en clases como en estructuras... es un metodo especial, llamado igual que la clase/estructura, de esta manera cuando instanciemos un nuevo tipo, este ejecutara el constructor. Si el constructor tiene parametros y es una estructura, como en este caso, podremos NO indicarlos, mientras que si fuera una clase, estariamos obligados a ello.

nombre_estructura aux; //Funciona
nombre_estructura aux=new nombre_estructura(); //Funciona
nombre_estructura aux=new nombre_estructura(2,"uuu",1.0) //Funciona

No se si ya he echo mencion a "public", esta palabrita consigue que podamos tratar con el dato cuando manejamos alguna estructurao clase. Si no lo tuvieramos, C# no nos permitiria acceder a el. Es la contrapartida de "private" de C++.

En .NET, las propiedades (datos) en clases y estructuras, asi como sus metodos, hemos de declararlos "public" ya que son "private" por defecto ¿capicci?

Asi, si fuesemos programadores intentando matar un dragon, por poner un ejemplo eh... empezariamos construyendo el objeto "dragon"

public class dragon {
 int x,y; //posiciones absolutas del bixo
 int fuerza; //fuerza transformada en numero... si no ke, esperas ake te pegue?
 int resistencia; //Ahi ahi... como las magic
 int largo_llamarada; //demosle un arma al bixo...
 int ancho_llamarada;
 int direccion_llamarada; //dejemoslo en 4 suponiendo ke el mapa sea una matriz  simple...
 string nombre; //por si acaso nos preguntan
}

Los metodos de clase, son funciones que incorporamos DENTRO de la clase, para manejar los datos, tambien llamados "funciones miembro". En la programacion , ya sea orientada a objetos o no, es importante la encapsulacion por motivos ya mentados, asi que se deberia impedir el acceso a los dato de la clase, como ya estan declarados "por defecto" como private, hacemos public los metodos, asi manejamos dichos datos, sin peligro a que el usuario los trastee (aparte de conseguir que no pase nada si se mejora la clase y esta mantiene sus metodos)

El dragon, quedaria asi....

public class dragon {
 int x,y; //posiciones absolutas del bixo
 int fuerza; //fuerza transformada en numero... si no ke, esperas ake te pegue?
 int resistencia; //Ahi ahi... como las magic
 int largo_llamarada; //demosle un arma al bixo...
 int ancho_llamarada;
 int direccion_llamarada; //dejemoslo en 4 suponiendo ke el mapa sea una matriz simple...
 string nombre; //por si acaso nos preguntan

 public void Set_X(int val) { this.x=val; } //funciones get/para cada una de las  variables....
 public int Get_X() { return this.x; }

//Imaginaros que he escrito el resto... xD

}

Esto, por supuesto, puede mejorarse, puedes crear rapidamente los metodos asi..

public int X {
 get {
   return this.x;
 }

 set {
   this.x=value;
 }
}

A esta chorradilla (denominemosla "get/set sentences" por decir algo) le veo la pega que no me deja insertarle algun otro metodo propio.... pero bueno, igual si es posible y sencillamente no se como ^^... pero es util en cuanto a organizar el codigo, y a crear rapidamente funciones get/set.

El constructor arriba mencionado tambien es aplicable a las clases, solo que si esta lo incorpora, obliga a usarlo, no permite obviarlo. Es recomendable incluir siempre un constructor en las clases que creemos, de todas maneras el compilador creara uno basico si no se incluye, asi que por la fuerza acabara haciendolo igualmente ^^.

public class dragon {
 int x,y; //posiciones absolutas del bixo
 int fuerza; //fuerza transformada en numero... si no ke, esperas ake te pegue?
 int resistencia; //Ahi ahi... como las magic
 int largo_llamarada; //demosle un arma al bixo...
 int ancho_llamarada;
 int direccion_llamarada; //dejemoslo en 4 suponiendo ke el mapa sea una matriz  simple...
 string nombre; //por si acaso nos preguntan

//Constructor
 public dragon() {
    this.x=0; this.y=0;
    nombre="EskamaRoja";
  //......... y seteamos todas las variables asi
 }
}

En .NET no existen destructores en si.... ya que la gestion de memoria lo lleva el framework y a nosotros no nos deja meter mucha mano... nos deja usar en cambio, finalizadores... que viene a ser algo parecido, y que casi que nos sirve para lo mismo... asi que estamos contentos. Un finalizador se indica con el simbolo ~ antes del nombre del metodo de finalizacion (se escribe como el constructor, pero con el simbolito coñe), y en ese metodo deberiamos efectuar las tareas de limpieza necesarias.

El Garbage Collecter gestiona los recursos de memoria, pero no es capaz de trabajar con otro tipo de recursos como manipuladores de bases de datos, graficos, etc. Asi que las clases que tengan algun tipo de datos que el Garbage Collecter no pueda manejar, sera la que tenga que llevar un destructor implementado.

Es recomendable crear a su vez un metodo que haga lo mismo que el destructor, pero que pueda ser llamada por el usuario, esto vuelve a ser mas una pauta que una norma.

Los metodos de clase, siguen siendo funciones, y como tal admiten parametros de entrada tipicos, y sobrecarga de funciones, que consiste basicamente en crear funciones con el mismo nombre, pero distintos parametros. Asi este ejemplo seria valido. Lo explicaremos mejor en otro post

public class miclase {
 int x;
 public void SetX() { this.x=0; }
 public void SetX(int a) { this.x=a; }
 public void SetX(int a,int b) { this.x=a*b; }
}

La sobrecarga de metodos tambien se usa para crear varios constructores, asi poder definir un objeto de varias maneras.

Para modificar variables enviadas a una funcion por sus parametros (lo que en C/C++ conseguiamos usando una referencia), en C# ha de utilizarse las palabras claves "ref" y "out".

nombremetodo(ref int a) { } //Definicion de metodo...
nombremetodo(ref b); //llamada al metodo....

De esta manera, podremos cambiar B en el metodo, y los cambios persistiran. Pero solo podremos enviar de esta manera variables ya inicializadas, a las que ya les hayamos asignado previamente un valor. Para poder enviar variables sin inicializar, usaremos la sentencia "out", que funciona igual que ref. (En otros lenguajes out no existe, y ref se lleva todo el trabajo xD)

Como ya me he extendido demasiado... seguire en otro post....Hasta mas ver