Unidad 2 Semana 3

Taller de Programación 2023
TALLER DE PROGRAMACIÓN
Unidad De Aprendizaje 3: Diseño y Programación

Orientada a Objeto
Docente: César D’Alençon Vásquez
Instituto Profesión AIEP – Sede San Felipe Página 1
Contenido
Bienvenidos ............................................................................................................................................................................. 4
Introducción ............................................................................................................................................................................ 5
1. Clasificación de Los Lenguajes de Programación ............................................................................................................ 6
1.2. Declarativos............................................................................................................................................................. 6
1.3. Imperativos. ............................................................................................................................................................ 7
1.4. Generación de los Lenguajes. ................................................................................................................................. 7
1.4.1. Primera Generación. ........................................................................................................................................... 7
1.4.2. Segunda Generación. .......................................................................................................................................... 8
1.4.3. Tercera Generación. ............................................................................................................................................ 8
1.4.4. Cuarta Generación. ............................................................................................................................................. 8
1.4.5. Quinta Generación. ............................................................................................................................................. 8
2. Metodología Orientada a Objetos .................................................................................................................................. 9
2.1. Etapas Orientado a Objetos ..................................................................................................................................... 9
2.2. Diseño Orientado a Objetos ..................................................................................................................................... 9
2.3. Ciclo de Vida Orientado a Objetos ......................................................................................................................... 12
3. Introducción a .NET ....................................................................................................................................................... 14
3.1. ¿Qué es .NET? ......................................................................................................................................................... 14
3.2. .Net Framework .................................................................................................................................................... 14
3.3. Lenguajes .NET ...................................................................................................................................................... 15
3.4. El Common Language Runtime CLR ...................................................................................................................... 15
3.5. Microsoft Intermedial Language MSIL .................................................................................................................. 16
3.6. Common Language Specification CLS ................................................................................................................... 16
3.7. ADO.NET................................................................................................................................................................ 16
3.8. ASP.NET. ................................................................................................................................................................ 17
3.9. Biblioteca de Clases .NET ...................................................................................................................................... 17
4. .Net FrameWork............................................................................................................................................................ 18
5. MSIL, CLR y el código controlado .................................................................................................................................. 19
5.1. Tipos comunes entre Lenguajes .NET .CLS y CTS ....................................................................................................... 20
6. Assemblies .................................................................................................................................................................... 20
7. Common Type System .................................................................................................................................................. 21

7.1. Los Modificadores de acceso admitidos son: ............................................................................................................ 22

8. RAD (Rapid Application Development) ......................................................................................................................... 22
Referencias ............................................................................................................................................................ 25

Bienvenidos
Estimados Estudiantes, comenzamos ahora el módulo Taller de

Programación.
Para empezar la segunda Unidad, denominada Diseño y

Programación Orientada a Objeto, revisemos los Aprendizajes
Esperados que corresponden a esta tercera semana de Clases:
• Analizan diseño orientado a objeto, considerando proceso de

desarrollo de software.

Introducción
¿Qué es un Lenguaje de Programación? ¿Qué es .NET?
Es un conjunto de sintaxis y reglas semánticas que Net es la nueva plataforma de desarrollo que ha lanzado
definen los programas del computador. Es una técnica al mercado Microsoft, y en la que ha estado trabajando
estándar de comunicación para entregarle instrucciones durante los últimos años. Sin duda alguna será uno de
al computador. Un lenguaje le da la capacidad al los entornos de desarrollo que reinen durante los
programador de especificarle al computador, qué tipo próximos años
de datos actúan y qué acciones tomar bajo una variada
gama de circunstancias, utilizando un lenguaje ¿Entonces .NET es un lenguaje de programación?, No.
relativamente próximo al lenguaje humano. Es mucho más que eso, Microsoft .NET es un conjunto
de tecnologías de software, compuesto de varios
Un programa escrito en un lenguaje de programación lenguajes de programación que se ejecutan bajo el .NET
necesita pasar por un proceso de compilación, Framework. Es además un entorno completamente
interpretación o intermedio, es decir, ser traducido al orientado a objetos y que es capaz de ejecutarse bajo
lenguaje de máquina para que pueda ser ejecutado por cualquier plataforma.
el ordenador.
“¿Sabes cuál es el problema?

