Francisco Pacheco Control 1

PROGRAMACIÓN .NET - I

SEMANA 1

Introducción a Microsoft .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 ESTE LA de SEMANA 1 utilizarDOCUMENTO los contenidos paraCONTIENE fines comerciales ninguna clase.

1

ESTE DOCUMENTO CONTIENE LA SEMANA 1

2

ÍNDICE OBJETIVOSESPECÍFICOS ........................................................................................................................... 4 INTRODUCCIÓN ...................................................................................................................................... 4 1.

MICROSOFT .NET............................................................................................................................. 5 1.1.

HISTORIA ......................................................................................................................... 5

1.2.

¿QUÉ SE ENCUENTRA DETRÁS DE LA PLATAFORMA .NET?............................................. 6

1.3.

PRINCIPALES COMPONENTES DE .NET ............................................................................ 7

1.4.

GRUPOS DE PRODUCTOS DE .NET ................................................................................... 7

2 .NET FRAMEWORK ........................................................................................................................... 8 2.1 LA PLATAFORMA .NET ........................................................................................................... 8 2.2 METAS DE DISEÑO ................................................................................................................. 8 2.2.1 INFRAESTRUCTURA DE COMPONENTES ............................................................................ 9 2.2.2 INTEGRACIÓN DE LENGUAJES ............................................................................................ 9 2.2.3 DESARROLLO SIMPLIFICADO ............................................................................................ 10 2.2.4 REUSABILIDAD .................................................................................................................. 10 2.2.5 SEGURIDAD....................................................................................................................... 11 2.3 EVENTOS Y EL CONTROL DE EVENTOS EN .NET FRAMEWORK............................................ 11 2.3.1

FUNCIONAMIENTO DEL MODELO DE PROGRAMACIÓN CONTROLADO POR EVENTOS ...................................................................................................................................12

2.3.2 CONTROLADORES DE EVENTOS ....................................................................................... 12 2.3.3 GENERACIÓN DE EVENTOS ............................................................................................... 14 2.3.4

IMPLEMENTACIÓN DE DELEGADOS .......................................................................... 14

2.4 ARQUITECTURA DEL FRAMEWORK ..................................................................................... 15 2.4.1

COMMON LANGUAGE RUNTIME (CLR) ..................................................................... 16

2.4.2 LENGUAJES SOPORTADOS ................................................................................................ 17 COMENTARIO FINAL .......................................................................................................................... 18 REFERENCIAS BIBLIOGRÁFICAS. ................................................................................................................ 19


3

INTRODUCCIÓN A MICROSOFT.NET OBJETIVOS ESPECÍFICOS







Comprender las metas de diseño de reusabilidad y de desarrollo simplificado del Framework de .NET en el desarrollo de proyectos de software. Conocer el funcionamiento del modelo de programación controlado por eventos en Microsoft .NET. Comprender el funcionamiento del Common Language Runtime (CLR) en Microsoft .NET.

INTRODUCCIÓN En esta primera clase se pondrá atención al contexto de lo que implica desarrollar aplicaciones en la plataforma .NET. Se verán, como temas principales, las metas de diseño en las que se basa esta infraestructura y cómo esas metas de diseño permiten a los desarrolladores de software crear aplicaciones para múltiples plataformas. Se analizará también el funcionamiento del modelo de programación controlado por eventos que Microsoft pone al alcance de los programadores y cómo el uso de delegados cambia la manera de declarar y usar los eventos. Por último, se verán las funciones del CLR (Common Language Runtime) y las ventajas que ofrece este modelo de desarrollo de aplicaciones.


4

