PROGRAMACIÓN .

NET - I

SEMANA 8
Interfaces y espacios de
nombres en .NET

Todos los derechos de autor son de la exclusiva propiedad de IACC o de los otorgantes de sus licencias. No está
permitido copiar, reproducir, reeditar, descargar, publicar, emitir, difundir, poner a disposición del público ni 1
ESTE
utilizarDOCUMENTO
los contenidos paraCONTIENE LAdeSEMANA
fines comerciales 8
ninguna clase.
 2
ESTE DOCUMENTO CONTIENE LA SEMANA 8
ÍNDICE

INTERFACES Y ESPACIOS DE NOMBRES EN .NET ................................................................................. 4

OBJETIVOS ESPECÍFICOS ........................................................................................................................... 4
INTRODUCCIÓN ...................................................................................................................................... 4
1. CLASES ABSTRACTAS........................................................................................................................ 5
1.1. DECLARACIÓN DE CLASES ABSTRACTAS .............................................................................. 5
2. INTERFACES.................................................................................................................................... 6
2.1. DECLARACIÓN DE INTERFACES............................................................................................ 6
2.2. IMPLEMENTACIÓN DE LAS INTERFACES.............................................................................. 8
3. ESPACIOS DE NOMBRES ................................................................................................................... 9
3.1. FUNCIONAMIENTO.............................................................................................................. 9
3.2. NIVEL DE ACCESO .............................................................................................................. 10
3.3. ESPACIO DE NOMBRES DE LA RAÍZ ................................................................................... 13
COMENTARIO FINAL.......................................................................................................................... 14
REFERENCIAS ..................................................................................................................................... 15

3
ESTE DOCUMENTO CONTIENE LA SEMANA 8
INTERFACES Y ESPACIOS DE NOMBRES EN .NET

OBJETIVOS ESPECÍFICOS
 Utilizar clases abstractas e interfaces en Microsoft .NET.
 Comprender el funcionamiento de los espacios de nombres en Microsoft .NET.

INTRODUCCIÓN
El contenido de esta semana se basa en el empleo de clases abstractas, interfaces y espacios de
nombres. Se observará la manera en que estos elementos son definidos y su importancia a la hora
del desarrollo de aplicaciones, tanto de tipo form, web o consola. Cabe destacar que en .NET
Framework, de manera predeterminada, al momento de crear un proyecto o aplicación, se asocian
a este algunas clases abstractas, interfaces y espacios de nombres. Acerca de esos elementos es
importante saber que pueden ser desactivados a través de la herramienta de propiedades del
proyecto.

4
ESTE DOCUMENTO CONTIENE LA SEMANA 8
 1. CLASES ABSTRACTAS
Las clases abstractas brindan la posibilidad de definir la interacción de los componentes. Con su
utilización se definen los comportamientos de las clases heredadas, al igual que su
implementación. En una clase abstracta se puede implementar la cantidad de interfaces que se
desee o necesite.

Las clases abstractas son de utilidad cuando un conjunto de componentes que estén relacionados
incorporen un grupo de métodos con la misma funcionalidad, pero de igual manera se necesita
flexibilidad en la implementación de diferentes métodos.

1.1. DECLARACIÓN DE CLASES ABSTRACTAS

Las clases abstractas permiten la creación de componentes, logrando definir un nivel de
funcionalidad para los métodos y retrasar la implementación de otros que necesiten llamar a una
clase específica.

Para declarar una clase abstracta se usa la sentencia MustInherit en Visual Basic .NET. Los
métodos que no vayan a ser modificados pueden programarse dentro de una clase base. Por su
parte, los métodos que se necesiten implementar se deben definir con la sentencia MustOverride.

La forma de declarar una clase es igual a la definición de variables, propiedades, eventos y

métodos que componen la clase.

[ Public | Private | Protected | Friend |Protected Friend ]

[ Shadows ] [ MustInherit | NotInheritable ]
Class nombre
[ Inherits nombreclase ]
[ Implements nombreinterface ]
[ statements ]
End Class

Tal como la declaración de procedimientos, funciones y métodos, dichas entidades usan las
palabras claves (Public, Private, Protected, Friend, Protected Friend) para definir el acceso que
podrán tener a ellas. Es opcional la palabra Shadows, la que indica que esa clase es nombrada de
la misma manera en una clase base.

Existen dos formas de indicar cómo la clase implementará la herecia:

- MustInherit: indica que no comparte miembros de la clase y pueden ser accedidos solo
por la derivación de clases. La clase sirve de clase base en una relación de herencia.
- NotInheritable: indica que de esa clase no está permitida ninguna otra herencia. La clase
será la última de la jerarquía.