Imaginarte el ALGORITMO y no PROGRAMARLO”

1. Clasificación de Los Lenguajes de Programación
Los Lenguajes de Programación pueden ser Clasificados de acuerdo a diversos criterios:
✓ Lenguajes Interpretados (Intérpretes) como Basic, Dbase.

✓ Lenguajes Compilados (Compiladores) como C, C++, Clipper.
✓ Lenguajes Interpretados con recolectores de basura (Máquina Virtual) como Smalltalk, Java, Ocaml.
✓ Lenguajes Scripts (Motor de Ejecución) como Perl, PHP.
1.2. Declarativos.
Se les conoce como lenguajes declarativos en ciencias computacionales aquellos lenguajes de programación en
los cuales se le indica a la computadora que es lo que se desea obtener o que es lo que se está buscando, por
ejemplo: Obtener los nombres de todos los empleados que tengan más de 32 años. Algunos ejemplos de
lenguajes declarativos son el Datatrieve, SQL y las expresiones regulares
Siglas de Structured Query Language (Lenguaje Estructurado de Consultas). Es un lenguaje declarativo que
aúna características del Álgebra y el Cálculo Relacionales que nos permite lanzar consultas contra una Base de
Datos para recuperar información de nuestro interés, almacenada en ella.
Ejemplos de consultas SQL:

SELECT Nombre
From Tabl_fich_personales
where Edad >=18;
El concepto de expresiones regulares (Regular expressions en inglés) se refiere a una familia de lenguajes
compactos y potentes para la descripción de conjuntos de cadenas de caracteres. Numerosos editores de texto y
otras utilidades (especialmente en el sistema operativo UNIX), como por ejemplo sed y awk, utilizan estos
lenguajes para buscar ciertas estructuras en el texto y, por ejemplo, remplazarlas con alguna otra cadena de
caracteres

1.3. Imperativos.
En ciencias de la computación se llama lenguajes imperativos a aquellos en los cuales se le ordena a la

computadora cómo realizar una tarea siguiendo una serie de pasos o instrucciones, por ejemplo:
Paso 1, solicitar número.

Paso 2, multiplicar número por dos.
Paso 3, imprimir resultado de la operación.
Algunos ejemplos de lenguajes imperativos son: BASIC, C, C++, Java, Clipper, Dbase, C# y Perl.
1.4. Generación de los Lenguajes.
Los equipos de ordenador (el hardware) han pasado por cuatro generaciones, de las que las tres primeras
(ordenadores con válvulas, transistores y circuitos integrados) están muy claras, la cuarta (circuitos integrados
a gran escala) es más discutible.
Algo parecido ha ocurrido con la programación de los ordenadores (el software), que se realiza en lenguajes
que suelen clasificarse en cinco generaciones, de las que las tres primeras son evidentes, mientras no todo el
mundo está de acuerdo en las otras dos. Estas generaciones no coincidieron exactamente en el tiempo con las
de hardware, pero sí de forma aproximada, y son las siguientes:
1.4.1. Primera Generación.
Los primeros ordenadores se programaban

directamente en código binario, que puede
representarse mediante secuencias de ceros y unos
sistema binario. Cada modelo de ordenador tiene
su propio código, por esa razón se llama lenguaje
de máquina.

1.4.2. Segunda Generación.
Los lenguajes simbólicos, así mismo propios de la

máquina, simplifican la escritura de las instrucciones y
las hacen más legibles.
1.4.3. Tercera Generación.
Los lenguajes de alto nivel sustituyen las instrucciones

simbólicas por códigos independientes de la máquina,
parecidas al lenguaje humano o al de las Matemáticas.
1.4.4. Cuarta Generación.
Se ha dado este nombre a ciertas herramientas que

permiten construir aplicaciones sencillas
combinando piezas prefabricadas. Hoy se piensa que
estas herramientas no son, propiamente hablando,
lenguajes. Algunos proponen reservar el nombre de
cuarta generación para la programación orientada a
objetos.
1.4.5. Quinta Generación.
Se llama así a veces a los lenguajes de la inteligencia