1. MICROSOFT .NET El framework Microsoft .NET es una infraestructura de desarrollo creada por la reconocida empresa de informática Microsoft, la que constituye el motor de ejecución de las aplicaciones desarrolladas sobre esta. En otras palabras, ello significa que el código escrito bajo esta tecnología será independiente del sistema operativo en el cual se ejecute, ya que es justamente el motor el que interpretará las líneas de código y las ejecutará según sea necesario. Esto permite que las aplicaciones puedan ejecutarse en distintos sistemas operativos sin tener que realizar modificaciones al código, además de poder funcionar en diferentes arquitecturas de hardware, nuevamente, sin tener que realizar modificaciones al código. Un ejemplo claro de lo anterior es que dentro del abanico de sistemas operativos provistos por Microsoft las aplicaciones funcionan sin mayores inconvenientes. Pero, cuando se habla de distintos sistemas operativos, no nos referimos a las diferentes versiones de Windows, sino que hacemos referencia a ellos e incluso a aquellos que están fuera de las arquitecturas de hardware que se pueden encontrar en computadoras personales de escritorio o portátiles. Microsoft provee sistemas operativos para dispositivos multimedia portables como Zune o consolas de videojuegos como Xbox, así como para teléfonos celulares como las versiones de Windows Mobile y Windows Phone. En todos estos casos, Microsoft .NET Framework está presente, y si se hace un desarrollo cuidadoso, el código creado podría funcionar en forma automática en cada uno de esos dispositivos sin tener que realizar cambios sustanciales a lo desarrollado (Iacono, 2011).

1.1. HISTORIA Microsoft .NET Framework hace su aparición a principios del año 2002 con la versión 1.0. Desde entonces hasta la fecha se han sucedido diferentes versiones y en la actualidad se cuenta con la versión 4.6. Previo a que esta arquitectura existiera, Microsoft contaba con el entorno de desarrollo Visual Studio 4.0 que fue lanzado al mercado en el año 1995. Visual Studio 97 y Visual Studio 6.0 fueron los siguientes productos desarrollados. Si bien .NET comienza a ser desarrollado en la década de 1990, recién apareció su primera versión beta en el año 2000. La primera versión fue lanzada al mercado a principios de 2002 para funcionar en las plataformas Windows NT 4.0, Windows 98, Windows Millenium y XP. Esta nueva plataforma introdujo importantes cambios en la forma de programar, siendo la primera vez en que se comenzó a usar el CLR (Common Language Runtime) y tener soporte para programación web orientada a objetos (Thai y Lam, 2003).


5

1.2. ¿QUÉ SE ENCUENTRA DETRÁS DE LA PLATAFORMA .NET?

Computación distribuida Simplifica la construcción de aplicaciones cliente/servidor de gran envergadura y programación por capas. Microsoft .NET provee arquitecturas de cliente-servidor que sacan el máximo provecho de estándares abiertos de internet como HTTP, XML, SOAP y WSOL.

Componentización Agrega simplicidad a la integración de componentes de software desarrollados por diferentes vendedores y permite el desarrollo de aplicaciones distribuidas.

Servicios empresariales Permite el desarrollo de aplicaciones empresariales escalables, sin la necesidad de escribir código para el manejo de transacciones y seguridad.

Cambio de paradigma web Con el tiempo, el desarrollo de aplicaciones web ha experimentado transformaciones, desde una visión orientada a conectividad (HTTP) y presentación (HTML) hacia la programabilidad (XML y SOAP). Una meta esencial de Microsoft .NET ha sido el permitir el intercambio de funcionalidad sobre la web en diferentes plataformas, dispositivos y lenguajes de programación.

Madurez de la industria TI Lecciones que la industria del software ha aprendido del desarrollo de grandes aplicaciones web empresariales. Una aplicación web comercial debe soportar interoperatividad, escalabilidad, disponibilidad, seguridad y manejabilidad. Microsoft .NET facilita el cumplimiento de estas metas.


6

1.3. PRINCIPALES COMPONENTES DE .NET El framework .NET es un conjunto de componentes que interactúan entre sí y que al mismo tiempo brindan soporte al desarrollador de software y al software mismo creado bajo esta plataforma. Los principales componentes del Microsoft .NET Framework son el CLR o Common Language Runtime (Lenguaje Común de Ejecución) y la Base Class Library (Librería de Clases Base): 



