PROGRAMACIÓN .

NET - I

SEMANA 7
Procedimientos 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 7
ninguna clase.
 2
ESTE DOCUMENTO CONTIENE LA SEMANA 7
ÍNDICE

PROCEDIMIENTOS EN .NET ................................................................................................................. 4

OBJETIVO ESPECÍFICO............................................................................................................................... 4
INTRODUCCIÓN ...................................................................................................................................... 4
1. PROCEDIMIENTOS EN VISUAL BASIC .NET............................................................................................ 5
1.1. DECLARACIÓN DE PROCEDIMIENTOS ................................................................................ 5
1.2. LLAMADOS Y RETORNO DE PROCEDIMIENTOS ................................................................. 6
1.3. TIPOS DE PROCEDIMIENTOS EN .NET ................................................................................ 8
1.3.1. SUBPROCEDIMIENTOS................................................................................................... 8
1.3.2. PROCEDIMIENTOS DE FUNCIÓN .................................................................................... 9
1.3.3. PROCEDIMIENTOS DE PROPIEDAD .............................................................................. 10
1.3.4. PROCEDIMIENTOS DE OPERADOR ............................................................................... 11
COMENTARIO FINAL.......................................................................................................................... 13
REFERENCIAS........................................................................................................................................ 14

3
ESTE DOCUMENTO CONTIENE LA SEMANA 7
PROCEDIMIENTOS EN .NET

OBJETIVO ESPECÍFICO
 Comprender el funcionamiento y llamado de los distintos tipos de procedimientos de
Visual Basic .NET

INTRODUCCIÓN
El contenido de esta semana estará centrado en el estudio de los procedimientos en Visual Basic
.NET. El objetivo es poder conocer el funcionamiento de dichos procedimientos en este lenguaje
de programación, teniendo en cuenta lo útiles que son para el desarrollo de aplicaciones,
independiente de que se trate solo, por ejemplo, del cálculo simple de una operación aritmética o
del diseño de un sistema de facturación. Entre los tipos de procedimientos que se incluyen en este
material están Sub, Function, Property, Operator. Se analizará cómo se deben o se pueden llamar
los procedimientos desde las diferentes partes del código (clases, estructuras, modelos) para
poder ejecutar sus operaciones.

4
ESTE DOCUMENTO CONTIENE LA SEMANA 7
 1. PROCEDIMIENTOS EN VISUAL BASIC .NET
Son conjuntos de código o instrucciones que buscan resolver alguna problemática a través de una
aplicación. Entre las palabras claves para su declaración se encuentran Function, Sub, Get, Set,
Operator y End. La sentencia Sub no devuelve valores a diferencia de Function. La gran utilidad de
los procedimientos es la reutilización del código, debido a que puede crearlo y llamarlo en
distintos lugares de la aplicación donde necesite dicho proceso.

El código que se ejecutará debe estar dentro de un procedimiento y este, a su vez, dentro de una
clase contenedora.

Cada procedimiento tiene un nombre y líneas de código que se ejecutarán cuando sean invocados.
Por su parte, los parámetros permiten a los procedimientos o funciones poder adoptar un
comportamiento diferente, dependiendo del tipo de datos que estos posean.

1.1. DECLARACIÓN DE PROCEDIMIENTOS

Un procedimiento puede ser creado con la instrucción Sub o Function. Luego, iría el conjunto de
instrucciones y para finalizar la declaración se usa End Sub o End Function.

Procedimiento que no retorna valor

Se utiliza la palabra clave Sub, luego el nombre del procedimiento y entre paréntesis los
parámetros. Posterior a esto, debe incluir todas las instrucciones que serán ejecutadas del
procedimiento y por último la instrucción End Sub.

Sintaxis de declaración de un procedimiento:

Public Sub Nombre (ByVal x As Short)

…
End Sub

Procedimiento que retorne valor

Se utiliza la palabra clave Function, nombre del procedimiento y la palabra As, en la cual se debe
especificar el tipo de datos del valor retornado. Posteriormente, se debe incluir todas las
instrucciones que serán ejecutadas del procedimiento, incluyendo la instrucción Return para que
retorne el valor indicado en la declaración. Por último, se agrega instrucción End Function.

Sintaxis de declaración de una función:

[Modificadores] Function NombreFuncion [(ListaParametros)] As TipoRetorno

[Statements]
End Function

