Documentos de Académico
Documentos de Profesional
Documentos de Cultura
NET
INTEGRANTES:
- Carrasco Purisaca Juan.
- Huaman Rafael David.
- Rodríguez Castillo Julio Braulio.
15 DE MAYO DE 2018
UNIVERSIDAD NACIONAL PEDRO RUIZ GALLO.
ING. DE COMPUTACION E INFORMATICA.
Contenido
Plataforma .NET. ........................................................................................................................ 2
1. CLR - Common Language Runtime .................................................................................... 5
2. CLS - Common Language Specification ............................................................................. 6
3. BCL - Base Class Library ..................................................................................................... 7
.NET Framework ........................................................................................................................ 7
1. Características de Common Language Runtime ............................................................... 9
2. Biblioteca de clases de .NET Framework......................................................................... 10
Microsoft Visual Studio ............................................................................................................ 11
1. Versiones ......................................................................................................................... 11
2. Historia ............................................................................................................................ 12
2.1. Visual Studio 6.0 ...................................................................................................... 12
2.2. Visual Studio .NET (2002) ........................................................................................ 12
2.3. Visual Studio .NET 2003........................................................................................... 13
2.4. Visual Studio 2005 ................................................................................................... 13
2.5. Visual Studio 2008 ................................................................................................... 14
2.6. Visual Studio 2010 ................................................................................................... 14
2.7. Visual Studio 2012 ................................................................................................... 14
2.8. Visual Studio 2013 ................................................................................................... 14
2.9. Visual Studio 2015 ................................................................................................... 15
2.10. Visual Studio 2017 ............................................................................................... 15
Ensamblado (Microsoft .NET) ................................................................................................. 15
Conclusión.................................................................................................................................. 16
Bibliografía ................................................................................................................................ 16
1
Plataforma .NET.
.NET es un proyecto de Microsoft para crear una nueva plataforma de desarrollo de software
con énfasis en transparencia de redes, con independencia de plataforma y que permita un
rápido desarrollo de aplicaciones. Basado en esta plataforma, Microsoft intenta desarrollar una
estrategia horizontal que integre todos sus productos, desde el Sistema Operativo hasta las
herramientas de mercado.
A largo plazo Microsoft pretende reemplazar el API Win32 o Windows API con la plataforma
.NET. Esto debido a que el API Win32 o Windows API fue desarrollada sobre la marcha,
careciendo de documentación detallada, uniformidad y cohesión entre sus distintos
componentes, provocando múltiples problemas en el desarrollo de aplicaciones para el sistema
operativo Windows. La plataforma .NET pretende solventar la mayoría de estos problemas
proveyendo un conjunto único y expandible con facilidad, de bloques interconectados,
diseñados de forma uniforme y bien documentados, que permitan a los desarrolladores tener a
mano todo lo que necesitan para producir aplicaciones sólidas.
Debido a las ventajas que la disponibilidad de una plataforma de este tipo puede darle a las
empresas de tecnología y al público en general, muchas otras empresas e instituciones se han
unido a Microsoft en el desarrollo y fortalecimiento de la plataforma .NET, ya sea por medio de
la implementación de la plataforma para otros sistemas operativos aparte de Windows
(Proyecto Mono de Ximian/Novell para Linux/MacOS X/BSD/Solaris), el desarrollo de lenguajes
de programación adicionales para la plataforma (ANSI C de la Universidad de
Princeton, NetCOBOL de Fujitsu, Delphi de Borland, entre otros) o la creación de bloques
adicionales para la plataforma (como controles, componentes y bibliotecas de clases
adicionales); siendo algunas de ellas software libre, distribuibles ciertas bajo la licencia GPL.
Con esta plataforma Microsoft incursiona de lleno en el campo de los Servicios Web y establece
el XML como norma en el transporte de información en sus productos y lo promociona como tal
en los sistemas desarrollados utilizando sus herramientas.
.NET intenta ofrecer una manera rápida y económica pero a la vez segura y robusta de
desarrollar aplicaciones – o como la misma plataforma las denomina, soluciones – permitiendo
a su vez una integración más rápida y ágil entre empresas y un acceso más simple y universal a
todo tipo de información desde cualquier tipo de dispositivo.
Bajo el nombre .NET Framework o Marco de trabajo .NET se encuentran reunidas una serie de
normas impulsadas por varias compañías además de Microsoft (como Hewlett-Packard , Intel,
IBM, Fujitsu Software, Plum Hall, la Universidad de Monash e ISE), entre las cuales se
encuentran:
La norma que define las reglas que debe seguir un lenguaje de programación para ser
considerado compatible con el marco de trabajo .NET (ECMA-335, ISO/IEC 23271).
Por medio de esta norma se garantiza que todos los lenguajes desarrollados para la plataforma
ofrezcan al programador un conjunto mínimo de funcionalidad, y compatibilidad con todos los
demás lenguajes de la plataforma.
2
Este es el lenguaje insignia del marco de trabajo .NET, y pretende reunir las ventajas de
lenguajes como C/C++ y Visual Basic en un solo lenguaje.
Tal vez el más importante de los componentes de la plataforma, esta norma define un conjunto
funcional mínimo que debe implementarse para que el marco de trabajo sea soportado por un
sistema operativo. Aunque Microsoft implementó esta norma para su sistema operativo
Windows, la publicación de la norma abre la posibilidad de que sea implementada para cualquier
otro sistema operativo existente o futuro, permitiendo que las aplicaciones corran sobre la
plataforma independientemente del sistema operativo para el cual haya sido implementada. El
Proyecto Mono emprendido por Ximian pretende realizar la implementación de la norma para
varios sistemas operativos adicionales bajo el marco del software libre o código abierto.
Debido a la publicación de la norma para la infraestructura común de lenguajes (CLI por sus
siglas en inglés), el desarrollo de lenguajes se facilita, por lo que el marco de trabajo
.NET soporta ya más de 20 lenguajes de programación y es posible desarrollar cualquiera de los
tipos de aplicaciones soportados en la plataforma con cualquiera de ellos, lo que elimina las
diferencias que existían entre lo que era posible hacer con uno u otro lenguaje.
Algunos de los lenguajes desarrollados para el marco de trabajo .NET son: C#, Visual Basic,
Delphi (Object Pascal), C++, J#, Perl, Python, Fortran y Cobol.NET.
El CLR es el verdadero núcleo del Framework de .NET, entorno de ejecución en el que se cargan
las aplicaciones desarrolladas en los distintos lenguajes, ampliando el conjunto de servicios del
sistema operativo (W2k y W2003).
Para ejecutarse se necesita un segundo paso, un compilador JIT (Just-In-Time) es el que genera
el código máquina real que se ejecuta en la plataforma del cliente.
La compilación JIT la realiza el CLR a medida que el programa invoca métodos, el código
ejecutable obtenido, se almacena en la memoria caché del ordenador, siendo recompilado de
nuevo sólo en el caso de producirse algún cambio en el código fuente.
La Biblioteca de Clases Base (BCL por sus siglas en inglés) maneja la mayoría de las operaciones
básicas que se encuentran involucradas en el desarrollo de aplicaciones, incluyendo entre otras:
3
Administración de memoria.
Cifrado de datos.
Transmisión y recepción de datos por distintos medios (XML, TCP/IP).
Administración de componentes Web que corren tanto en el servidor como en el cliente
(ASP.NET).
Manejo y administración de excepciones.
Manejo del sistema de ventanas.
Herramientas de despliegue de gráficos (GDI+).
Herramientas de seguridad e integración con la seguridad del sistema operativo.
Manejo de tipos de datos unificado.
Interacción con otras aplicaciones.
Manejo de cadenas de caracteres y expresiones regulares.
Operaciones aritméticas.
Manipulación de fechas, zonas horarias y periodos de tiempo.
Manejo de arreglos de datos y colecciones.
Manipulación de archivos de imágenes.
Aleatoriedad.
Generación de código.
Manejo de idiomas.
Auto descripción de código.
Interacción con el API Win32 o Windows API.
Compilación de código.
Los ensamblados son ficheros con forma de EXE o DLL que contienen toda la funcionalidad de
la aplicación de forma encapsulada.
El diagrama siguiente muestra los bloques conceptuales en los que se divide la plataforma .NET:
4
Aunque se trata de un esquema muy simplificado, ya que hay muchos otros componentes que
se construyen por encima de esta base y forman también parte de la plataforma, es un esquema
igualmente útil para entender qué es la plataforma y en qué "piezas" se basa.
El funcionamiento del CLR no es trivial, trabaja encima del sistema operativo para aislar a la
plataforma de éste. Su funcionamiento es muy parecido, para entendernos, al hipervisor de
una máquina virtual. Esto le permite ejecutar aplicaciones .NET multiplataforma. Hoy en día es
posible desarrollar aplicaciones .NET para diversas plataformas, como por ejemplo Windows,
iOS, Android o Linux.
El CLR nos garantiza también la seguridad de los tipos de datos, avalando que no se producen
errores en la conversión de tipos en la ejecución de una aplicación .NET. Este aspecto y algunos
otros vienen regulados por lo que se conoce el Common Type System (CTS) o Sistema Común
de Tipos de datos.
El CTS define los tipos de datos de .NET y las construcciones de programación de los lenguajes
que el CLR puede utilizar de forma adecuada y correcta. En otras palabras, el CTS es lo más
parecido a las reglas de juego que permiten el correcto entendimiento entre diferentes
lenguajes de programación y el propio entorno de ejecución de .NET.
5
Adicionalmente, el CLR se encarga también de gestionar la vida de los objetos, declaraciones y
recursos a lo largo de la ejecución de una aplicación .NET. Esto se lleva a cabo a través de lo que
se conoce como recolector de basura o garbage collector. Por lo tanto, a la hora de programar
no debemos preocuparnos de reservar espacio de memoria para ejecutar nuestra aplicación
.NET. Ni tampoco de liberar los recursos del sistema una vez finaliza la ejecución de la aplicación.
El CLR se encarga de ello y nos exime de esta responsabilidad, facilitando el desarrollo
enormemente frente a otros lenguajes "tradicionales" como C/C++.
Entre estos lenguajes de programación destacan Visual Basic ó C#, pero existen
implementaciones muy variadas, como por ejemplo Cobol (¡Guau!).
Lo mejor de todo es que, como decíamos en el apartado anterior, cualquier componente creado
con uno de estos lenguajes puede ser utilizado de forma transparente desde cualquier otro
lenguaje .NET. Además, como ya se ha comentado también, es posible ejecutar el código .NET
en diferentes plataformas y sistemas operativos.
La especificación del lenguaje común o CLS está formada por un conjunto de reglas que deben
ser seguidas por las definiciones de tipos de datos. Así, dichos datos pueden interactuar desde
una aplicación escrita en un lenguaje
determinado con otra aplicación escrita en otro
lenguaje diferente.
6
Para evitar este tipo de problemas y poder gestionar de forma eficiente y segura el acceso a la
memoria, el CLS define un conjunto de tipos de datos comunes (Common Type System o
CTS) que indica qué tipos de datos se pueden manejar, cómo se declaran y se utilizan éstos y
de qué forma se deben gestionar durante la ejecución.
Cada una de estas bibliotecas puede contener a su vez numerosas clases que aglutinan varios
métodos y funciones con características concretas.
De esta manera, podemos encontrar bibliotecas con funcionalidades para casi cualquier cosa
que necesitemos: enviar correos electrónicos, escribir archivos de texto, acceder a fuentes de
datos, manejar información,
criptografía, etc...
.NET Framework
.NET Framework es una tecnología que admite la compilación y ejecución de la última
generación de aplicaciones y Servicios web XML. El diseño de .NET Framework está enfocado a
cumplir los objetivos siguientes:
7
Ofrecer un entorno de ejecución de código que promueva la ejecución segura del
mismo, incluso del creado por terceras personas desconocidas o que no son de plena
confianza.
Proporcionar un entorno de ejecución de código que elimine los problemas de
rendimiento de los entornos en los que se utilizan scripts o intérpretes de comandos.
Ofrecer al programador una experiencia coherente entre tipos de aplicaciones muy
diferentes, como las basadas en Windows o en Web.
Basar toda la comunicación en estándares del sector para asegurar que el código de
.NET Framework se puede integrar con otros tipos de código.
.NET Framework consta de dos componentes principales: Common Language Runtime (CLR) y la
biblioteca de clases de .NET Framework. Common Language Runtime es el fundamento de .NET
Framework. El tiempo de ejecución se puede considerar como un agente que administra el
código en tiempo de ejecución y proporciona servicios centrales, como la administración de
memoria, la administración de subprocesos y la comunicación remota, al tiempo que aplica una
seguridad de tipos estricta y otras formas de especificación del código que promueven su
seguridad y solidez. De hecho, el concepto de administración de código es un principio básico
del motor en tiempo de ejecución. El código destinado al tiempo de ejecución se denomina
código administrado, a diferencia del resto de código, que se conoce como código no
administrado. La biblioteca de clases es una colección completa orientada a objetos de tipos
reutilizables que se pueden emplear para desarrollar aplicaciones que abarcan desde las
tradicionales herramientas de interfaz gráfica de usuario (GUI) o de línea de comandos hasta las
aplicaciones basadas en las innovaciones más recientes proporcionadas por ASP.NET, como
formularios Web Forms y Servicios web XML.
Por ejemplo, ASP.NET hospeda el motor en tiempo de ejecución para proporcionar un entorno
de servidor escalable para el código administrado. ASP.NET trabaja directamente con el tiempo
de ejecución para habilitar aplicaciones de ASP.NET y Servicios web XML, que se tratan más
adelante en este tema.
8
En las secciones siguientes se describen con más detalle las características principales de .NET
Framework.
Además, el entorno administrado del motor en tiempo de ejecución elimina muchos problemas
de software comunes. Por ejemplo, el motor en tiempo de ejecución controla automáticamente
la disposición de los objetos, administra las referencias a éstos y los libera cuando ya no se
utilizan.Esta administración automática de la memoria soluciona los dos errores más comunes
de las aplicaciones: la fuga de memoria y las referencias no válidas a la memoria.
9
Además, el motor en tiempo de ejecución aumenta la productividad del programador. Por
ejemplo, los desarrolladores pueden crear aplicaciones en el lenguaje que prefieran y seguir
sacando todo el provecho del tiempo de ejecución, la biblioteca de clases y los componentes
escritos en otros lenguajes por otros colegas. El proveedor de un compilador puede elegir
destinarlo al motor en tiempo de ejecución. Los compiladores de lenguajes que se destinan a
.NET Framework hacen que las características de .NET Framework estén disponibles para el
código existente escrito en dicho lenguaje, lo que facilita enormemente el proceso de migración
de las aplicaciones existentes.
Aunque el motor en tiempo de ejecución está diseñado para el software del futuro, también es
compatible con el software actual y el software antiguo. La interoperabilidad entre el código
administrado y no administrado permite que los desarrolladores continúen utilizando los
componentes COM y las DLL que necesiten.
El motor en tiempo de ejecución está diseñado para mejorar el rendimiento. Aunque Common
Language Runtime proporciona muchos servicios estándar de motor en tiempo de ejecución, el
código administrado nunca se interpreta. Una característica denominada compilación JIT (Just-
In-Time) permite ejecutar todo el código administrado en el lenguaje de máquina nativo del
sistema en el que se ejecuta. Mientras tanto, el administrador de memoria evita que la memoria
se pueda fragmentar y aumenta la zona de referencia de la memoria para mejorar aún más el
rendimiento.
Como en cualquier biblioteca de clases orientada a objetos, los tipos de .NET Framework
permiten realizar diversas tareas de programación comunes, como son la administración de
cadenas, recolección de datos, conectividad de bases de datos y acceso a archivos. Además de
estas tareas habituales, la biblioteca de clases incluye tipos adecuados para diversos
escenarios de desarrollo especializados. Use .NET Framework para desarrollar los siguientes
tipos de aplicaciones y servicios:
Aplicaciones de consola.
Aplicaciones de GUI de Windows (Windows Forms).
10
Aplicaciones de Windows Presentation Foundation (WPF).
Aplicaciones ASP.NET.
Servicios de Windows.
Aplicaciones orientadas a servicios mediante Windows Communication Foundation
(WCF).
Aplicaciones habilitadas para el flujo de trabajo mediante Windows Workflow
Foundation (WF).
Las clases de Windows Forms son un conjunto completo de tipos reutilizables que simplifican
enormemente el desarrollo de GUI para Windows. Si escribe una aplicación de formularios
Web Forms de ASP.NET, puede usar las clases de formularios Web Forms.
Visual Studio permite a los desarrolladores crear sitios y aplicaciones web, así como servicios
web en cualquier entorno que soporte la plataforma .NET (a partir de la versión .NET 2002). Así,
se pueden crear aplicaciones que se comuniquen entre estaciones de trabajo, páginas web,
dispositivos móviles, dispositivos embebidos y consolas, entre otros.
1. Versiones
A partir de la versión 2005, Microsoft ofrece gratuitamente las Ediciones Express, que son
versiones básicas separadas por lenguajes de programación o plataforma enfocadas a
estudiantes y programación amateur. Estas ediciones son iguales que el entorno de desarrollo
comercial, pero sin características avanzadas de integración. Dichas ediciones son:
Visual InterDev
Visual J++
Visual FoxPro
11
2. Historia
2.1. Visual Studio 6.0
Se lanzó en 1998 y fue la última versión en ejecutarse en la plataforma Win9x. Los números de
versión de todas las partes constituyentes pasaron a 6.0, incluyendo Visual J++ y Visual InterDev,
que se encontraban en las versiones 1.1 y 1.0 respectivamente. Esta versión fue la base para el
sistema de desarrollo de Microsoft para los siguientes cuatro años, en los que Microsoft migró
su estrategia de desarrollo al .NET Framework.
Visual Studio 6.0 fue la última versión en que Visual Basic se incluía de la forma en que se conocía
hasta entonces; versiones posteriores incorporarían una versión muy diferente del lenguaje con
muchas mejoras, fruto de la plataforma .NET. También supuso la última versión en incluir Visual
J++, que proporcionaba extensiones de la plataforma Java, lo que lo hacía incompatible con la
versión de Sun Microsystems. Esto acarreó problemas legales a Microsoft, y se llegó a un
acuerdo en el que Microsoft dejaba de comercializar herramientas de programación que
utilizaran la máquina virtual Java.
Aunque el objetivo a largo plazo de Microsoft era unificar todas las herramientas en un único
entorno, esta versión en realidad añadía un entorno más a Visual Studio 5.0: Visual J++ y Visual
Interdev se separaban del entorno de Visual C++, al tiempo que Visual FoxPro y Visual Basic
seguían manteniendo su entorno específico.
Visual Studio .NET 2002 supuso también la introducción del lenguaje C#, un lenguaje nuevo
diseñado específicamente para la plataforma .NET, basado en C++ y Java. Se presentó también
el lenguaje J# (sucesor de J++), el cual, en lugar de ejecutarse en una máquina virtual Java, se
ejecuta únicamente en el framework .NET. El lenguaje Visual Basic fue remodelado
completamente y evolucionó para adaptarse a las nuevas características de la plataforma .NET,
haciéndolo mucho más versátil y dotándolo con muchas características de las que carecía. Algo
similar se llevó a cabo con C++, añadiendo extensiones al lenguaje llamadas Managed
Extensions for C++ con el fin de que los programadores pudieran crear programas en .NET. Por
otra parte, Visual FoxPro pasa a comercializarse por separado.
Todos los lenguajes se unifican en un único entorno. La interfaz se mejora notablemente en esta
versión, siendo más limpia y personalizable.
Visual Studio .NET puede usarse para crear programas basados en Windows (usando Windows
Forms en vez de COM), aplicaciones y sitios web (ASP.NET y servicios web), y dispositivos
móviles (usando el .NET Compact Framework).
12
Esta versión requiere un sistema operativo basado en NT. La versión interna de Visual Studio
.NET es la 7.0.
Visual Studio 2003 se lanza en cuatro ediciones: Academic, Professional, Enterprise Developer y
Enterprise Architect. La edición Enterprise Architect incluía una implementación de la tecnología
de modelado Microsoft Visio, que se centraba en la creación de representaciones visuales de la
arquitectura de la aplicación basadas en UML. También se introdujo "Enterprise Templates",
para ayudar a grandes equipos de trabajo a estandarizar estilos de programación e impulsar
políticas de uso de componentes y asignación de propiedades.
Microsoft lanzó el Service Pack 1 para Visual Studio 2003 el 13 de septiembre de 2006.
La versión interna de Visual Studio .NET 2003 es la 7.1, aunque el formato del archivo que
emplea es el de la 8.0.
La actualización más importante que recibieron los lenguajes de programación fue la inclusión
de tipos genéricos, similares en muchos aspectos a las plantillas de C++. Con esto se consigue
encontrar muchos más errores en la compilación en vez de en tiempo de ejecución, incitando a
usar comprobaciones estrictas en áreas donde antes no era posible. C++ tiene una actualización
similar con la adición de C++/CLI como sustituto de C# manejado.
Se incluye un diseñador de implantación, que permite que el diseño de la aplicación sea validado
antes de su implantación. También se incluye un entorno para publicación web y pruebas de
carga para comprobar el rendimiento de los programas bajo varias condiciones de carga.
Visual Studio 2005 también añade soporte para arquitecturas de 64 bits. Aunque el entorno de
desarrollo sigue siendo una aplicación de 32 bits, Visual C++ 2005 soporta compilación para x86-
64 (AMD64, Intel 64) e IA-64 (Itanium). El SDK incluye compiladores de 64 bits, así como
versiones de 64 bits de las librerías.
Visual Studio 2005 tiene varias ediciones radicalmente distintas entre sí: Express, Standard,
Professional, Tools for Office y cinco ediciones Visual Studio Team System. Estas últimas se
proporcionaban conjuntamente con suscripciones a MSDN cubriendo los cuatro principales
roles de la programación: Architects, Software Developers, Testers y Database Professionals. La
funcionalidad combinada de las cuatro ediciones Team System se ofrecía como la edición Team
Suite. Por otra parte, Tools for the Microsoft Office System está diseñada para extender la
funcionalidad a Microsoft Office.
13
Las ediciones Express se han diseñado para principiantes, aficionados y pequeños negocios,
todas disponibles gratuitamente a través de la página de Microsoft.4 Se incluye una edición
independiente para cada lenguaje: Visual Basic, Visual C++, Visual C#, Visual J# para
programación .NET en Windows y Visual Web Developer para la creación de sitios web ASP.NET.
Las ediciones Express carecen de algunas herramientas avanzadas de programación, así como
de opciones de extensibilidad.
La versión interna de Visual Studio 2005 es la 8.0, mientras que el formato del archivo que
emplea es el de la 9.0.
Las ventanas de documentos tales como el editor de código y la ventana de la vista diseño ahora
pueden colocarse fuera de la ventana IDE. Por ejemplo, puede arrastrar el editor de código en
el IDE de modo que se puede ver la ventana de la vista de diseño al lado.
14
.NET Framework 4.0
.NET Framework 4.5
.NET Framework 4.5.1
.NET Framework 4.5.2
La compatibilidad es la misma que en Visual Studio 2015, salvo que se agregan algunas
funciones extra.
15
Un ensamblado puede consistir en uno o más archivos. Los archivos de código son llamados
módulos. Un ensamblado puede contener más de un módulo de código y es posible utilizar
diferentes lenguajes en los diferentes módulos para crear el ensamblado de .NET. Visual Studio,
sin embargo, no permite utilizar diferentes lenguajes en un ensamblado, por lo que la
compilación de ensamblados con varios lenguajes debe ser realizada desde la consola de
comandos.
Por buenas prácticas de desarrollo se acostumbra ubicar una única clase en cada archivo del
ensamblado, pero cabe recordar que un módulo, un archivo, puede contener varias clases
dentro de él, aunque no es recomendable.
Los ensamblados pueden tener diferentes decoradores que definen el entorno de ejecución de
los mismos: COM+, DCOM, Remoting, etc.
Conclusión.
La plataforma .NET está formada por una serie de componentes que, en conjunto, permiten la
creación de todo tipo de aplicaciones en todo tipo de sistemas operativos y utilizando todo tipo
de lenguajes de programación.
Bibliografía
aprendenetframework.net. (s.f.). Obtenido de
https://aprendenetframework.wordpress.com/2011/12/05/que-es-un-ensamblado-
en-net/
16