0

Índice
Contenido

Introducción..................................................................................................................................... 2
2. CREACIÓN DE OBJETOS EN VISUAL BASIC .NET .......................................................... 2
2.1 Declaración de una clase en Visual Basic .Net ....................................................... 3
2.2 Agregar propiedades ...................................................................................................... 5
2.3 Creación de métodos ..................................................................................................... 7
2.4 Agregar eventos .............................................................................................................. 8
2.5 Definición y usos de interfaces ................................................................................... 9
2.6 Espacios de nombres .................................................................................................. 10
2.7 Creación y uso de una biblioteca DLL..................................................................... 11
Conclusión ................................................................................................................................. 12
Bibliografía ................................................................................................................................. 12

1
Introducción
En esta investigación estaremos viendo lo de la semana 3 que es la creación de objetos
en Visual Basic .NET y sus subtemas que conlleva esto, al igual que veremos ejemplos de
las definiciones. Es conocido para trabajos de .NET y C++ e otros lenguajes más. Aquí
veremos declaraciones de variables, creación de métodos, interfases, entre otros. Está
diseñado para simplificar la programación de aplicaciones en un ambiente distribuido.

2. CREACIÓN DE OBJETOS EN VISUAL BASIC .NET

Un objeto es una combinación de código y datos que puede verse como una unidad. Los
objetos pueden ser parte de una aplicación, como controles o formularios. Una aplicación
completa también puede ser un objeto. Cuando creas una aplicación en Visual Basic,
estás trabajando constantemente con objetos. Puede utilizar objetos proporcionados por
Visual Basic, como controles, formularios y objetos de acceso a datos.
También puede utilizar objetos de otros programas en un programade Visual Basic.
Incluso puedes crear tus propios objetos y definir propiedades y métodos adicionales para
ellos. Los objetos actúan como bloques de construcción prediseñados, por lo que puedes
escribir un fragmento de código una vez y usarlo una y otra vez. Cada objeto de Visual
Basic está definido por una clase.
Las categorías describen las variables, propiedades, procedimientos y eventos de un
objeto. Los objetos son instancias de una clase; Una vez que haya definido una clase,
puede crear tantos objetos como necesite. Considere las cookies y sus patrones para
comprender la relación entre los objetos y sus categorías.
El cortador de galletas es de primera categoría. Defina las propiedades de cada galleta,
como el tamaño y la forma. Esta categoría se utiliza para crear objetos. El objeto es una
cookie. Se debe crear un objeto para acceder a sus miembros (excepto a los miembros
compartidos, a los que se puede acceder sin una clase de objeto).
Creación de un objeto a partir de una clase
1. Determine a partir de qué clase quiere crear un objeto o defina su propia clase.
Por ejemplo:
Public Class Customer
Public Property AccountNumber As Integer

End Class

2. Escriba una instrucción Dim para crear una variable a la que pueda asignar una
instancia de clase. La variable debe ser del tipo de la clase deseada.
Dim nextCustomer As Customer

3. Agregue la palabra clave Nuevo operador para inicializar la variable en una nueva
instancia de la clase.
Dim nextCustomer As New Customer

2
 4. Ahora puede tener acceso a los miembros de la clase a través de la variable de
objeto.
nextCustomer.AccountNumber = lastAccountNumber + 1

2.1 Declaración de una clase en Visual Basic .Net

Para definir una clase:

Cree un proyecto haciendo clic en Nuevo proyecto en el menú Archivo.
Aparecerá el cuadro de diálogo Nuevo proyecto .
Seleccione Aplicación de Windows en la lista de plantillas de proyecto de
Visual Basic para que aparezca el nuevo proyecto.
Para agregar una nueva clase al proyecto, haga clic en Agregar claseen el
menú Proyecto. Aparecerá el cuadro de diálogo Agregar nuevo elemento.
Seleccione la plantilla Clase.
Asigne el nombre UserNameInfo.vb a la nueva clase y, a continuación,
haga clic en Agregar para mostrar el código de la nueva clase.
Public Class UserNameInfo
End Class
Puede usar el editor de código de Visual Basic para agregar una clase al formulario de
inicio escribiendo la palabra clave Class seguida del nombre de la nueva clase. El editor
de código proporciona la instrucción End Class correspondiente.
Defina un campo privado para la clase agregando el código siguiente entre las
instrucciones Class y End Class:
Private userNameValue As String
Si declara el campo como Private significa que solo se puede usar dentro de la clase.
Puede hacer que los campos estén disponibles desde fuera de una clase mediante
modificadores de acceso, como Public que proporcionan más acceso. Para más
información, consulte Niveles de acceso en Visual Basic.
Para definir una propiedad para la clase, agregue el siguiente código:
Public Property UserName() As String
Get
' Gets the property value.
Return userNameValue
End Get
Set(ByVal Value As String)