5
ESTE DOCUMENTO CONTIENE LA SEMANA 7
Cuando se habla de modificadores estos indican si el procedimiento es de uso compartido,
sobrecarga, entre otras características. En otras palabras, se distinguen por las instrucciones
(Public, Protected, Friend, Private, Protected Friend).

La sintaxis para declarar una función es la siguiente:

A la instrucción Return, se le asigna un valor y este luego será el valor que devuelva la función.

Public Function NombreFuncion(ByVal x As Short) as Integer

…
Return 0
End Function

Y cuando se utiliza la instrucción Exit Function,

Public Function NombreFuncion(ByVal x As Integer) As Double

myFunction = x
Exit Function
End Function

Aquí se puede observar un ejemplo de una función donde se suman dos números enteros:

Public Function Suma (ByVal numero1 As Integer, ByVal numero2 As

Integer) As Integer
Return numero1 + numero2
End Function

Donde los parámetros de entradas serán dos números enteros y como resultado se entregará
también un número entero.

Tanto Return como Exit Function generan el fin de la ejecución de una función (Function).

1.2. LLAMADOS Y RETORNO DE PROCEDIMIENTOS

Procedimiento que no retorna un valor

Los procedimientos Sub no retornan un valor. Se debe especificar el nombre, luego los parámetros
entre paréntesis y separados por coma. En caso de que no se tengan parámetros, se puede dejar
sin paréntesis, lo cual no es recomendable ya que estos facilitan la lectura del código escrito. Es
importante que los parámetros sean escritos en el mismo orden en el que fueron definidos en el
procedimiento.

Aquí se observa un ejemplo de procedimiento Sub, donde se muestra por pantalla el número
mayor:

Public Sub Mayor(ByVal a As Integer, ByVal b As Integer)

If (a > b) then
Console.WriteLine("El primer valor es mayor y es: ", a)
Else
Console.WriteLine("El segundo valor es mayor y es:", b)

6
ESTE DOCUMENTO CONTIENE LA SEMANA 7
 End Sub

Luego, para realizar el llamado serio:

Sub Main()
...
Dim a, b,i As Integer
i = 0
Do While i < 10

Mayor(a, b)

Loop
End Sub

Procedimiento que retorna un valor

Cuando es llamado dentro de una expresión

Se debe indicar el nombre del procedimiento Function, luego entre paréntesis y separados por
coma se deben incluir los parámetros. En caso de ser necesarios, se pueden omitir los paréntesis,
pero la lectura del código se hace mucho más fácil si se incluyen. Es muy importante que los
parámetros estén en el mismo orden en el cual fue definido el procedimiento, para asegurar los
resultados correctos al momento de la ejecución del mismo.

Un ejemplo de la suma de dos números:

Public Function Suma (ByVal numero1 As Integer, ByVal numero2 As

Integer) As Integer
Return numero1 + numero2
End Function

Luego, puede ser llamado de la siguiente manera:

Sub PruebaSuma()
Dim N1, N2 As Integer
Suma(N1, N2)
End Sub

Cuando es llamado en una instrucción de asignación

Se debe escribir el nombre de la variable o instrucción de asignación, luego el signo igual. Se tiene
que indicar el nombre del procedimiento Function, y seguidamente entre paréntesis y separados
por coma se deben incluir los parámetros. En caso de ser necesario, se pueden omitir los
paréntesis, pero la lectura del código se hace mucho más fácil si se incluyen. Es muy importante
que los parámetros estén en el mismo orden en el cual fue definido el procedimiento, para
asegurar los resultados correctos al momento de la ejecución del mismo.

7
ESTE DOCUMENTO CONTIENE LA SEMANA 7
El mismo ejemplo de la suma en este caso:

Sub PruebaSuma()
Dim N1, N2, Resultado As Integer
Resultado = Suma(N1, N2)
End Sub

Las maneras de llamar un procedimiento Function dependen de qué tan cómodo se sienta cada
desarrollador con cada uno.

1.3. TIPOS DE PROCEDIMIENTOS EN .NET

Como se ha dicho, los procedimientos son conjuntos de instrucciones que se encuentran entre las
palabras claves (Function, Sub, Operator, Get y Set) y la instrucción End para finalizarlo. En Visual
Basic, el código para la ejecución de un proceso tiene que estar en procedimientos. Existen
diferentes tipos de procedimientos: subprocedimientos, procedimientos de función,
procedimientos de propiedad y de operador.