5
ESTE DOCUMENTO CONTIENE LA SEMANA 8
Inherits también es opcional e indica que la clase hereda los miembros de otra clase. Al igual que
las anteriores, Implements es opcional e indica que la clase implementa los miembros de una
interface. Finalmente, Statements de igual forma es opcional, y define las variables, propiedades,
eventos, métodos y tipos de la clase. Si se declara una clase abstracta, luego puede ser instanciada
por otras clases que sean heredadas.

Ejemplo:

Public MustInherit Class Total

Public Sub calcularImpuesto(ByVal monto as Decimal)
Me.monto = monto * 0,19
End Sub
Public MustOverride Sub calcularTotal()

End Class

En el ejemplo anterior, se declara la clase abstracta llamada Total, y en su interior es definido el

subprocedimiento calcularImpuesto, que realiza el cálculo del 19% del monto recibido.

2. INTERFACES
Las interfaces permiten definir métodos, propiedades y eventos que podrá implementar la clase.
En otras palabras, definen las características que tendrá cada una de las clases. Las interfaces
proporcionan compatibilidad ya que permiten el desarrollo de mejoras sin afectar el código ya
existente. Muchas veces conviene más el uso de interfaces y no de una herencia de clases debido
a que las interfaces son fáciles de adaptar a nuevos requerimientos, y son más flexibles que las
clases base, ya que pueden definir una sola implementación que defina varias interfaces. Las
interfaces son de gran utilidad cuando se requiere implementar el mismo método en varias clases.
Tanto las clases como las interfaces pueden definir propiedades, métodos y eventos.

Cuando en una clase se implementa una interfaz, se proporcionan todos los elementos
previamente definidos en la interfaz. Por lo tanto, si se necesita realizar cambios en el código de
una interfaz, se debe tener en cuenta que esto afectará en el código de las clases que la
implementan.

2.1. DECLARACIÓN DE INTERFACES

Las interfaces son un conjunto de instrucciones dentro de las palabras claves Interface y End
Interface. Luego de la palabra Interface es opcional colocar la palabra clave Inherits, para llamar
una o varias interfaces heredadas.

6
ESTE DOCUMENTO CONTIENE LA SEMANA 8
Las demás palabras claves que se usan son Event, Sub, Function, Property, Class, Structure y Enum.
Las interfaces son Public implícitamente cuando se definen en el interior de clases, interfaces,
módulos y/o estructuras, pero de igual manera se pueden declarar Friend, Protected o Private.

En el siguiente ejemplo se muestra la manera de declarar interfaces:

Public Interface IPrimera

Function comparar(ByVal n As Object) As Integer
End Interface

A modo de recomendación: los nombres de las interfaces comienzan con la letra I (i mayúscula), y
en el ejemplo presentado se define una interfaz llamada IPrimera. Los miembros de una interfaz
son públicos y no deberán implementar código, sino su definición. En las clases donde se
implemente dicha interfaz, se debe crear una función para comparar el dato que es pasado por
parámetro con la instancia actual del objeto.

Según la definición anterior, se implementa la interfaz IPrimera de la siguiente forma:

Public Class Vehiculo

Inherits Marca
Implements IPrimera

...

Public Function comparar(ByVal n As Object) As Integer

Implements IPrimera.comparar
If modelo > ‘2000’ then
Return 1
Else
Return 0
End If
End Function

En otro ejemplo:

Interface ISegunda
Property Propiedad() As String
Function Funcion() As Integer
End Interface

En este último caso se creó una interfaz, la cual a su vez realiza el llamado o implementación de
una propiedad y una función definidas en otra parte del proyecto.

7
ESTE DOCUMENTO CONTIENE LA SEMANA 8
 2.2. IMPLEMENTACIÓN DE LAS INTERFACES
Para implementar interfaces se utiliza la sentencia Implements. Esta, como instrucción, se utiliza
cuando una estructura o clase implementa una interfaz. Implements, como palabra clave, es
necesaria cuando algún miembro de una clase y/o estructura implementa a un miembro específico
de interfaz.

Cuando se implementa alguna interfaz, debe ser incluida la palabra Implements luego de la
instrucción Class o Structure. Seguidas de la instrucción Implements, y separadas por coma, son
invocadas las interfaces que la clase implementará. Con Implements se puede llamar un solo
método que ejecute varios métodos previamente definidos en la interfaz.

Para especificar dentro de la clase a un miembro de la interfaz, se debe indicar el nombre de dicha
interfaz, luego un punto (.) y el nombre de la función, propiedad o evento que será implementado.

Ejemplo:

Class Clase
Implements claseinterface.interface

Sub(ByVal i As Integer) Implements claseinterface.interface.Sub

...
End Sub
End Class

En el ejemplo anterior, se declara un procedimiento Sub que implementará un método de una

interfaz.