3
 ' Sets the property value.
userNameValue = Value
End Set
End Property
Para definir un método para la clase, agregue el siguiente código:
Public Sub Capitalize()
' Capitalize the value of the property.
userNameValue = UCase(userNameValue)
End Sub
Para definir un constructor parametrizado para la nueva clase, agregue un
procedimiento denominado Sub New:
Public Sub New(ByVal UserName As String)
' Set the property value.
Me.UserName = UserName
End Sub
Se llama automáticamente al constructor Sub New cuando se crea un objeto basado en
esta clase. Este constructor establece el valor del campo que contiene el nombre de
usuario.

Para crear un botón para probar la clase

1. Cambie el formulario de inicio al modo de diseño; para ello, haga clic con el botón
derecho en su nombre en el Explorador de soluciones y, a continuación, haga clic
en Diseñador de vistas. De forma predeterminada, el formulario de inicio para
proyectos de aplicaciones Windows se denomina Form1.vb. Aparecerá el
formulario principal.
2. Agregue un botón al formulario principal y haga doble clic en él para mostrar el
código del controlador de eventos Button1_Click. Agregue el código siguiente para
llamar al procedimiento de prueba:
' Create an instance of the class.
Dim user As New UserNameInfo("Moore, Bobby")
' Capitalize the value of the property.
user.Capitalize()
' Display the value of the property.
MsgBox("The original UserName is: " & user.UserName)

4
' Change the value of the property.
user.UserName = "Worden, Joe"
' Redisplay the value of the property.
MsgBox("The new UserName is: " & user.UserName)

Para ejecutar la aplicación

1. Para ejecutar la aplicación, presione F5. Haga clic en el botón del formulario para
llamar al procedimiento de prueba. Muestra un mensaje que indica que el
UserName original es "MOORE, BOBBY", porque el procedimiento llamó al
método Capitalize del objeto.
2. Haga clic en Aceptar para descartar el cuadro de mensaje. El procedimiento
Button1 Click cambia el valor de la propiedad UserName y muestra un mensaje
que indica que el nuevo valor de UserName es "Worden, Joe".

2.2 Agregar propiedades

Las propiedades permiten que una clase exponga métodos públicos para obtener y
establecer valores mientras oculta el código de implementación o validación. Un
descriptor de acceso de propiedad se usa para devolver una propiedad, mientras que una
propiedad de establecimiento se usa para asignar un nuevo valor. En C# 9 y versiones
posteriores, el descriptor de acceso de la propiedad init solo se usa para asignar nuevos
valores durante la construcción del objeto.
Estos accesorios pueden tener diferentes niveles de acceso. Para obtener más
información, consulte Restringir el acceso a los accesorios. La palabra clave value se
utiliza para definir un valor que se asignará a un conjunto o inicializador. Las propiedades
pueden ser de lectura y escritura (ambas tienen accesos get y set), de solo lectura (tienen
accesos get pero no accesos establecidos)o de solo lectura (tienen accesos establecidos
pero no accesos get).Los atributos de escritura son raros y a menudo se utilizan para
restringir el acceso a datos confidenciales. Las propiedades simples que no requieren una
contraseña definida por el usuario se pueden implementar como propiedades definidas
por el cuerpo de la expresión o implementarse automáticamente.

Propiedades implementadas automáticamente

En algunos casos, los descriptores de acceso de propiedad get y sets implemente
asignan un valor a un campo de respaldo o recuperan un valor de él sin incluir ninguna
lógica adicional. Mediante las propiedades implementadas automáticamente, puede
simplificar el código y conseguir que el compilador de C# le proporcione el campo de
respaldo de forma transparente. Si una propiedad tiene los descriptores de acceso get y
set (o get y init), ambos se deben implementar de forma automática.

5
Una propiedad implementada automáticamente se define mediante las palabras clave
gety set sin proporcionar ninguna implementación. El ejemplo siguiente repite el anterior,
salvo que Name y Price son propiedades implementadas automáticamente. En el ejemplo
también se quita el constructor parametrizado, por lo que los objetos SaleItem ahora se
inicializan con una llamada al constructor sin parámetros y un inicializador de objeto.
C#
public class SaleItem
{
public string Name
{ get; set; }
public decimal Price
{ get; set; }
}
Las propiedades implementadas automáticamente pueden declarar diferentes
accesibilidades para los descriptores de acceso get y set. Normalmente, declara un
descriptor de acceso público get y un descriptor de acceso privado set. Puede obtener
más información en el artículo sobre Restringir la accesibilidad del descriptor de acceso.