1.3.1. SUBPROCEDIMIENTOS

Un subprocedimiento es un conjunto de instrucciones incluidas entre las palabras claves Sub y End
Sub. Este permite ejecutar un proceso o tarea y se retorna el control al código que es llamado,
pero por sí solo no devuelve ningún dato. Cuando se define un subprocedimiento de manera
Public, este se puede llamar desde cualquier parte del código del programa. Los
subprocedimientos pueden ser definidos en clases, estructuras o módulos.

Se muestra aquí un ejemplo de un subprocedimiento, en donde se define si un número ingresado

es par o impar:

Public Sub ParImpar(ByVal x As Integer)

If (x Mod 2 = 0) then
Console.WriteLine("Valor x ingresado es Par")
Else
Console.WriteLine("Valor x ingresado es Impar")
End Sub

Otro ejemplo que sirve para calcular el área de un rectángulo sería:

Sub calcularArea(ByVal largo As Double, ByVal ancho As Double)

Dim area As Double ' se declara la variable local.

If largo = 0 Or ancho = 0 Then
Exit Sub
End If
area = largo * ancho
Console.WriteLine(area)

8
ESTE DOCUMENTO CONTIENE LA SEMANA 7
End Sub

En el ejemplo anterior, se verifica si uno de los parámetros es igual a cero y si esto es verdadero el
subprocedimiento termina su ejecución; en el caso contrario, se ejecuta el cálculo y se muestra el
resultado por pantalla.

1.3.2. PROCEDIMIENTOS DE FUNCIÓN

Por otra parte, los procedimientos de Function son un conjunto de instrucciones incluido dentro
de las palabras claves Function y End Function; este ejecuta un proceso y luego retorna el control y
valor al código que realizó el llamado. Cuando se define un Function de manera Public, este se
puede llamar desde cualquier parte del código del programa. Este tipo de procedimiento acepta
parámetros de tipo constantes, variables y/o expresión. Cuando es llamado un procedimiento
Function, son ejecutadas cada una de las instrucciones hasta que consiga la instrucción End
Function, Exit Function o Return.

Este tipo de procedimientos, al igual que las variables, poseen un tipo de dato, y este se especifica
con la palabra clave As, luego del paréntesis que indican los parámetros.

En el ejemplo se calcula la mitad de un número:

- Con la instrucción Return

Function Fifty(ByVal j As Integer) As Double

Return j/2
End Function

- Con la instrucción Exit Function

Function Fifty(ByVal j As Integer) As Double

Fifty = j/2
Exit Function
End Function

Como se muestra en los ejemplos, la función siempre posee un tipo de datos que va a depender
tanto de los datos de entrada como de los cálculos que dentro del procedimiento se realicen.

9
ESTE DOCUMENTO CONTIENE LA SEMANA 7
 1.3.3. PROCEDIMIENTOS DE PROPIEDAD

Son un conjunto de códigos o instrucciones que pueden administrar una propiedad a la medida en
una clase, módulo o estructura en Visual Basic .NET. También son llamados descriptores de acceso
de propiedades. Se dividen en procedimientos Get y Set.

Get: retorna el valor de la propiedad. También se conoce como acceso hacia la propiedad.

Set: es el responsable de asignar un valor a la propiedad, incluyendo la referencia al objeto.

La sintaxis de declaración de un procedimiento Property es la siguiente:

Las instrucciones van delimitadas entre la palabra clave Property y End Property. Dichas líneas de
código definen los procedimientos de propiedad (Get y/o Set) y su instrucción End para cada uno
respectivamente, tal como se muestra a continuación:

[Modificador] Property NombrePropiedad[(ListaParametros)] [As TipoDato]

Get
' codigo
Return Valor
End Get

Set[(ByVal NuevoValor As DataType)]

' Codigo
LValor = NuevoValor
End Set
End Property

Cabe destacar que, al igual que los procedimientos Function, los procedimientos Property tienen
un tipo de datos, y en este caso solo pueden tener un solo tipo por propiedad. De igual manera, si
la propiedad almacena un valor Double, debe recuperar un valor Double.

Para llamar un procedimiento Property:

Se hace referencia a la propiedad, utilizando su nombre tal como se realiza con las variables, pero
se deben indicar todos los parámetros que sean obligatorios. Además, se debe incluir la lista de
parámetros dentro de paréntesis.

Cuando se trata de Get:

