# Aprendiendo C# y Revit API (III)

Advertencia

Esto no es un curso de programación, ni pretende serlo, simplemente son comentarios e ideas de un aspirante a conocer C# y la API de Revit; si detectas algún error puedes contactar conmigo o dejar un comentario en esta entrada.

Creación de una Clase

Ya conocemos que la Programación Orientada a Objetos (POO) se caracteriza por el uso de ejemplares concretos de una determinada plantilla que previamente hemos definido; si hablamos con terminología más ortodoxa diríamos que "un programa escrito según el paradigma POO contendrá únicamente objetos", es decir, instancias de las clases definidas previamente por el desarrollador (o disponibles en el framework .NET).

Supongamos que vamos a diseñar un programa que va a trabajar con elementos constructivos. El primer paso que daremos será definir esas clases que nos permitirán generar posteriormente los objetos con los que trabajará nuestro programa.

Comenzaremos por definir una clase que agrupe a todos los elementos constructivos existentes en un edificio; la denominaremos "ElementoConstructivo":

    class ElementoConstructivo
    {
        // Atributos de la clase ElementoConstructivo

        // Propiedades de la clase ElementoConstructivo

        // Métodos de la clase ElementoConstructivo

        // Constructores de la clase ElementoConstructivo
    }

Ahora debemos comenzar a definir los miembros que componen dicha clase, distinguiendo principalmente entre:

  • Atributos (campos)
  • Propiedades
  • Métodos
  • Constructores

Atributos (campos)

Los atributos, o campos, de una clase son variables asociadas a dicha clase que pueden ser de multitud de tipos y para los que debemos controlar siempre su accesibilidad, es decir, que región del programa tiene acceso a dicho miembro de la clase.

En nuestro caso, vamos a definir dos variables privadas: "id", de tipo "int", y "nombre", de tipo "string":

        // Atributos de la clase ElementoConstructivo
        private int id;
        private string nombre;

Propiedades

Generalmente, no suele ser buena idea permitir que los valores de los atributos de una clase se lean o modifiquen directamente desde el exterior de la clase, principalmente porque perderíamos la capacidad de verificar cómo se devuelven o establecen dichos valores. Por este motivo se definen las propiedades, identificadas generalmente con el nombre del atributo en mayúsculas, que controlan cómo se recupera (get) o se establece (set) el valor de un atributo.

En nuestro caso, podemos verificar que el atributo "id" sea siempre mayor que 0 y que el atributo "nombre" no quede vacío (valor 'null' o espacios en blanco):

       // Propiedades de la clase ElementoConstructivo
        public int Id
        {
            get { return id; }
            set
            {
                if (value <= 0) id = 0;
                else id = value;
            }
        }
        public string Nombre
        {
            get { return nombre; }
            set
            {
                if (string.IsNullOrWhiteSpace(value)) nombre = "Sin especificar";
                else nombre = value;
            }
        }

Métodos

Además de controlar la información contenida en los atributos de la clase (a través de las propiedades), en la POO existe el concepto de método, que podríamos definir como una acción que se ejecuta en una clase u objeto (dependiendo del tipo de método implementado) como respuesta a un mensaje/llamada recibido.

En nuestro ejemplo, al ser una clase muy sencilla vamos a poder implementar pocos métodos. Sin embargo, vamos a suponer que necesitamos que nuestro objeto nos envíe un "string" (cadena de caracteres) con su nombre e identificador separados por el caracter "/"; para ello, implementaremos el método "Dni", haciendo un guiño al Documento Nacional de Identidad de España:

       // Métodos de la clase ElementoConstructivo
        public string Dni()
        {
            string mensaje = this.Nombre + " / " + this.Id.ToString();
            return mensaje;
        }

Constructores

Por último, es habitual definir uno o más constructores que serán las funciones que se invoquen cuando decidimos instanciar una clase, es decir, generar un objeto a partir de la clase que hemos definido.

Los constructores son fáciles de identificar porque tienen el mismo nombre que la clase; incluso podemos definir varios constructores que respondan a diferentes parámetros, lo que se conoce como "sobrecargas".

Para nuestro ejemplo, vamos a crear un único constructor que reciba dos argumentos, 'i' y 'n', que serán los valores que se asignarán a los atributos internos del objeto, utilizando para ello las propiedades definidas anteriormente:

        // Constructores de la clase ElementoConstructivo
        public ElementoConstructivo(int i, string n)
        {
            Id = i;
            Nombre = n;
        }

Creación de un objeto

Una vez que tenemos definida nuestra clase "ElementoConstructivo" podemos crear un pequeño programa en el que crearemos un par de objetos diferentes y, posteriormente, invocaremos algún método para que nos devuelvan cierta información de los mismos.

En C#, el compilador buscará entre los archivos fuente (extensión "cs") un único método denominado "Main" que será estático (static), no devolverá ningún valor (void) y cuyo argumento será de tipo string (string[] arg).

Este será el punto de entrada y salida del programa.

    class Program
    {
        static void Main(string[] args)
        {
        }
    }

Dentro del método "Main", definiremos e inicializaremos cuatro variables que utilizaremos como argumentos para la creación de los dos objetos de la clase "ElementoConstructivo":

            // Variables de los objetos
            int idObjeto1 = 12345;
            string nombreObjeto1 = "Muro";
            int idObjeto2 = 67890;
            string nombreObjeto2 = "Forjado";

A continuación, crearemos dos instancias de la clase "ElementoConstructivo" que denominaremos "elemento1" y "elemento2". Utilizaremos el constructor definido al que pasaremos como argumentos las variables definidas previamente:

            // Creación de objetos
            ElementoConstructivo elemento01 = new ElementoConstructivo(idObjeto1, nombreObjeto1);
            ElementoConstructivo elemento02 = new ElementoConstructivo(idObjeto2, nombreObjeto2);

Finalmente, mostraremos por pantalla dos cadenas de texto que hagan uso del método "Dni()" que definimos para la clase "ElementoConstructivo":

            // Utilizar el método Dni() en ambos objetos
            System.Console.WriteLine("El elemento 1 es '{0}'", elemento01.Dni());
            System.Console.WriteLine("El elemento 2 es '{0}'", elemento02.Dni());

La salida de la consola será:

El elemento 1 es 'Muro / 12345'
El elemento 2 es 'Forjado / 67890'

Conclusiones

Hemos visto que una clase es una 'plantilla' que definimos para poder crear objetos.

Esos objetos los creamos utilizando constructores que permiten definir los atributos que poseerá dicha instancia de la clase (objeto).

Además, podremos crear propiedades y métodos que permitirán a los diferentes objetos responder a los mensajes que le lleguen, devolviendo valores o realizando operaciones internas con los atributos de la clase.