Common Language Runtime (Lenguaje Común de Ejecución): este componente es el que ejecuta las aplicaciones. Es el componente más cercano al sistema operativo y es el encargado de procesar el código creado para transformarlo en código que pueda ser ejecutado e interpretado por el sistema operativo donde se esté intentando ejecutar el programa. Librería de Clases Base (Base Class Library): contiene gran cantidad de código común al que podemos acceder desde el código que se cree para una aplicación. La librería de clases facilita funcionalidad para diferentes tareas que de otra forma nos veríamos forzados a crear por cuenta propia. Por ejemplo, si una aplicación necesita leer un archivo del disco duro de una computadora, no es necesario escribir el código que se encargue de navegar por los diferentes sectores del disco en busca del archivo en cuestión, esta lógica ya se encuentra encapsulada dentro de la librería de clases base disponible para su uso.

1.4. GRUPOS DE PRODUCTOS DE .NET La plataforma .NET consiste principalmente en 4 grupos: Herramientas de desarrollo y librerías: un conjunto de lenguajes como C#, J# y Visual Basic .NET, un conjunto de herramientas como Visual Studio .NET, una librería de clases para desarrollar servicios web y aplicaciones de escritorio y el Common Language Runtime (CLR). Servicios web: una variedad de servicios web comerciales que los desarrolladores pueden utilizar para construir aplicaciones que lo requieran. Servidores especializados: un conjunto de servidores empresariales como SQL Server Exchange Server, Servidores BizTalk, etc. Estos proveen funcionalidades especializadas para almacenamiento de datos, email y comercio B2B (Business-to-business). Dispositivos: más allá de los computadores personales, la plataforma .NET llega a dispositivos como teléfonos celulares, tabletas y consolas de videojuegos.


7

2 .NET FRAMEWORK El .NET Framework es una infraestructura de desarrollo y ejecución de software que provee una nueva interfaz de programación para servicios Windows y API (Application Programming Interfaces), e integra un número de tecnologías que surgieron de Microsoft durante los años 90. El framework se posiciona sobre una gran variedad de sistemas operativos basados en Windows y consiste en varios componentes. .NET es básicamente una aplicación de sistema que corre en entorno Windows y su componente más importante es el CLR, el que constituye la parte central del framework.

2.1 LA PLATAFORMA .NET La plataforma .NET consiste principalmente en 5 componentes. En la capa más baja se encuentra el sistema operativo. Por sobre esta capa se halla un conjunto de productos de servidor especializados que disminuyen los tiempos de desarrollo de aplicaciones de gran tamaño. En estos productos se incluyen: Application Center, BizTalk Server, Commerce Server, Exchange Server, entre otros. Dado que los servicios web son ampliamente reutilizables, Microsoft provee una serie de servicios llamados oficialmente .NET SERVICES, que los desarrolladores pueden usar mediante un pago mensual. Dos ejemplos de estos servicios son .NET Passport y .NET Alerts .NET Passport permite utilizar un nombre de usuario y contraseña para todos sitios web que soporten autenticación Passport. En la capa superior de la plataforma .NET se encuentra una herramienta de desarrollo llamada Visual Studio .NET, la cual hace posible el desarrollo rápido de servicios web y otras aplicaciones. El sucesor de Visual Studio 6.0 es Visual Studio .NET, un entorno de desarrollo integrado o IDE que soporta 4 diferentes lenguajes de programación, un depurador de código y un manejador de XML. Y en el centro de .NET se encuentra el framework de .NET, que es una infraestructura que funciona en tiempo de ejecución y que revoluciona por completo el desarrollo de aplicaciones en entorno Windows. El framework de .NET incluye el CLR y librerías de clases que pueden ser usadas por todos los lenguajes de la plataforma.

2.2 METAS DE DISEÑO Una de las principales ventajas de .NET es que unifica los modelos de programación, bibliotecas de funcionalidad y entornos de ejecución que existían anteriormente para distintos tipos de aplicaciones y distintos dispositivos.


8