LValor = NombrePropiedad(Parametros)

Cuando se trata de Set:

NombrePropiedad(Parametros) = instrucción

10
ESTE DOCUMENTO CONTIENE LA SEMANA 7
Ejemplo:

Se crea una propiedad que permite leer y escribir los datos de los vehículos en un concesionario,
que para este caso serían “placa”, “patente” y “marca”.

Dim patente, marca As String

Property vehiculo() As String
Get
If marca = "" Then
Return patente
Else
Return patente & " " & marca
End If

End Get
Set(ByVal valor As String)
Dim espacio As Integer = valor.IndexOf(" ")
If espacio < 0 Then
patente = Value
marca = ""
Else
patente = valor.Substring(0, espacio)
marca = valor.Substring(espacio + 1)
End If
End Set
End Property

Cuando es llamada la propiedad vehículo, el procedimiento Get concatena y devuelve la patente y

marca del vehículo. En caso de que se asigne la patente y marca en un solo campo, es llamado Set
para dividir en dos.

1.3.4. PROCEDIMIENTOS DE OPERADOR

Estos procedimientos determinan la manera como funcionan los operadores básicos entre ellos (<
>, And o *). Cuando esos operadores son utilizados en una clase o estructura, se habla de una
sobrecarga de operadores. Luego de que es declarada una clase, se pueden definir las variables
que estarán asociadas a su tipo. En los tipos de datos son definidos los operadores, al igual que la
manera en que se comportarán dentro de la clase asociada.

Se utilizan las instrucciones Widening o Narrowing para la definición de un operador de conversión

de tipos. Mediante la instrucción ByVal deben ser declarados todos los operandos.

El modo de declarar un procedimiento de operador es el siguiente:

Public Shared [Widening | Narrowing] Operator simboloperador (operad1[,

operad2]) As TipoDato
' Codigo
End Operator

11
ESTE DOCUMENTO CONTIENE LA SEMANA 7
En la definición de un operador de una clase, por lo menos un operando debe ser del mismo tipo
de datos que posee la clase. Respecto a los operadores de conversión de tipos, deben pertenecer
al tipo de datos de dicha clase.

La manera de llamar un procedimiento operador es la siguiente:

Dim Estructura As nombreestructura

Dim NuevaEstructura As nombreestructura = Estructura simboloperador 10

Se hace uso del símbolo operador para llamar un procedimiento de operador, y se deben indicar
los operandos que son brindados por los operadores ya definidos.

A continuación se muestra el ejemplo de un operador +:

Public Structure Sumatoria

Dim primerNumero As Integer
Dim segundoNumero As Integer
Public Shared Operador +(ByVal v As Sumatoria,
ByVal w As Sumatoria) As Sumatoria
Return Sumatoria (v.primerNumero + w.segundoNumero)

End Operador
End Structure

En el ejemplo anterior es definido un procedimiento para el operador + dentro de una estructura.

En este procedimiento de operador se calcula la suma de dos números ingresados.

12
ESTE DOCUMENTO CONTIENE LA SEMANA 7
COMENTARIO FINAL
Los procedimientos en Visual Basic .NET son una serie de instrucciones que tienen
comportamientos bien definidos dependiendo de su tipo. Los subprocedimientos no retornan
valor, pero dentro de ellos se ejecutan todas las instrucciones definidas. Para el caso de los
procedimientos tipo función, se ejecutan los procesos y retornan un valor. Los procedimientos de
propiedad administran una característica previamente definida. En el caso de los procedimientos
de operador, permiten definir los operadores matemáticos y lógicos para ser usados en una clase
o estructura.

De esta manera, se puede notar que el empleo de procedimientos permite el buen uso de las
virtudes de Visual Basic .NET, pudiendo realizar la respectiva distribución del código aplicando el
paradigma orientado a objetos, en este caso empleando los procedimientos que a su vez son
invocados en las clases.

13
ESTE DOCUMENTO CONTIENE LA SEMANA 7
REFERENCIAS
Microsoft (2016). Cómo: crear un procedimiento (Visual Basic). Recuperado de:

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

PARA REFERENCIAR ESTE DOCUMENTO, CONSIDERE:

IACC (2016). Procedimientos en .NET. Programación .NET - I. Semana 7.

14
ESTE DOCUMENTO CONTIENE LA SEMANA 7
 15
ESTE DOCUMENTO CONTIENE LA SEMANA 7