Propiedades obligatorias
A partir de C# 11, puede agregar el miembro required para forzar que el código de cliente
inicialice cualquier propiedad o campo:
C#
public class SaleItem
{
public required string Name
{ get; set; }
public required decimal Price
{ get; set; }
}
Para crear SaleItem, debe establecer las propiedades Name y Pricemediante
inicializadores de objeto, como se muestra en el código siguiente:
C#
var item = new SaleItem { Name = "Shoes", Price = 19.95m
};Console.WriteLine($"{item.Name}: sells for {item.Price:C2}”);

6
2.3 Creación de métodos
Un método es un bloque de código que contiene una serie de instrucciones. Los
programas ejecutan declaraciones llamando a métodos y especificando los parámetros de
método requeridos. En C#, todas las declaraciones ejecutadas se ejecutan en el contexto
de un método. El método principal es el punto de entrada de cada aplicación C# y
Common Language Runtime (CLR) lo llama cuando se inicia el programa. En aplicaciones
que utilizan directivas de nivel superior, el compilador genera el método principal y
contiene todas las directivas de nivel superior.
class TestMotorcycle : Motorcycle {

public override double GetTopSpeed() {

return 108.4; } s

tatic void Main() { TestMotorcycle moto = new TestMotorcycle();

moto.StartEngine(); moto.AddGas(15); moto.Drive(5, 20); double speed =
moto.GetTopSpeed(); Console.WriteLine("My top speed is {0}", speed); } }

Debemos de considerar 4 partes a recordar:

Un nombre significativo
Los enunciados que se ejecutarán cuando se invoque el método
Un único tipo de dato de retorno
Uno ó más datos de entrada, con los que nuestro método puede funcionar
(Opcional).

Parámetros de métodos frente a argumentos

La definición del método especifica los nombres y tipos de todos los parámetros
necesarios. Si el código de llamada llama al métodos, proporciona valores concretos
denominados argumentos para cada parámetro. Los argumentos deben ser compatibles
con el tipo de parámetro, pero el nombre del argumento (si existe) utilizado en el código
de llamada no tiene que ser el mismo que el parámetro con nombre definido en el método.
Por ejemplo:
C#
public void Caller()

{ int numA = 4;

// Call with an int variable. int productA = Square(numA);

int numB = 32; // Call with another int variable.

int productB = Square(numB);

// Call with an integer literal.

int productC = Square(12);

7
// Call with an expression that evaluates to int. productC = Square(productA
* 3);

int Square(int i) {

// Store input argument in a local variable.

int input = i;

return input * input;

2.4 Agregar eventos

Los eventos son cosas que suceden en su sistema programado. El sistema se encarga de
generar algún tipo de señal cuando ocurre un evento y proporciona un mecanismo para
realizar acciones automáticamente (ejecutar código) cuando ocurre el evento. Los eventos
se activan en una ventana del navegador y generalmente están asociados con elementos
específicos en esa ventana. Puede ser un solo elemento, un grupo de elementos, un
archivo HTML cargado desde la etiqueta actual o toda la ventana del navegador. Pueden
ocurrir diferentes tipos de eventos.
Por ejemplo:
El usuario selecciona, hace clic o pasa el ratón por encima de cierto elemento.
El usuario presiona una tecla del teclado.
El usuario redimensiona o cierra la ventana del navegador.
Una página web terminó de cargarse.
Un formulario fue enviado.
Un vídeo se reproduce, se pausa o termina.
Ocurrió un error.
Para reaccionar a un evento, puedes asociarle un manejador de eventos. Esto es un
bloque de código (normalmente una función de JavaScript que tú como programador
creas) que se ejecuta cuando el evento ocurre. Cuando uno de estos bloques de código
se configura para ejecutarse en respuesta de un evento, decimos que estamos
registrando un manejador de eventos. Nota: Los manejadores de eventos a veces son
llamados detectores de eventos. Estos términos, para lo que nos concierne justo ahora,
son intercambiables, aunque hablando de forma estricta, hacen referencia a dos
mecanismos que trabajan juntos. Los detectores de eventos están pendientes a que
ocurra un evento, mientras que el manejador es el código que se ejecuta en respuesta del
evento.
Un ejemplo: manejando un evento de clic
En el siguiente ejemplo, tenemos un único elemento <button> en la página:
HTML
<button>Cambiar el color</button>

8
Ahora tenemos algo de JavaScript. Veremos esto más a detalle en la siguiente sección
pero, por ahora, nos basta decir que: agrega un manejador de evento al evento "click" del
botón, y el manejador reacciona al evento estableciendo un color de fondo aleatorio en la
página:
JS
const btn = document.querySelector("button");
function random(number) {
return Math.floor(Math.random() * (number + 1));
}

btn.addEventListener("click", () => {
const rndCol = `rgb(${random(255)}, ${random(255)}, ${random(255)})`;
document.body.style.backgroundColor = rndCol;
});

2.5 Definición y usos de interfaces

Por interfaz nos referimos a la conexión física y funcional que se establece entre dos
entidades, dispositivos o sistemas que operan independientemente uno del otro. En este
sentido, la comunicación entre humanos y ordenadores se produce a través de interfaces.
La palabra "interfaz" proviene del inglés interfaz, que significa "superficie de contacto".
Una interfaz es un mecanismo o
herramienta que permite dicha
comunicación mediante la
representación de un conjunto
de objetos, íconos y elementos
gráficos que sirven como
metáforas o símbolos de
acciones o tareas que los
usuarios pueden realizar en una
computadora. Introduzca p.e.
datos en una hoja de papel en
blanco, envíe el documento a la
papelera, edítelo y cierre el
programa.
Básicamente existen dos tipos de interfaces en una computadora: las interfaces físicas,
que consisten en objetos que nos permiten ingresar datos y operarla computadora, como
ratones o teclados, que actúan como prótesis o extensiones de nuestro cuerpo; e
interfaces gráficas, también conocidas como GUI (Graphical User Interfaces), que

9
permiten a las personas interactuar con las computadoras a través de una serie de
elementos gráficos (ventanas, íconos, etc.). interfaz de usuario
Una interfaz de usuario es la forma en que las personas interactúan con una máquina,
dispositivo o computadora. Suelen ser amigables e intuitivos, lo que los hace fáciles de
entender y utilizar para los usuarios. Incluye elementos como menús, ventanas, teclados,
ratones, sonidos de alarma, etc., todos ellos canales para crear una comunicación
efectiva entre humanos y máquinas. GUI
Una interfaz gráfica de usuario, también conocida como GUI (abreviatura de Graphic User
Interface), es un programa informático que utiliza un conjunto de imágenes y objetos en
un entorno de simulación gráfica para representar todas las acciones disponibles para el
usuario. en la interfaz. Este sistema se llama WYSIWYG (Loque ves es lo que obtienes).
El objetivo de una interfaz gráfica de usuario es proporcionar a las personas un entorno
visual amigable e intuitivo para facilitarles la interacción con un sistema operativo,
máquina o computadora. Ejemplos de interfaces gráficas de usuario son entornos de
escritorio parasistemas operativos como Windows, GNU/Linux o Mac OS.

2.6 Espacios de nombres

Un espacio de nombres es en
realidad un espacio donde se
almacenan algunos nombres. Los
espacios de nombres proporcionan
una forma de agrupar archivos y
corresponden a la abstracción de
carpetas en el sistema de archivos.
Los espacios de nombres deben
agrupar recursos relacionados. En
tiempo de ejecución, el identificador
único de un artefacto consta del
espacio de nombres y el nombre
local del artefacto. Puede ver el
espacio de nombres del recurso en
la vista Integración empresarial.
Haga clic en el botón Mostrar
espacio de nombres en la barra de herramientas para mostrar los espacios de nombres
de recursos. El espacio de nombres de artefacto predeterminado se deriva de la ruta del
archivo. Puede cambiar este espacio de nombres predeterminado, pero hágalo con
precaución. Para obtener más información, lea el resto de este tema y la tarea
relacionada "Cambiar nombre del espacio de nombres".
Es válido que un módulo o biblioteca tenga múltiples espacios de nombres. Sin embargo,
se deben evitar las siguientes situaciones al utilizar espacios de nombres:
No divida el espacio de nombres en dos proyectos dependientes. Evite conflictos de
nombres en espacios de nombres.

10
2.7 Creación y uso de una biblioteca DLL
En este tutorial paso a paso se muestra cómo usar el IDE de Visual Studio para crear una
biblioteca de vínculos dinámicos (DLL) propia escrita en Microsoft C++ (MSVC). Después,
se muestra cómo usar la DLL desde otra aplicación de C++. Los archivos DLL (también
conocidos como bibliotecas compartidas en los sistemas operativos basados en UNIX)
son uno de los tipos de componentes de Windows más útiles. Se pueden usar como una
manera de compartir recursos y código, y para reducir el tamaño de las aplicaciones. Los
archivos DLL incluso pueden hacer que sea más sencillo dar servicio a las aplicaciones y
ampliarlas.
En este tutorial, creará un archivo DLL que implementa algunas funciones matemáticas.
Después, creará una aplicación de consola que usa las funciones del archivo DLL.
También obtendrá una introducción a algunas de las técnicas de programación y a las
convenciones que se usan en los archivos DLL de Windows.
En este tutorial se tratan las siguientes tareas:
Cree un proyecto de DLL en Visual Studio.
Agregue funciones exportadas y variables al archivo DLL.
Cree un proyecto de aplicación de consola en Visual Studio.
Utilice las funciones y variables que se importaron desde el archivo DLL en la
aplicación de consola.
Ejecute la aplicación completada.
Como sucede con una biblioteca vinculada estáticamente, un archivo DLL exporta
variables, funciones y recursos por nombre. Una aplicación cliente importa los nombres
para usar esas variables, funciones y recursos. A diferencia de una biblioteca vinculada
estáticamente, Windows conecta las importaciones de la aplicación a las exportaciones de
un archivo DLL en el tiempo de carga o de ejecución, en lugar de conectarse a ellos en el
tiempo de vinculación. Windows requiere información adicional que no forma parte del
modelo de compilación de C++ estándar para realizar estas conexiones. El compilador de
MSVC implementa algunas extensiones específicas de Microsoft en C++ para
proporcionar esta información adicional. Se explicarán estas extensiones según
avanzamos.
Este tutorial crea dos soluciones de Visual Studio; uno que compila el archivo DLL y otro
que compila la aplicación cliente. El archivo DLL usa la convención de llamada de C. Se
puede llamar desde aplicaciones escritas en otros lenguajes de programación, siempre y
cuando la plataforma, las convenciones de llamada y las convenciones de vinculación
coincidan. La aplicación cliente usa la vinculación implícita, donde Windows vincula la
aplicación al archivo DLL en el tiempo de carga. Esta vinculación permite que la aplicación
llame a las funciones proporcionadas por el archivo DLL al igual que las funciones de una
biblioteca vinculada de forma estática.
En este tutorial no se tratan algunas situaciones comunes. En el código no se muestra el
uso de archivos DLL de C++ por parte de otros lenguajes de programación. No se
muestra cómo crear una DLL solo de recursos, ni cómo usar la vinculación explícita para
cargar archivos DLL en tiempo de ejecución, en lugar de hacerlo en tiempo de carga.
Puede usar MSVC y Visual Studio sin problemas para realizar todas estas operaciones.

11
Aunque el código de la DLL está escrito en C++, hemos utilizado interfaces de estilo C
para las funciones exportadas. Hay dos razones principales para ello: en primer lugar,
muchos otros lenguajes admiten la importación de funciones de tipo C. La aplicación
cliente no debe estar escrita en C++. En segundo lugar, evita algunos problemas comunes
relacionados con las clases exportadas y las funciones miembro. Es fácil cometer errores
difíciles de diagnosticar cuando se exportan clases, ya que todo lo que se refiere dentro
de una declaración de clase tiene que tener una instanciación que también se exporta.
Esta restricción se aplica a las DLL, pero no a las bibliotecas estáticas. Si sus clases son
del estilo de los datos simples, no debería encontrarse con este problema.

Conclusión
Como conclusión, es muy beneficioso toda esta información, porque nos ofrece distintas
cosas que nos sirve y es muy útil. Nos brinda beneficios en la programación y simplifica la
creación de aplicaciones. Y nos damos cuenta que la forma de programar ha
evolucionado con el paso del tiempo, nos han facilitado las actividades que realizamos en
nuestra vida cotidiana y no cualquiera puede hacer un programa, se debe de tener
aprecio hacia los programadores porque son el futuro.

Bibliografía
https://learn.microsoft.com/es-es/dotnet/visual-basic/programming-guide/language-
features/objects-and-classes/
https://learn.microsoft.com/es-es/dotnet/csharp/programming-guide/classes-and-
structs/methods
https://www.significados.com/interfaz/#:~:text=Como%20interfaz%20designamos%2C%20
en%20informática,por%20medio%20de%20una%20interfaz.
https://www.ibm.com/docs/es/integration-designer/8.5.5?topic=projects-namespaces

12