Antes de .NET existían lenguajes, bibliotecas, entornos de ejecución y herramientas de desarrollo distintas y específicas para cada tipo de aplicación y dispositivo (Visual Basic, Visual C++, ASP/VBScript, Embedded Visual C++, etc.). .NET unifica todos esos modelos de programación ofreciendo una única API, un único entorno de ejecución, un único conjunto de bibliotecas y una única herramienta de desarrollo para cualquier tipo de aplicación.

2.2.1 INFRAESTRUCTURA DE COMPONENTES Antes de la llegada de la tecnología COM, los desarrolladores no tenían una manera estándar de integrar librerías binarias sin hacer referencias o alterar el código fuente. El Modelo de Objeto de Componentes o COM (Component Object Model) es una tecnología desarrollada por Microsoft en 1993, que hizo posible la interacción entre procesos y la creación de objetos de forma dinámica para todos los lenguajes de programación que trabajen con dicho modelo. Con la llegada de COM, se logró la integración binaria de componentes en las aplicaciones de forma similar a como funcionan los dispositivos de hardware Plug-and-Play en un PC de escritorio. A pesar de que COM fue una tecnología muy útil en su tiempo, contaba con algunos detalles problemáticos. Si bien permitía integrar componentes binarios desarrollados en cualquier lenguaje, requería seguir la identidad, tiempo de vida y reglas binarias de este. Estos inconvenientes producían una reescritura constante de código muy similar, la cual .NET se preocupó de resolver. En .NET, todas las clases están listas para ser usadas a nivel binario. Ya no es necesario escribir código extra para integración de componentes en el framework de .NET. Solo es requerido escribir una clase en .NET que se convierte en parte del ensamblado y con esto es suficiente para incorporar los componentes. Además de proveer un framework para hacer el desarrollo más simple, .NET elimina la dificultad de desarrollar componentes COM. Para ser precisos, .NET elimina el uso de registro de componentes y prescinde de la necesidad de escribir complejas líneas de código para hacer uso de estos (Thai y Lam, 2003).

2.2.2 INTEGRACIÓN DE LENGUAJES COM soporta independencia de lenguajes, por lo que se pueden desarrollar componentes COM en cualquier lenguaje de programación provisto por la plataforma. Siempre y cuando sigan todas las especificaciones COM, dichos componentes pueden ser instalados y usados por las


9

aplicaciones que lo requieran. Sin embargo, a pesar de que a través de esta tecnología se pueden reutilizar componentes binarios, COM no soporta integración de lenguajes. En otras palabras, no se puede reutilizar el código dentro de un componente COM desarrollado por otra persona, no se puede extender el uso de las clases contenidas en dichos componentes, y no se pueden recuperar excepciones lanzadas por el código del componente. Con Microsoft .NET se pueden desarrollar componentes COM en cualquier lenguaje, por lo que se pueden derivar clases internas de estos, capturar excepciones y usar polimorfismo a través de múltiples lenguajes. El framework de .NET lo hace posible gracias una especificación llamada Common Type System (CTS) o Sistema de Tipo Común. Por ejemplo, en .NET todo es un objeto de una clase específica que deriva de una clase raíz llamada System.Object. CTS soporta los conceptos generales de clases interfaces y delegados, tipos de referencia y tipos de valores. Las clases base de .NET proveen la mayor parte de los tipos básicos de sistema como aquellos que soportan los enteros, string y manipulación de archivos. Dado que cada compilador de lenguaje debe cumplir un mínimo de especificaciones, diferentes lenguajes pueden ser usados en la misma aplicación (Thai y Lam, 2003).

2.2.3 DESARROLLO SIMPLIFICADO En el pasado, cada vez que se requería desarrollar aplicaciones usando un compilador diferente, el desarrollador debía aprender una nueva API o librería de clases ya que no existía consistencia entre las distintas librerías o interfaces. .NET resuelve este problema aportando una serie de clases de framework que todos los lenguajes usan. Dicho framework elimina la necesidad de aprender una nueva API cada vez que se cambia de un lenguaje a otro (Thai y Lam, 2003).