Pueden ser usadas las sentencias (Overloads, Overrides, Overridable, Public, Private, Protected,
Friend, Protected Friend, MustOverride, Default y Static) para implementar los métodos de
interfaz.

Cuando una clase implementa alguna interfaz, debe implementar sus propiedades, eventos y
métodos.

Ejemplo:

Interface InterfacePrimera
Sub subprimer(ByVal i As Integer)
End Interface

' Esta hereda de InterfacePrimera, definiendo un método y propiedad.

Interface InterfaceSegunda
Inherits InterfacePrimera
Sub Metodo(ByVal y As Integer)
ReadOnly Property Numero() As Integer

8
ESTE DOCUMENTO CONTIENE LA SEMANA 8
End Interface

En el ejemplo anterior son definidas dos interfaces, donde la interfaz (InterfaceSegunda) hereda a
la interfaz InterfacePrimera.

3. ESPACIOS DE NOMBRES
Los espacios de nombres permiten la organización lógica de los objetos en ensamblados, los que a
su vez pueden estar compuestos por varios espacios de nombres. Además, los espacios de
nombres pueden estar conformados por otros espacios de nombres. Uno de los objetivos de los
espacios de nombres es evitar las redundancias al hacer las referencias en el caso en que se use
una gran cantidad de objetos dentro del proyecto.

3.1. FUNCIONAMIENTO
El objetivo principal de los espacios de nombres es facilitar el ordenamiento de los objetos de
manera lógica, además de permitir evitar las ambigüedades en los proyectos cuando se realizan
referencias de elementos con los mismos nombres. En las clases contenidas en .NET Framework,
como es el caso de ListBox, perteneciente a los ensamblados System.Web y
System.Windows.Foms, cuando se realizan referencias de estos ensamblados el compilador podría
no identificar cuál clase se desea emplear. Por esta razón se incluye el espacio de nombres, donde
la clase se encuentra definida.

Se muestra aquí un ejemplo de la referencia de los ensamblados System.Web y

System.Windows.Foms:

Dim listWeb As System.Web.UI.WebControls.ListBox

Dim listWindows As System.Windows.Forms.ListBox

Se puede usar la palabra clave Imports para hacer mucho más ligera la escritura del código. Dicha
palabra le indica al compilador que algunos espacios de nombres están sobreentendidos, es decir,
que el espacio de nombres fue referenciado anteriormente mediante la instrucción Imports.
Imports permite que el código esté mejor organizado y se lea fácilmente. Asimismo, evita los
conflictos debido a la utilización de nombres con longitud adecuada, permitiendo reducir el
tamaño de los nombres a la hora de hacer las referencias y/o llamados de los espacios de
nombres.

Ejemplo de los espacios de nombres System.Web y System.Windows.Foms usando la palabra clave

Imports:

9
ESTE DOCUMENTO CONTIENE LA SEMANA 8
Imports System.Windows.Foms
Imports System.Web.UI.WebControls
Public Class Clase
Dim lista As ListBox

Adicionalmente, se puede declarar espacios de nombres propios empleando las palabras claves
Namespace y End Namespace. El código presente entre “Namespace” y “End Namespace” es
accesible mediante el uso del llamado del espacio de nombres.

Se muestra aquí un ejemplo del desarrollo de un espacio de nombres:

Namespace Factura
Public Class Total
Public Function Neto(Precio As Decimal, Iva As Decimal) As Decimal
Return Precio * (1 + Iva / 100)
End Function
End Class
End Namespace

En el ejemplo anterior, fue definida la clase total y en su interior el procedimiento de función neto,
donde esta función permite ser accesible por habérsele asignado el prefijo con el nombre del
espacio de nombres.

La función neto, definida anteriormente, puede ser accedida de la siguiente manera:

Sub Main()
SubTotal = Factura.Total.Neto(500, 19)
End Sub

3.2. NIVEL DE ACCESO

Al momento de crear un proyecto, se crean de manera predeterminada algunas importaciones de
espacios de nombres. Dichas referencias de espacios de nombres pueden ser modificadas en caso
de ser necesario.

Se puede visualizar las importaciones activas que vienen por defecto en cada proyecto. Para ello,
el operador debe ubicarse en el explorador de soluciones, hacer clic en el botón derecho del
mouse sobre el nombre de su aplicación y luego, sobre el menú de Propiedades.

10
ESTE DOCUMENTO CONTIENE LA SEMANA 8
Luego, se abrirá una ventana donde aparecerá un menú en la parte izquierda. Si se presiona la
opción Referencias, se podrá visualizar todos los espacios de nombres que están siendo
referenciados por defecto. Cabe destacar que desde dicha ventana se pueden adicionar o eliminar
referencias para ese proyecto.