artificial, aunque con el fracaso del proyecto japonés
de la quinta generación el nombre ha caído en
desuso

2. Metodología Orientada a Objetos
La metodología Orientada a Objetos fue propuesta por Grandy Booch y en ella propone que los sistemas
pueden ser vistos como un conjunto de objetos o entidades con una identidad y comportamiento propio, las
cuales interactúan entre si para alcanzar el objetivo común del sistema.
2.1. Etapas Orientado a Objetos
• Requerimientos.
• Análisis de la estructura de objetos.
• Análisis del comportamiento de objetos.
• Diseño de la estructura de objetos.
• Diseño del comportamiento de objetos.
• Programación.
• Prueba.
• Puesta en producción.
• Mantenimiento.
2.2. Diseño Orientado a Objetos
Müller, P. (1997) en su obra Modelado de Objetos con UML, define a este como un lenguaje de modelado y no
como un método o un proceso. Sostiene además que el UML está compuesto por una notación muy específica
y por las reglas semánticas relacionadas para la construcción de sistemas de software.
• Diagrama de Clases: Representan la estructura estática en términos de clases y relaciones.

• Diagrama de Casos de Uso: Representan las funciones de un sistema desde el punto de vista del
usuario.
• Diagrama de Objetos: Representan objetos y sus relaciones.
• Diagrama de Actividades: Representan el comportamiento de una operación como un conjunto de
acciones.
• Diagrama de Iteración: Se clasifican en:
o Diagrama de Secuencia: Son una representación temporal de los objetos y sus relaciones.
o Diagrama de Colaboración: Son una representación espacial de objetos, uniones e iteraciones.
• Diagrama de Estados: Representan el comportamiento de una clase en términos de estado.
• Diagrama de Implementación: Se clasifican en:
o Diagrama de Componentes: Representan los componentes físicos de una aplicación.

o Diagrama de Despliegue: Representan la colocación de componentes en piezas particulares de

hardware.


2.3. Ciclo de Vida Orientado a Objetos
Esta técnica fue presentada en la década de los 90, tal vez como una de las mejores metodologías a seguir para
la creación de productos software.

Puede considerarse como un modelo pleno a seguir, como así también una alternativa dentro de los modelos
anteriores.
Al igual que la filosofía del paradigma de la programación orientada a objetos, en esta metodología cada
funcionalidad, o requerimiento solicitado por el usuario, es considerado un objeto.
Los ciclos de vida clásicos se centran en el proyecto, el desarrollo orientado a objetos se basa en el producto,
no comprende los procesos como funciones, sino que arma módulos basados en componentes, es decir, cada
componente es independiente del otro y se relacionan entre ellos a través de interfaces, son más modulares y
se dividen en mini proyectos lo cual permiten que el código sea reutilizable.
Ventajas
• El cliente estará seguro de que el producto final reflejará lo que él desea.
• La planificación es sencilla.
• La calidad del producto resultante es alta.
• Permite trabajar con personal poco cualificado
Desventajas
• Primera versión de un producto es construida con poca funcionalidad y poca fiabilidad.
• Puede ser demasiado lento, demasiado grande o torpe en su uso, o las tres a la vez.
• Lo peor es la necesidad de tener todos los requisitos al principio. Lo normal es que el cliente no
tenga perfectamente definidas las especificaciones del sistema, o puede ser que surjan
necesidades imprevistas.
• Si se comete un error en la fase de análisis no lo descubrimos hasta la entrega, con el consiguiente
gasto inútil de recursos.
Los ciclos de vida orientados a objetos son:

• Modelo Fuente. Fue creado por Henderson-Sellers y Edwards en 1990. Es un tipo de ciclo de vida
pensado para la orientación a objetos y posiblemente el más seguido.
Un proyecto se divide en las fases: Planficación del Negocio – Construcción – Entrega.
Construcción
Es la más importante y se divide a su vez en otras cinco actividades:
➢ Planificación
➢ Investigación
➢ Especificación.
➢ Implementación
➢ Revisión