2.2.4 REUSABILIDAD Con excepción de C++, en Microsoft .NET cada clase deriva de la clase padre de todas las clases, Object, la cual soporta algunos aspectos básicos como devolver la representación en string de un objeto o indicar si un objeto es igual a otro. El CLR debe reconocer y verificar cada tipo antes de ser cargado y ejecutado. Esto reduce la posibilidad de errores de programación rudimentarios y previene sobrecargas de la memoria, lo cual puede ser una debilidad de la seguridad. Los lenguajes de programación tradicionales no proveen un mecanismo común para el manejo de errores. C++ y Java soportan manejo de errores, pero muchos otros lo dejan en manos del programador haciendo que estos deban implementar sus propias formas de manejar los errores. Microsoft .NET soporta el manejo de errores desde el CLR, aportando un mecanismo consistente


10

de manejo de errores. En otras palabras, las excepciones en .NET funcionan a través de todos los lenguajes que soporta. Al programar en C++, el desarrollador debe asignar todos los objetos bases que han sido instanciados. Si esto no se realiza, todos los recursos asignados en memoria no serán liberados aunque ya no sean necesarios, y si se tratara de una aplicación de servidor, no será lo suficientemente robusta dada la alta acumulación de recursos de memoria en desuso que eventualmente podrían llevar abajo al sistema. .NET hace un rastreo de todos estos recursos y los libera cuando ya no son necesarios.

2.2.5 SEGURIDAD Antes de la aparición de .NET a principios de 2002, al trabajar bajo el sistema operativo DOS, los desarrolladores se preocupaban poco por la seguridad debido a que sus aplicaciones funcionaban en una sola computadora y bajo un solo hilo de procesamiento. Tan pronto como las aplicaciones cliente-servidor se volvieron comunes, las cosas comenzaron a complicarse: muchos usuarios teniendo acceso a los sistemas y manejando intercambios de información sensible entre cliente y servidor. Este problema se tornó aun más complejo con la llegada de las aplicaciones web, dado que, sin saberlo, se podían descargar y ejecutar applets (componentes de una aplicación que se ejecutan en el contexto de otro programa) con intenciones maliciosas. Para resolver este problema, .NET provee una serie de características relevantes. Windows Server protege los recursos usando listas de control de acceso y seguridad de identidad, pero no provee una forma de verificar la seguridad de partes específicas del código que se ejecuta. A diferencia de la forma de seguridad tradicional que protege únicamente el acceso a los ejecutables, .NET va más allá y verifica el acceso a diferentes partes del código ejecutado. Esto se conoce como “seguridad de acceso al código”. Por ejemplo, para hacer uso de esta infraestructura de seguridad, se pueden declarar en las implementaciones de métodos atributos de seguridad sin necesidad de escribir ninguna línea de código. En pocas palabras, .NET provee funcionalidades de seguridad para hacer mucho más difícil que agentes maliciosos penetren en las aplicaciones (Thai y Lam, 2 003).

2.3 EVENTOS Y EL CONTROL DE EVENTOS EN .NET FRAMEWORK Todo programa recibe retroalimentación de usuarios o de otros programas a través de los eventos. Estos son una parte importante de la programación en .NET. Sin la implementación de eventos las aplicaciones .NET no tienen forma de responder a las acciones externas que ocurren cuando, por ejemplo, el usuario presiona una tecla o hace clic con el ratón sobre un botón en un formulario. Si bien es cierto que .NET soporta varios lenguajes de programación, como por ejemplo C++, C# y ASP.NET, entre otros, en este curso nos enfocaremos en la programación en Visual Basic.NET.


11

2.3.1 FUNCIONAMIENTO DEL CONTROLADO POR EVENTOS

MODELO

DE

PROGRAMACIÓN