Como anteriormente se observó, dentro de los espacios de nombres se pueden definir clases,
interfaces, módulos, estructuras, delegados y espacios de nombres.

11
ESTE DOCUMENTO CONTIENE LA SEMANA 8
Existen varios niveles de espacio de nombres:

Palabra clave Global en nombres completos

En .NET Framework, cuando se definen espacios de nombres anidados, el código puede bloquear
el acceso al espacio de nombres System. En estos casos, el compilador no puede ejecutar de forma
expedita la referencia a System.Int32, debido a que SpecialSpace.System no logra definir a Int32.
Para resolver dicho inconveniente se hace uso de la palabra clave Global, la que permite
referenciar el espacio de nombres de la biblioteca de clases que se requiera (en este caso System).

En el siguiente ejemplo no se hace uso de la palabra clave Global:

Namespace EspacioNombre
Namespace System
Class Clase
Function Valor() As System.Int32
Dim a As System.Int32
Return a
End Function
End Class
End Namespace
End Namespace

Con el uso de Global, sería de la siguiente manera:

Namespace EspacioNombre
Namespace System
Class Clase
Function Valor() As Global.System.Int32
Dim a As Global.System.Int32
Return a
End Function
End Class
End Namespace
End Namespace

Palabra clave Global en espacios de nombres

En estos casos la palabra clave Global permite la definición de un espacio de nombres de forma
externa al espacio de nombres del proyecto. En los proyectos se crean espacios de nombres
basados en el espacio de nombres de cada proyecto.

En el siguiente ejemplo se declara un espacio de nombres para el espacio de nombres del

proyecto:

Namespace Global.EspacioNombre
...
End Namespace

12
ESTE DOCUMENTO CONTIENE LA SEMANA 8
Namespace Global
Namespace EspacioNombre
...

End Namespace
End Namespace

En el ejemplo presentado se declara el espacio de nombres Global.EspacioNombre, y luego el

proyecto hace referencia al espacio de nombres (EspacioNombre).

3.3. ESPACIO DE NOMBRES DE LA RAÍZ

El espacio de nombres de la raíz indica el espacio de nombres base para cada uno de los
elementos o archivos de un proyecto. .NET Framework le coloca el mismo nombre del proyecto al
espacio de nombres de la raíz. Por ejemplo, en un proyecto con nombre Votación, los elementos
pertenecerán al espacio de nombres Votación. En caso de declarar un espacio de nombres llamado
votando, el nombre para ese espacio sería Votacion.votando.

En caso de requerir indicar un espacio de nombres que existe en una instrucción espacio de
nombres, se puede indicar el espacio de nombres de la raíz en nulo. Esto se logra borrando la
entrada de espacio de nombres de la raíz en el menú Proyecto, tal como se muestra en la
siguiente figura:

13
ESTE DOCUMENTO CONTIENE LA SEMANA 8
De igual manera, para tener acceso a los espacios de nombres declarados fuera del proyecto se
utiliza la palabra clave Global, que permite tener acceso a los espacios de nombres externos.

COMENTARIO FINAL
En esta semana, se ha analizado como las interfaces y las clases resultan ser de gran utilidad para
el desarrollo eficiente de aplicaciones, no solo por la reutilización de código sino también por el
aprovechamiento de los recursos a la hora de la ejecución de los programas. Las interfaces
permiten definir métodos para que varias clases las puedan utilizar. Al igual que las clases, las
interfaces facilitan la definición de elementos como propiedades, eventos y métodos. Una clase
puede implementar la cantidad de interfaces que necesite, pero con respecto a una clase
abstracta solo puede heredar una.

Como se ha visto, el uso de Imports permite una mejor organización del código, obviando la
referencia de nombres completos de algunos espacios de nombres.

Según el tipo de proyecto que se esté desarrollando, algunos espacios de nombres son importados
por defecto. Los espacios de nombres de la raíz son creados de manera predeterminada al
momento de crear el proyecto en .NET Framework, teniendo la posibilidad de quitar su referencia
en caso de ser necesario.

14
ESTE DOCUMENTO CONTIENE LA SEMANA 8
REFERENCIAS

Microsoft (2016). Interfaces y clases abstractas. Recuperado de: https://msdn.microsoft.com/es-

es/library/cc437833%28v=vs.71%29.aspx

Microsoft (2016). Espacios de nombres en Visual Basic. Recuperado de:

https://msdn.microsoft.com/es-es/library/zt9tafza.aspx

PARA REFERENCIAR ESTE DOCUMENTO, CONSIDERE:

IACC (2016). Interfaces y espacios de nombres en .NET. Programación .NET - I. Semana 8.

15
ESTE DOCUMENTO CONTIENE LA SEMANA 8
 16
ESTE DOCUMENTO CONTIENE LA SEMANA 8