• Modelo de Agrupamiento.
• Modelo Remolino.
• Modelo PinBall.
3. Introducción a .NET
3.1. ¿Qué es .NET?
¿Entonces .NET es un lenguaje de programación?, No. Es mucho más que eso, Microsoft .NET es un conjunto
de tecnologías de software, compuesto de varios lenguajes de programación que se ejecutan bajo el .NET
Framework. Es además un entorno completamente orientado a objetos y que es capaz de ejecutarse bajo
cualquier plataforma.
3.2. .Net Framework
Es el entorno de trabajo de la plataforma .NET y que la engloba completamente. Toda la plataforma .NET
forma parte de .NET framework.

3.3. Lenguajes .NET
Destacan C# y VB.NET, y recientemente J#, aunque existen más lenguajes y con toda seguridad surgirán
nuevos.
3.4. El Common Language Runtime CLR
Es el motor en común de tiempo de ejecución de todos los lenguajes .NET.
El Common Language Runtime (CLR) es una serie de librerías dinámicas (DLLs), también llamadas Assemblies.

3.5. Microsoft Intermedial Language MSIL
Microsoft Intermedial Language, es el lenguaje intermedio al que compilan las aplicaciones (Asemmblies)
.NET. Este lenguaje intermedio es interpretado por el CLR en tiempo de ejecución.
3.6. Common Language Specification CLS
Common Language Specification, que engloban las pautas que deben cumplir los lenguajes .NET. Es esta
característica la que va a permitir a otras compañías producir lenguajes compatibles con .NET.
3.7. ADO.NET
Es la nueva interfaz de bases de datos. No se trata de una evolución de ADO, sino que se trata de una interfaz
completamente nueva.

3.8. ASP.NET.
Es la nueva tecnología para páginas web dinámicas completamente integrada dentro del entorno .NET.
Representa una auténtica revolución en el desarrollo Web (Internet e Intranet).
3.9. Biblioteca de Clases .NET
Es el conjunto de clases que componen el .NET framework y que nos permiten realizar casi cualquier tarea de
una manera fácil y rápida.

4. .Net FrameWork
.NET FrameWork es el corazón de la tecnología .NET. Es el marco de trabajo y ejecución común a toda la
tecnología .NET. Es por lo tanto un elemento indispensable dentro de la tecnología .NET.
Dentro del .NET framework están integrados los lenguajes .NET, el CLR, el CLS, ADO.NET, ASP.NET.
En el momento de escribir esta página .NET soporta los siguientes lenguajes de programación:
• C#
• C++ controlado
• VB.NET
• J#
• Delphi (Delphi de Borland).
Todos ellos trabajan perfectamente integrados con un motor común, el .NET framework, siendo C# el lenguaje
principal, ya que es el único que ha sido desarrollado específicamente para .NET. Gran parte de la biblioteca
de clases que componen el framework están escritas en C#.
.Net FrameWork es el conjunto de espacios de trabajo y clases que sirven de base a los lenguajes .NET. Es la
evolución de las API de Windows y de la fundación de clases de Microsoft MFC hacia la completa encapsulación.
Cualquier programa que desarrollemos utilizando la tecnología .Net, independientemente del lenguaje utilizado,
estará basado en .Net FrameWork.
La mejor forma de entender esto es un ejemplo. Imaginemos los menús de cualquier aplicación Windows que nos
permiten acceder a las distintas opciones del programa, pues bien, en el mundo de la tecnología .Net dichos
menús son una clase perteneciente al .Net FrameWork. Esta clase es siempre la misma independientemente del
lenguaje y entorno en el que nos encontremos, y la forma de trabajar con ella es la misma desde C#, VB.net o
cualquier lenguaje .Net. Lo mismo ocurre con los botones, las imágenes, la forma de leer los archivos. Todo,
absolutamente todo lo que hagamos en un lenguaje .NET está basado en el .Net FrameWork.

