¿Qué es un Namespace?

Un Namespace es una forma de agrupar clases (tipos) que están relacionadas de alguna forma.
El uso de los espacios de nombres nos permitirá tener nuestros ensamblados agrupados según
la tarea para la que los hemos programado.
Cada vez que creamos un proyecto con Visual Studio .NET de forma automática se crea un
espacio de nombres para nuestra aplicación.
Podemos usar lo que se llama importaciones de espacios de nombres, de esa forma podemos
acortar el código que tenemos que escribir.
Las importaciones de los espacios de nombres se hacen mediante la instrucción Imports (using
en C#). Dicha instrucción se usará al principio del fichero de código.
Visual Studio hace una serie de importaciones de forma automática y dependerán del tipo de
proyecto que estemos usando.
Para saber que espacios de nombres ha importado, podemos verlo en las propiedades del
proyecto, particularmente en la opción Referencias/Espacios de nombres importados.

Las referencias son las que le indican al compilador dónde encontrar las clases (y espacios de
nombres) que queremos usar en nuestro proyecto, mientras que las importaciones simplemente
hacen que no tengamos que escribir los espacios de nombres importados.

En un proyecto (ensamblado) podemos definir varios espacios de nombres.

Un espacio de nombres puede estar definido en varios ensamblados y todas las clases (tipos)
definidas se podrán acceder como si estuviesen en el mismo proyecto.
Podemos importar espacios de nombres para que el compilador sepa dónde buscar las clases.

Los espacios de nombres se utilizan como sistemas organizativos. Una forma de presentar
componentes del programa relacionados lógicamente.

LOS PILARES DE LA POO

Recordemos que tres son las principales características de un lenguaje orientado a objetos, es
decir, se considera que un lenguaje está totalmente orientado a objetos si es capaz de proveer
estas tres características:

 Encapsulación
 Herencia
 Polimorfismo

La ENCAPSULACIÓN es la cualidad de unificar los datos y la forma de manipularlos, de esta

forma podemos ocultar el funcionamiento de una clase y exponer solo los datos que manipula
(mediante propiedades), así como proveer de medios para poder manipular dichos datos
(mediante métodos). De esta forma solo exponemos al mundo exterior la información y la
forma de manipularla, ocultando los detalles usados para manejar esos datos.

La HERENCIA es la cualidad de poder crear nuevas clases (o tipos) basadas en otras clases, de
forma que la nueva clase obtenga todas las características de la clase que ha heredado, tanto
los datos que contiene como la forma de manipularlos, pudiendo añadir nuevas características e
incluso cambiar el comportamiento de algunas de las incluidas en la clase base.

Compartir las características de una clase base en otras clases derivadas de la clase base.
Reutilizar atributos y operaciones comunes de una clase base en una clase derivada.
Herencia simple: una clase únicamente puede heredar de una sola clase base
El POLIMORFISMO es la cualidad de implementar de forma particular algunas de las
características que tienen las clases, de forma que cuando necesitemos usarlas no nos preocupe
la implementación interna que cada una tenga, lo que realmente nos interesa o nos debe
importar es que podemos usar esas características.

Determina que el mismo nombre de método realizará diferentes acciones según el objeto sobre
el que se ha aplicado. Objetos de diferentes tipos pueden responder de forma diferente a la
misma llamada.

Polimorfismo basado en Herencia.

Ejemplo: En primer lugar, cree una clase base llamada Shape y clases derivadas como
Rectangle, Circle y Triangle. Incluya en la clase Shape un método virtual llamado Draw e
invalídelo en cada clase derivada para dibujar la forma determinada que representa la clase.

LAS CLASES Y ESTRUCTURAS

Una clase es una pieza de código en la que podemos definir una serie de datos y al mismo
tiempo unos métodos (funciones o procedimientos) que nos permitirán acceder a esos datos.

Una clase no es más que una estructura que se comporta de forma diferente. Los objetos creados
a partir de las clases son objetos por referencia, una estructura es por valor. Lo habitual es no
usar estructuras casi nunca.

Cuando definimos una clase, lo que estamos haciendo es definir una plantilla, a partir de la cual
podemos crear objetos en la memoria. Por tanto, la clase es el molde con el cual podemos crear
(instanciar) nuevos objetos. Una clase es una plantilla o una estructura preliminar de un objeto.
Esta estructura preliminar define atributos para almacenar datos y define operaciones para
manipular esos datos.

Un objeto es una instancia de una clase e incluye las características de esa clase. Los objetos se
distinguen uno de otro.

Las clases utilizan la abstracción para poner a disposición únicamente los elementos esenciales
para definir el objeto. Las clases utilizan la encapsulación para cumplir con la abstracción.

En .NET siempre usamos una clase para escribir cualquier tipo de código.

Podemos utilizar el Examinador de objetos para examinar los elementos de programación de un

componente (espacios de nombres, clases, módulos, estructuras, etc.) y los miembros de esos
elementos (propiedades, métodos, eventos, variables, etc.). Los componentes que examinemos
pueden ser proyectos de nuestra solución, componentes referenciados en esos proyectos o
componentes externos. En el menú Ver, seleccione Examinador de objetos.

INTERFACES
Cuando hablamos de polimorfismo, ineludiblemente tenemos que hablar de las interfaces. Una
clase especial en la que solamente se definen los métodos y propiedades que una clase que la
implemente debe codificar. Las interfaces representan un contrato, de forma que cualquier clase
que la implemente debe utilizar los miembros de la interfaz usando la misma forma en que ésta
la ha descrito: mismo número de argumentos, mismo tipo de datos devuelto, etc.
Una interfaz realmente es la definición de los miembros públicos de una clase. Por convención los
nombres de las interfaces siempre empiezan con la letra I mayúscula. Los miembros de las
interfaces siempre son públicos y no deben implementar código, solamente la definición.

Usar la instrucción Implements seguida del nombre de la interfaz.

Todas las clases siempre se derivan de la clase base Object.

Herencia simple, es decir, una clase solo se puede derivarse directamente de otra clase, si bien
se permite implementar múltiples interfaces.

CONSTRUCTORES Y DESTRUCTORES, EL PUNTO DE INICIO Y FINAL

DE LAS CLASES
Los constructores son procedimientos especiales, Sub New(parámetros), en los que podemos
escribir toda la lógica que debe usarse para la correcta creación del objeto. Por ejemplo,
podemos inicializar las variables.

El constructor es el único miembro de una clase que no se hereda, por tanto si necesitamos
crear constructores en clases derivadas debemos declararlos de forma explícita.

En .NET la destrucción (Finalize) de los objetos suele hacerse de forma automatizada, no es

necesario destruir explícitamente un objeto para eliminarlo de la memoria.

SOBRECARGA (OVERLOAD)
Definir varias funciones de las clases con un mismo nombre, pero que reciban distintos
argumentos, sean de diferentes tipos de datos o porque el número de argumentos usados sea
diferente.

LOS MIEMBROS DE LAS CLASES: CAMPOS, PROPIEDADES Y

MÉTODOS
Las clases manejan datos y proveen de funciones para acceder a esos datos.

Los campos no son otra cosa que variables declaradas en la clase, habitualmente declaradas de
forma privada.

Las propiedades son funciones especiales que nos permiten acceder a esos datos. Las
propiedades realmente representan a los datos que una clase contiene. Las propiedades
realmente son funciones.
Utilizamos el modificador ReadOnly en la declaración de la propiedad para crear únicamente la
propiedad Get. Utilizamos el modificador WriteOnly en la declaración de la propiedad para crear
únicamente la propiedad Set.

Los métodos nos permitirán realizar acciones sobre los datos.

Las clases tienen otros miembros como los eventos y las enumeraciones. Éstos nos permitirán
recibir notificaciones de cuando algo ocurra (eventos) o declarar ciertos valores constantes que
podemos usar para restringir algunos valores asignados a las propiedades o que nos permitan
seleccionar de forma coherente la información que queremos obtener (enumeraciones).
Los eventos son notificaciones que un objeto recibe de otros objetos u otras aplicaciones o que
transmite a ellos.

EL ÁMBITO DE LOS MIEMBROS DE LAS CLASES

El ámbito lo aplicamos para permitir el acceso desde cualquier código fuera de la clase o para
restringir ese acceso.

Private. Para uso privado. Cuando declaramos un miembro como privado sólo lo podremos
acceder desde la propia clase. Este es el más restrictivo y el que se recomienda para los
campos y las funciones de uso interno.

Protected. Uso protegido. Los elementos declarados como protegidos sólo estarán accesibles,
además de en la propia clase, por cualquier clase derivada.

Friend. Para uso dentro de la propia aplicación. Cuando declaramos un miembro con este
modificador, solo podremos acceder a él desde la propia clase o desde cualquier código que se
encuentre en el mismo ensamblado (proyecto).

Protected Friend. Una mezcla de Protected y Friend, es decir solo accesible desde las clases
derivadas o desde el mismo proyecto.

Public. Este modificador de ámbito nos permite exponer públicamente cualquier miembro de la
clase, de forma que no haya restricciones para acceder a él.

MIEMBROS Overridable, NO REEMPLAZABLES Y ABSTRACTOS

Cuando una clase hereda de otra podemos modificar el comportamiento de los miembros
heredados, pero estos solamente se podrán modificar si la clase base lo permite. El que una
clase que se base en otra, pueda crear su propia versión de ese método o propiedad dependerá
de que la clase base lo haya declarado como virtual (Overridable). En .NET los miembros de
una clase no son Overridables de forma predeterminada. Si queremos que la clase derivada
pueda crear su propia versión de un método, debemos declararlo como virtual o Overridable.

Si queremos que los miembros de nuestra clase se puedan redefinir en clases derivadas,
debemos indicarlo de forma expresa. Para que esto sea así, utilizaremos la instrucción
Overridable. Con esto logramos que en sucesivas derivaciones de la clase solamente exista un
mismo miembro polimórfico (un solo método).

Podemos definir miembros que a su vez sean abstractos, es decir, que en las clases abstractas
solamente se defina el método o propiedad, pero que no tenga ninguna funcionalidad, es más,
si declaramos un miembro como abstracto la clase que se derive de la clase abstracta estará
obligada a definirlo.
Serán las clases derivadas las que deban definir el código que los haga funcionales. Para indicar
que un miembro es abstracto, debemos indicarlo usando la instrucción MustOverride. En las
clases derivadas tendremos que usar la instrucción Overrides. Los miembros abstractos solo se
pueden definir en clases abstractas.

Si queremos redefinir un miembro existente en alguna de las clases que hemos heredado; si es
un método que devuelve una cadena y no recibe parámetros, debemos "respetar" esas mismas
características, porque de lo que se trata es de cumplir con un contrato, dicho contrato estipula
que tipo de miembro es, (un método o una propiedad), que tipo de datos devuelve, si recibe o
no parámetros y en caso de que los reciba de que tipo deben ser.

Si en una clase base hemos definido un método virtual, pero posteriormente queremos que no
se pueda seguir redefiniendo en otras clases derivadas, debemos indicarlo usando el
modificador NotOverridable, el cual se usará junto con Overrides, ya que sobrescribe un
miembro de la clase base y como además lo queremos marcar como no virtual, debemos usar
las dos instrucciones: Overrides NotOverridable.

Clases selladas o no heredables: Este tipo de clases no permitirán que se usen como clases
base de otras nuevas clases. Debemos usar la instrucción o modificador NotInheritable.

Si queremos que un método forzosamente haya que redefinirlo en las clases derivadas, en esos
casos la clase base que lo define no contiene código ejecutable, solo la definición, (como ocurre
con las interfaces). Se dice que estos métodos son abstractos porque solo se ha definido en la
forma y no se ha implementado ningún código ejecutable. En Visual Basic se definen usando el
modificador MustOverride. Estos métodos abstractos solo se pueden declarar en clases
abstractas (MustInherit).

Las clases abstractas están pensadas para usarse como clases base de otras, todos los
miembros son virtuales de forma predeterminada, por tanto no es necesario indicarlos usando
el modificador Overridable. Las clases abstractas no se puedan usar para crear objetos, pero si
para usarse como base de otras. La definición de una clase abstracta: hay que usar el
modificador MustInherit.

Overridable. Los miembros virtuales son los que las clases derivadas puedes sobrescribir para
crear su propia versión. Para indicar en una clase derivada que estamos sobrescribiendo dicho
elemento, usaremos Overrides.

NotOverridable. Los miembros virtuales heredados se pueden marcar como no virtuales, (las
siguientes clases derivadas no podrán sobrescribirlos), usando esta instrucción a continuación
de Overrides.

MustOverride. Un método que se debe reemplazar en la clase derivada y que solo se define en
la clase base sin ningún código ejecutable. Los métodos abstractos son virtuales por defecto y
solo se pueden declarar en clases abstractas.

MIEMBROS DE INSTANCIAS Y COMPARTIDOS

Los miembros de la clase siempre son miembros de instancia, es decir, solo existen en la
memoria cuando se crea un nuevo objeto.

Pero es posible que nos interese crear miembros compartidos, es decir, miembros que
pertenecen a la propia clase, no a ninguna instancia en particular. Dándonos la oportunidad de
poder acceder siempre a ellos, independientemente de que hayamos creado o no un nuevo
objeto en la memoria.
Usaremos en Visual Basic la instrucción Shared (compartido).
NiveldeAcceso Shared Nombre As TipodeDatos.

También pueden crearse propiedades y métodos compartidos en las clases.

Private Shared interestRate As Double
Shared Property Rate( ) As Double
Get
Return interestRate
End Get
Set(ByVal Value As Double)
interestRate = Value
End Set
End Property

Los miembros de procedimiento compartidos únicamente pueden acceder a datos marcados con
la palabra clave Shared.

Los miembros de datos compartidos permiten que múltiples instancias hagan referencia a una
única variable de nivel de clase.

CLASES ABSTRACTAS Y SELLADAS

Podemos hacer que una clase solamente se use como clase base de otras, pero no se puedan
usar para crear nuevas instancias en memoria, este es el caso de las clases abstractas. Una
clase abstracta puede contener miembros abstractos, miembros normales o virtuales. Para
indicar que una clase es abstracta, se usa el modificador MustInherit.

Clases selladas o clases que no se pueden usar como clases base, en estos casos las clases las
definiremos como NotInheritable

Como HEREDAR de una clase.

Inherits: hereda de una clase base.

NotInheritable: no es heredable.
MustInherit: no pueden crearse instancias de la clase; deben heredarse como una clase base.

Pueden heredarse propiedades, métodos, miembros de datos, eventos y controladores de

eventos (dependiendo del ámbito).

La palabra clave Inherits se utiliza para definir una clase derivada que heredará de una clase
base existente.
Public Class NombreClase
Inherits NombreClaseBase …

Podemos utilizar la palabra clave MyBase para invocar métodos de una clase base.

La palabra clave NotInheritable se utiliza para definir una clase que no puede utilizarse como
clase base para herencia.
Public NotInheritable Class NombreClase …
La palabra clave MustInherit se utiliza para definir clases que no están pensados para ser
utilizados directamente como objetos instanciados.
Public MustInherit Class BaseClass …

Delegados
Un delegado es un tipo que define una firma de método y que puede proporcionar una
referencia a cualquier método con una firma compatible. Puede invocar (o llamar) al método a
través del delegado. Los delegados se utilizan para pasar métodos como argumentos a otros
métodos.

Los controladores de eventos no son más que métodos que se invocan a través de delegados.

Comparación entre clases y estructuras.

POLIMORFISMO USANDO CLASES E INTERFACES

Por ejemplo, si queremos que nuestra clase sea "clasificable", es decir, que se pueda usar en
una colección que clasifique los elementos que contiene, nuestra clase debe implementar la
interfaz IComparable.
Si definimos una clase en la que queremos que el método ToString actúe de forma que
podamos especificar ciertos formatos a la hora de mostrar el contenido, nuestra clase debe
implementar IFormattable.
Que queremos que nuestra clase actúe como una colección, en la que se pueda enumerar o
recorrer el contenido de la misma, debemos implementar la interfaz IEnumerable.