Un evento es una señal que comunica a una aplicación que ha sucedido algo importante. Por ejemplo, cuando un usuario hace clic en un control de un formulario, el formulario puede provocar un evento clic y llamar a un procedimiento que controla el evento. Los eventos también permiten que las tareas separadas se comuniquen. Por ejemplo, suponga que una aplicación realiza una tarea de ordenación independientemente de la aplicación principal. Si un usuario cancela la ordenación, la aplicación puede enviar un evento de cancelación que ordene la detención del proceso de ordenación (Microsoft Developer Network, 2016). Los eventos y los delegados están estrechamente asociados en Visual Basic .NET.. Se implementan mediante delegados, una forma de puntero de función orientado a objetos que permite invocar una función indirectamente mediante una referencia a la función. Lo primero que se debe hacer para crear un evento es definirlo (implementarlo en código fuente), asignarle un nombre, los parámetros que usará y cada uno debe tener un delegado asociado. El método que hará la intercepción del evento debe tener la misma cantidad y mismos tipos de parámetros que el evento creado para poder funcionar. Los eventos se declaran en clases, estructuras, módulos e interfaces mediante la palabra clave Event, como se muestra en el siguiente ejemplo: Ev ent

Var i abl eDi f er ent eaCer o ( By Val

Var i abl e1 As St r i ng)

2.3.2 CONTROLADORES DE EVENTOS Cuando se ejecuta un evento lo que ocurre es que se llama a los métodos asociados a este y lo usual es que los métodos se encuentren definidos en clases distintas a la que define al evento. Método a ejecutar por acción del evento: Sub cli_ VariableDiferenteaCero( ByVal Variable1 As Integer, ByVal Variable2 As Integer)

En el siguiente código se expresa cómo definir y generar un evento: Public Class Prueba


12

Public Event VariableDiferenteaCero( Integer, ByVal Variable2 As Integer)

ByVal

Variable1

As

Private valor As Integer Public Property Valor() As integer Get Return valor End Get Set(ByVal Valor2 As String) If Valor2 <> 0 Then RaiseEvent Valor2)

VariableDiferenteaCero