5. MSIL, CLR y el código controlado
Cuando escribimos un programa los hacemos en un determinado lenguaje que podríamos llamar "humano. Es
decir, podemos leer y entender un programa (o al menos intentarlo) a través de un editor de texto, ya que este
programa está escrito en lenguaje "humano" (utilizando nuestra letras y esas cosas). El único problema es que un
ordenador no es capaz de entender nuestro programa, así que hay que traducirlo a su idioma. A este proceso se le
conoce como compilación
Como resultado del proceso de compilación obtenemos el programa ejecutable en código máquina, que entiende
el ordenador pero no el "humano". Según la arquitectura del procesador, el sistema operativo, etc. este código es
diferente y un programa que se ejecuta correctamente en un entorno Windows no funciona en Macintosh o UNIX.
Es decir el programa sólo funciona para la plataforma para la que fue diseñado. Este no es el proceso que ocurre
en .NET.
Cuando compilamos un programa escrito en cualquiera de los lenguajes .Net no se compila hacia código máquina
nativo, sino que se hace hacia MSIL (Microsoft Intermediate Language), este MSIL es un lenguaje intermedio y
universal. Cuando compilo un programa escrito en C# o en VB.Net ambos generan MSIL, con ciertas diferencias
pero MSIL. Este código será interpretado posteriormente por un intérprete, el CLR. De este modo conseguimos
que un programa escrito en .NET funcione en cualquier plataforma existente, incluso en plataformas futuras, sólo
necesitamos construir el intérprete apropiado.
El MSIL es independiente del procesador, de la plataforma de desarrollo y de la plataforma de ejecución. El MSIL

es parte del .Net FrameWork.
Llegados a este punto tenemos nuestro programa compilado a MSIL, pero el programa no funciona, ya que el
procesador sólo entiende su propio código máquina nativo, y MSIL no lo es. Es entonces cuando aparece el CLR
(Common Language Runtime), o motor de ejecución común, que lo que hace es servir de traductor entre el MSIL y
el código máquina nativo. Cuando ejecutamos un programa el CLR se encarga de compilar a código nativo dicho
programa y ejecutarlo.
A este tipo de compiladores se les conoce como compiladores JIT (Just In Time). Si alguno de vosotros conoce Java
abra gritado ¡plagio, esto es el ByteCode!. No exactamente... cambian... los nombres. Teóricamente el CLR
interpreta MSIL mucho mejor de lo que lo hace Java con el ByteCode y existen ciertas diferencias en la
arquitectura interna, el CLR únicamente compila a código nativo la parte necesaria en cada momento durante la
ejecución mientras que Java compila el programa completo, pero.

De este modo podemos ejecutar nuestro programa sobre cualquier máquina, siempre y cuando exista una versión
del .Net FrameWork y del CLR apropiada. Al código que se ejecuta bajo la batuta del CLR se le conoce como código
contralado.
Nota técnica. Los lenguajes .Net no son compilados, ya que no generan código nativo, ni interpretados, ya que
compilan código MSIL, son lenguajes evaluados.
5.1. Tipos comunes entre Lenguajes .NET .CLS y CTS
Para que todo esto sea posible Microsoft ha introducido ciertas restricciones a la hora de diseñar los lenguajes de
programación y en la forma de programar.
La especificación común de lenguajes CLS hace posible que cualquier fabricante de software genere herramientas
compatibles con .NET. De esta forma existen versiones .NET de Delphi y otros lenguajes ajenos a Microsoft.
Dentro del CLS destaca especialmente el CTS (Common Type System), que es una especificación que define como
el CLR utiliza y administra los tipos de datos. Básicamente es una relación entre los distintos tipos de datos que
proporciona cada lenguaje. La consecuencia inmediata del CTS es que dentro de un mismo proyecto .NET
podemos utilizar varios lenguajes .NET.
6. Assemblies
Un proyecto .NET no genera un ejecutable tal y como lo conocemos. Un proyecto .NET genera Assemblies. Un
Asemmblies es la unidad ejecutable de cualquier programa .NET, pero no se limita al código compilado sino que
también incluye lo que se ha dado en llamar el manifiesto.
El manifiesto es un listado de las librerías (dll) y los controles (ocx) que son necesarios para que la aplicación
funcione. Este listado contiene el número de versión necesario para que la aplicación funcione correctamente,
impidiendo que la instalación posterior de un programa afecte a nuestro ejecutable.
Con esta técnica Microsoft pretende poner fin al infierno de las dll. El tiempo dirá si lo consiguen.

7. Common Type System
El Common Type System (CTS) o Sistema de Tipo Común es el conjunto de reglas que han de seguir las
definiciones de tipos de datos para que el CLR las acepte. Es decir, aunque cada lenguaje gestionado disponga de
su propia sintaxis para definir tipos de datos, en el MSIL resultante de la compilación de sus códigos fuente se han
de cumplir las reglas del CTS. Algunos ejemplos de estas reglas son:
Cada tipo de dato puede constar de cero o más miembros. Cada uno de estos miembros puede ser un campo, un
método, una propiedad o un evento.
No puede haber herencia múltiple, y todo tipo de dato ha de heredar directa o indirectamente de System.Object.

7.1. Los Modificadores de acceso admitidos son:
8. RAD (Rapid Application Development)
También conocido como como “Programación Visual”. Este fue acuñado por Microsoft Corpotation en 1991 con la
aparición de la primera herramienta de este tipo, Visual BasicTM. Se trataba de un entorno de desarrollo visual de
cuarte generación (4GL) que además integraba el editor tradicional, un compilador de Basic y un depurador con
un modelo de programación dirigida por eventos, aparte de herramientas visuales que permitían un rápido y fácil
desarrollo de software en entorno Windows.
Con la nueva generación de herramientas RAD, entre las que se incluye Microsoft Visual Basic 4.0, se presta
principal atención al desarrollo rápido de aplicaciones en sí mismo (RAD), reutilización de componentes y la
conectividad y escalabilidad de bases de datos.
Los actuales entornos RAD permiten no solo el desarrollo de aplicaciones finales sino también el diseño de
prototipos eficientes, y ofrecen:

Entornos de desarrollo visual, entre otros, el menú propio del entorno, la paleta de componentes, la ventana de
propiedades (que refleja las propiedades asociadas al control activo y el editor de código).
Controles de alto nivel, que suelen ser de tipos: los incorporados en la propia herramienta y a aquellos externos
(VBX y OCX principalmente) que pueden ser añadidos. Estos controles se disponen en forma de iconos en una
paleta de componentes.
Acceso directo a las distintas partes del código asociado a cada uno de los objetos, y que se encuentra en la
ventana del editor de código.
Las aplicaciones diseñadas se basan en entornos gráficos de usuarios (GUI) fáciles de manejar y con el siguiente
proceso de desarrollo:
Creación de un formulario vacío que contendrá los componentes de interfaz de la aplicación (controles).
Selección de los componentes apropiados del conjunto de los disponibles en la paleta de componentes en forma
de iconos. Estos pueden luego ser redimensionados una vez colocados en el formulario.

Particularización de las propiedades de los controles en base a los requisitos de la aplicación.
Escritura de código para los distintos eventos significativos asociados al control. Este código se estructura dentro
de cada procedimiento del control según el lenguaje de programación utilizado, y se pueden incluir sentencias
propias del lenguaje y referencias a métodos y procedimientos del propio control o de otros controles, estén o no
en el mismo formulario.
Ejecuciones de prueba dentro del entorno de desarrollo.
Modificación de la aplicación durante el proceso de desarrollo hasta la generación de un fichero ejecutable (.EXE)
definitivo.
Utilización de herramientas de apoyo para depurar y refinar el código.
Las herramientas RAD permiten crear aplicaciones con bases de datos. La conexión con una base de datos se
puede efectuar de dos formas:
1. Directamente, utilizando el motor de dicha base de datos.

2. A través de enlaces remotos (vía ODBC).
En la aplicación se pueden utilizar dos alternativas:
1. Controles específicos en el propio formulario.

2. Objetos en el código.
Comentario Final
El Objetivo principal de esta primera semana ha sido comprender sobre los lenguajes de programación, su
clasificación, comprender la metodología Orientada a Objetos, y reconocer que es .NET, el marco de trabajo que
ofrece .NET FrameWork, comprender como se integran estas dos herramientas, también se reconoce el uso de RAD
para agilizar el proceso de diseño y desarrollo de soluciones que requieren de interfaces gráficas.
Todo lo aprendido aquí se podrá aplicar en las próximas semanas, en donde se profundizara en mayor detalle sobre
el desarrollo que ofrece Visual Studio 2013 y los lenguajes C# y Visual Basic .NET.