(Valor1,

End If Valor1 = Valor2 End Set End Property End class

Para poder interceptar el informe de que se ha generado un evento, es necesario definir un método que contenga una firma igual al evento definido y que por lo tanto tenga la misma cantidad de parámetros y que estos sean del mismo tipo. Al ejecutarse la instrucción RaiseEvent, todos los métodos que hayan sido asociados con el evento recibirán la alerta y para esto se requiere asociar los métodos con el evento que deben manejar. Existen varias maneras de hacerlo: la más sencilla es declarar el objeto donde está definido el evento con la instrucción WithEvent y usando la instrucción Handles a continuación de la declaración del método, y luego el objeto y el nombre del evento que debe manejar.

Private WithEvents prueba As Prueba Sub Main() prueba = New Prueba prueba.Valor= 1 End Sub


13

Private Sub prueba_VariableDiferenteaCero(ByVal Valor1 As Integer, ByVal Valor2 As Integer) Handles prueba.VariableDiferenteaCero Console.WriteLine(“El valor es distinto de cero”)

End Sub

El uso de WithEvent no puede usarse para declarar un objeto dentro de una propiedad o método, es decir, no se puede usar de forma local ni para declarar arreglos. En estos casos se debe utilizar la palabra AddHandler junto con AddressOf de la siguiente manera: AddHandler prueba. VariableDiferenteaCero, AddressOf prueba_VariableDiferenteaCero El argumento de AddHandler indica el objeto y el evento a interceptar y en el argumento de AddressOf el método que ha de interceptarlo. Esto se realizará cada vez que instanciemos un objeto de la clase que define el evento.

2.3.3 GENERACIÓN DE EVENTOS La instrucción a utilizar para ejecutar un evento es “RaiseEvent” . A esta instrucción se le debe

indicar el nombre del evento que debe accionar y las variables que serán usadas como parámetros de este: RaiseEvent VariableDiferenteaCero (Valor1, Valor2)

2.3.4 IMPLEMENTACIÓN DE DELEGADOS La inclusión o definición de delegados en Visual Basic .NET no es obligatoria como lo son otros lenguajes, como por ejemplo en C#, dado que el compilador se encargará de crearlos por sí solo. Aun así, se tiene la opción de definirlos. La ventaja que trae esto es ahorrarle trabajo al compilador, ya que si no definimos un delegado y tenemos una serie de eventos con la misma firma (igual cantidad de parámetros del mismo tipo) el compilador creará tantos delegados como eventos se declaren. Si lo que se requiere es tener varios eventos con igual firma, se puede declarar un delegado y asociarlo con cada uno de los eventos: Public Delegate Sub VariableDiferenteaCeroEventHandler (ByVal Valor1 As Integer, ByVal Valor 2 As Integer)


14

Y los eventos se declaran como el tipo de ese delegado: Public Event VariableDiferenteaCero as VariableDiferenteaCeroEventHandler Public Event OtraVariableDiferenteaCero as VariableDiferenteaCeroEventHandler.

2.4 ARQUITECTURA DEL FRAMEWORK El componente más importante del framework de .NET es el CLR o Common Lenguaje Runtime, o en castellano “Lenguaje Común de Ejecución”. El CLR maneja y ejecuta el código escrito en los lenguajes de .NET. Es la base de la arquitectura de .NET de igual forma como lo es la máquina virtual de Java para Java. El CLR es el encargado de activar objetos, realizar verificaciones de seguridad en ellos, ejecutarlos y eliminarlos de la memoria cuando se requiera. La siguiente imagen ilustra la arquitectura de Microsoft .NET, desde los lenguajes de programación soportados (nivel superior), hasta el contacto con el sistema operativo (nivel inferior) (Iacono, 2011). C++

VB

C#

JScript

Common Language Specification ASP.NET Web Forms Web Services

Windows Forms

ADO.NET y XML

Librería de Clases Base

Common Language Runtime

Sistema Operativo


15

2.4.1 COMMON LANGUAGE RUNTIME (CLR) El CLR de .NET es un ambiente que trabaja en tiempo de ejecución. Cuando se escribe código a través de un compilador de .NET, genera lo que podría definirse como código administrado. Esto significa que el CLR se encarga de administrar la integración entre los distintos lenguajes de la plataforma, controla las excepciones entre lenguajes, la seguridad, entre otros. Los archivos ejecutables generados en .NET tienen características distintas a los ejecutables tradicionales. Están compuestos no solamente de líneas de código y datos, sino que además contienen metadatos con descripción de los tipos, los miembros y referencias del código. Un archivo ejecutable de .NET debe ajustarse a las especificaciones PE (Portable Executable File) que definen el formato del archivo. Los sistemas operativos Windows saben cómo cargar y ejecutar un .EXE o una DLL (Dynamic Link Library, o en castellano “Librería de Vínculos Dinámicos”) porque comprenden la estructura de un archivo PE. El CLR utiliza estos metadatos para localizar y cargar clases, activar instancias en la memoria, invocar métodos, escribir código nativo, etc. El CLR hace que el diseño de componentes y aplicaciones con objetos desarrollados en distintos lenguaje sea más simple y permite integrar su comportamiento. Una clase escrita, por ejemplo usando C#, puede ser derivada utilizando Visual Basic .NET o ejecutar un método que se encuentre creado en la misma. Esta integración se puede realizar dado que los compiladores hacen uso de tipos comunes que son definidos por el motor en tiempo de ejecución. En la Tabla 1 podemos ver una lista de algunos de los mecanismos implementados por el CLR y que ayudan a la ejecución de las aplicaciones. Tabla 1. Algunos de los mecanismos implementados por el CLR TIPO Compilación Just In Time

Manejo de la memoria

Manejo de excepciones

Acceso a la metadata

DESCRIPCIÓN La compilación JIT (Just in Time) hace referencia a la capacidad de compilar partes de código MSIL (Microsoft Intermedia Language) de acuerdo con la necesidad de uso de este. La búsqueda de espacio libre en la memoria, así como su limpieza es tarea del CLR. Dentro de los procesos que se ejecutan para mantener la estabilidad del uso de memoria, podemos encontrar el GC (Garbage Collector o Recolector de Basura). El CLR se encarga de manejar los posibles errores que las aplicaciones en ejecución pudieran arrojar. Esto previene que cualquier error no controlado se propague a todo el sistema operativo. Parte de la información que se incluye en el código compilado es información de sí mismo. Métodos y funciones, propiedades, así como


16

Gestión de seguridad de código

información sobre seguridad y otros acompañan a los programas. Es posible por tanto consultar esta información para manipularla. La ejecución de las aplicaciones .NET no queda librada al azar. Es posible definir reglas de ejecución que van a actuar sobre las aplicaciones creadas con Microsoft .NET impidiendo la ejecución de aquellas que no cuenten con autorización, o restringiendo el acceso a ciertos recursos según sea necesario.

2.4.1.1 FUNCIONAMIENTO DE CLR Al compilar una aplicación o librería usando CLR, el compilador escribe un código fuente basado en un lenguaje intermedio denominado MSIL o Microsoft Intermediate Language (o solamente IL), siendo estas una serie de instrucciones distintas a las que entiende directamente la CPU pero que pueden ser traducidas a un código descifrable para el procesador de forma muy rápida. Para que el sistema pueda ejecutar código MSIL debe primero convertirlo al lenguaje específico del procesador a través de un compilador llamado JIT (Just In Time), o en castellano “Justo en el Momento”, y de esta manera puede ser ejecutado en equipos diferentes con arquitecturas distintas. El CLR es lo suficientemente inteligente para convertir en tiempo de ejecución solo el código necesario para ejecutar las funciones requeridas en el momento, guardando el resto del código MSIL en memoria para que esté disponible en llamadas posteriores. Una de las principales ventajas de trabajar bajo Microsoft .NET es que este motor de ejecución es el que se encargará de, por ejemplo, gestionar la memoria, su uso, así como su liberación (Iacono, 2011).

2.4.2 LENGUAJES SOPORTADOS Visual Basic .NET Visual C# .NET Visual C++ .NET Extensiones administradas de C++ Transact-SQL


17

Lenguajes de secuencias. Windows Scripting Host VBScript JScript JScript .NET XML Visual J++ Lenguajes alternativos: 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12.

COBOL para Microsoft .NET. Perl para Microsoft .NET. Eiffel para Microsoft .NET. Python para Microsoft .NET. Pascal para Microsoft .NET. Mercury para Microsoft .NET. Mondrian para Microsoft .NET. Oberon para Microsoft .NET. Salford FTN95 (Fortran) para Microsoft .NET. SmallTalk para Microsoft .NET. ML estándar para Microsoft .NET. Dyalog APL para Microsoft .NET.

COMENTARIO FINAL Después de analizar el contenido visto en esta clase, es más factible entender el aporte que tienen todos los componentes y herramientas que posee la plataforma .NET en el desarrollo de aplicaciones. Las metas de diseño fueron importantes aportes para afrontar el desarrollo de grandes y pequeñas aplicaciones bajo el contexto de la industria del software, que en la actualidad demanda instrumentos de desarrollo que simplifiquen el trabajo de los programadores. Si la construcción de programas de computadora continuara siguiendo el modelo tradicional de programación, el desarrollo de software llevaría mucho más trabajo y no sería capaz de aportar la seguridad, fiabilidad y escalabilidad que hoy en día demanda la industria del software.


18

REFERENCIAS BIBLIOGRÁFICAS. Thai, T. y Lam, H. (2003). .NET Framework Essentials . 3.ª edición. California, Estados Unidos O'Reilly Media, Inc. Kimmel, P. (2002). Visual Basic® .NET Unleashed . Indianapolis, Estados Unidos. Sams. Iacono, M. (2011 ). Programador .NET . 1.ª edición. Buenos Aires, Argentina. Fox Andina. Irby, B. (2012). Reengineering .NET . California, Estados Unidos. Addison-Wesley Professional. Microsoft Developer Network. (2016). Controlar y provocar eventos. Recuperado desde https://msdn.microsoft.com/es-es/library/edzehd2t%28v=vs.110%29.aspx


19

PARA REFERENCIAR ESTE DOCUMENTO, CONSIDERE: IACC (2016). Introducción a Microsoft .NET . Programación .NET - I. Semana 1.


20


21

Francisco Pacheco Control 1

Recommend Documents