Referencias
✓ Construya aplicaciones .NET 3.5 con la herramienta para negocio RAD de Microsoft. Tim Patrick, Mc Graw Hill
O’Reilly.
✓ Programación con Visual Basic 2008. Tim Patrick, Mc Graw Hill O’Reilly.
✓ Manual avanzado de Visual Basic 2008. Anaya, 2008, Jorge Serrano Pérez.

Unidad 2 Semana 3

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Unidad 2 Semana 3

Cargado por

Copyright:

Formatos disponibles

Taller de Programación 2023

Unidad De Aprendizaje 3: Diseño y Programación

Instituto Profesión AIEP – Sede San Felipe Página 2

7.1. Los Modificadores de acceso admitidos son: ............................................................................................................ 22

Instituto Profesión AIEP – Sede San Felipe Página 3

Estimados Estudiantes, comenzamos ahora el módulo Taller de

Para empezar la segunda Unidad, denominada Diseño y

• Analizan diseño orientado a objeto, considerando proceso de

Instituto Profesión AIEP – Sede San Felipe Página 4

¿Qué es un Lenguaje de Programación? ¿Qué es .NET?

“¿Sabes cuál es el problema?

Instituto Profesión AIEP – Sede San Felipe Página 5

1. Clasificación de Los Lenguajes de Programación

Los Lenguajes de Programación pueden ser Clasificados de acuerdo a diversos criterios:

✓ Lenguajes Interpretados (Intérpretes) como Basic, Dbase.

Ejemplos de consultas SQL:

Instituto Profesión AIEP – Sede San Felipe Página 6

En ciencias de la computación se llama lenguajes imperativos a aquellos en los cuales se le ordena a la

Paso 1, solicitar número.

1.4. Generación de los Lenguajes.

1.4.1. Primera Generación.

Los primeros ordenadores se programaban

Instituto Profesión AIEP – Sede San Felipe Página 7

1.4.2. Segunda Generación.

Los lenguajes simbólicos, así mismo propios de la

1.4.3. Tercera Generación.

Los lenguajes de alto nivel sustituyen las instrucciones

1.4.4. Cuarta Generación.

Se ha dado este nombre a ciertas herramientas que

1.4.5. Quinta Generación.

Se llama así a veces a los lenguajes de la inteligencia

Instituto Profesión AIEP – Sede San Felipe Página 8

2. Metodología Orientada a Objetos

2.1. Etapas Orientado a Objetos

2.2. Diseño Orientado a Objetos

• Diagrama de Clases: Representan la estructura estática en términos de clases y relaciones.

Instituto Profesión AIEP – Sede San Felipe Página 9

o Diagrama de Despliegue: Representan la colocación de componentes en piezas particulares de

Instituto Profesión AIEP – Sede San Felipe Página 10

Instituto Profesión AIEP – Sede San Felipe Página 11

2.3. Ciclo de Vida Orientado a Objetos

Instituto Profesión AIEP – Sede San Felipe Página 12

Los ciclos de vida orientados a objetos son:

Instituto Profesión AIEP – Sede San Felipe Página 13

3.1. ¿Qué es .NET?

3.2. .Net Framework

Instituto Profesión AIEP – Sede San Felipe Página 14

3.3. Lenguajes .NET

3.4. El Common Language Runtime CLR

Es el motor en común de tiempo de ejecución de todos los lenguajes .NET.

Instituto Profesión AIEP – Sede San Felipe Página 15

3.5. Microsoft Intermedial Language MSIL

3.6. Common Language Specification CLS

Instituto Profesión AIEP – Sede San Felipe Página 16

3.9. Biblioteca de Clases .NET

Instituto Profesión AIEP – Sede San Felipe Página 17

Instituto Profesión AIEP – Sede San Felipe Página 18

5. MSIL, CLR y el código controlado

El MSIL es independiente del procesador, de la plataforma de desarrollo y de la plataforma de ejecución. El MSIL

Instituto Profesión AIEP – Sede San Felipe Página 19

5.1. Tipos comunes entre Lenguajes .NET .CLS y CTS

Instituto Profesión AIEP – Sede San Felipe Página 20

7. Common Type System