INGENIERÍA EN SISTEMAS

DESARROLLO DE SISTEMAS 1

Tema: Actividad 3

Estudiante:

Jamyl Zurita Pilinco

Docente:

Hugo Arnaldo Guzman Centellas

08 de noviembre del 2024 –Santa Cruz - Bolivia

Contenido
Introducción ................................................................................................................................. 3
PREGUNTAS .............................................................................................................................. 4
1. El Framework .NET ............................................................................................................... 4
2. Arquitectura del Framework .NET ....................................................................................... 4
3. Características del Framework .NET .................................................................................. 5
4. El Common Language Runtime (CLR) ............................................................................... 6
5. Just-In-Time Compilation (JIT) ............................................................................................. 6
ejemplo de como: ....................................................................................................................... 7
• Implementar servicios y componentes del framework .................................................. 7
Ejemplo: Implementación de un Servicio Simple en .NET ........................................... 7
Resultado ............................................................................................................................. 9
• Administrar los diferentes servicios y librerías del framework. ..................................... 9
Ejemplo: Administrar Múltiples Servicios en .NET ........................................................ 9
MAPA MENTAL ........................................................................................................................ 12
BIBLIOGRAFÍA: ........................................................................................................................ 13
Introducción
.NET Framework proporciona una plataforma de desarrollo integral que permite
a los programadores crear aplicaciones eficientes, seguras y escalables dentro
de diversos sistemas operativos, particularmente en sistemas Windows. Desde
su introducción en 2002 por parte de Microsoft, se ha expandido para ayudar en
aplicaciones de escritorio, móviles, web y basadas en la nube, convirtiéndose en
un elemento básico en la creación de soluciones web empresariales y
contemporáneas.

También viene con un montón de herramientas comunes en BCL para

desarrolladores. Además, fomenta la compatibilidad entre diversas tecnologías
y lenguajes, agilizando el desarrollo y mantenimiento de aplicaciones en diversos
entornos.

Uno de los atributos más destacables de .NET Framework es su capacidad para

administrar servicios y partes mediante inyección de dependencia (DI). Esta
función permite la modularización y reutilización dentro de las aplicaciones,
optimizando su administración y ampliando su funcionalidad. Al adoptar este
método, resulta factible gestionar varios y múltiples componentes, como saludos
y despedidas, en una oración continua de una manera eficaz y estructurada.

Este documento examina la estructura de .NET Framework, las características

esenciales y la utilización de sus servicios y componentes, complementados con
ejemplos prácticos para la integración de aplicaciones.

.
PREGUNTAS

1. El Framework .NET
.NET Framework es una plataforma de desarrollo integral creada por Microsoft
para facilitarle la creación y ejecución de aplicaciones en un entorno Windows.
Desde su lanzamiento en 2002, ha seguido evolucionando, permitiendo a los
desarrolladores crear aplicaciones seguras, escalables y de alto rendimiento. El
marco proporciona una infraestructura común para ejecutar y administrar
aplicaciones en todos los dispositivos y plataformas. .NET incluye herramientas
para administrar interfaces de usuario, acceso a bases de datos y redes, lo que
permite a los desarrolladores integrar servicios y aplicaciones web que se
comunican de manera confiable y eficiente con la red. También es la base
sobre la cual Microsoft avanza en su ecosistema de aplicaciones comerciales y
empresariales, lo que lo hace relevante en el desarrollo de soluciones
tecnológicas modernas.

2. Arquitectura del Framework .NET

La arquitectura .NET se basa en componentes clave que permiten ejecutar y
administrar aplicaciones. Estos elementos son los siguientes:

Common Language Runtime (CLR): CLR es el motor de ejecución de .NET

responsable de administrar aspectos clave como la memoria, la seguridad y el
manejo de excepciones. Con un modelo de ejecución común, CLR permite a
los desarrolladores combinar múltiples lenguajes de programación en una sola
aplicación, proporcionando un sistema de ejecución unificado.

Biblioteca de clases base (BCL): BCL es un conjunto de bibliotecas de clases

estándar que cubren la funcionalidad básica. Desde la manipulación de
archivos hasta la recopilación de datos. Esto simplifica el desarrollo porque los
desarrolladores no tienen que crear código desde cero para realizar tareas
comunes.
Lenguajes de programación soportados: .NET soporta múltiples lenguajes, los
más populares son C#, VB.NET y F#. Esto brinda a los desarrolladores la
flexibilidad de utilizar el lenguaje que mejor se adapte a sus
necesidades.Aproveche el poder de .NET.

La arquitectura .NET es modular y extensible, lo que la hace ideal para

aplicaciones empresariales que requieren una infraestructura confiable y de
alto rendimiento.

3. Características del Framework .NET

.NET ofrece una variedad de características que lo hacen popular entre los
desarrolladores:

Interoperabilidad: .NET permite a los desarrolladores integrar su código con

bibliotecas y aplicaciones escritas en otros lenguajes, como C++ y COM. Esto
simplifica la reutilización del código y la integración con sistemas heredados.

Compatibilidad: con la llegada de .NET Core, la plataforma obtiene soporte

multiplataforma, lo que le permite ejecutar aplicaciones en Windows, Linux y
macOS, así como crear aplicaciones empresariales. Aplicaciones en diferentes
entornos.

Seguridad: .NET implementa un sólido modelo de seguridad basado en permisos

y reglas de seguridad. Además, utiliza autenticación y autorización integradas
para garantizar que solo los usuarios autorizados tengan acceso a los recursos
críticos.
Administración de memoria: incluye recolección automática de basura para
administrar la asignación y liberación de memoria, lo que ayuda a evitar pérdidas
de memoria y mejorar la eficiencia del rendimiento general. aplicación.

Extensibilidad: .NET es altamente extensible y se puede integrar con nuevas

tecnologías mediante API y bibliotecas externas.Permite a los desarrolladores
crear aplicaciones más complejas de forma modular.

4. El Common Language Runtime (CLR)

Common Language Runtime (CLR) es el núcleo de .NET Framework. Actúa
como un entorno de ejecución que proporciona un conjunto de servicios clave:

Administración de memoria: el CLR utiliza un recolector de basura para

administrar automáticamente la memoria, liberando memoria ocupada por
objetos no utilizados, optimizando el uso de recursos y mejorando el rendimiento.

Seguridad: CLR proporciona un entorno de ejecución de código seguro y

controlado que impone restricciones de seguridad y garantiza que el código
malicioso no pueda dañar aplicaciones o sistemas.

Soporte de múltiples idiomas: A Debido a la compatibilidad de idiomas, CLR

permite el uso de diferentes lenguajes de programación. , como C# y F#, en una
única aplicación para garantizar que todos los componentes funcionen sin
problemas.

5. Just-In-Time Compilation (JIT)

La compilación justo a tiempo (JIT) es una función CLR avanzada que convierte
código intermedio .NET (lenguaje intermedio de Microsoft o MSIL) en código de
máquina nativo en tiempo de ejecución. Esto proporciona varios beneficios:
Optimización del rendimiento: cuando el código se compila en tiempo de
ejecución, JIT ajusta las transformaciones en función de las características
específicas del sistema en el que se ejecuta, lo que hace que las aplicaciones
.NET sean más rápidas y eficientes en el uso del hardware disponible. .

\Uso más eficiente de los recursos: la compilación JIT solo convierte el código
necesario en el momento adecuado, lo que permite que el resto del código
conserve el formato MSIL cuando sea necesario, ahorrando memoria y recursos.

Este proceso de compilación justo a tiempo es fundamental para la velocidad y

la eficiencia. Aplicaciones .NET, especialmente en sistemas con hardware muy
variable.

ejemplo de como:

• Implementar servicios y componentes del framework

Ejemplo: Implementación de un Servicio Simple en .NET

Supongamos que queremos implementar un servicio que saluda al usuario y

luego lo utiliza en un controlador para mostrar el saludo.

Paso a Paso

1. Crear el Servicio: Creamos un servicio simple llamado GreetingService

que devolverá un mensaje de saludo.

public class GreetingService

public string GetGreeting()

return "¡Hola, bienvenido a nuestra aplicación!";

 }

Configurar el Servicio en Program.cs: En el archivo Program.cs, registramos el

servicio GreetingService para que pueda ser utilizado en cualquier parte de la
aplicación.

var builder = WebApplication.CreateBuilder(args);

// Registrar el servicio GreetingService

builder.Services.AddSingleton<GreetingService>();

var app = builder.Build();

Usar el Servicio en un Controlador o Ruta: Ahora, podemos usar GreetingService

en cualquier parte de la aplicación. Aquí, lo usaremos en una ruta simple para
mostrar el saludo.

app.MapGet("/greeting", (GreetingService greetingService) =>

return greetingService.GetGreeting();

});

app.Run();

¿Cómo Funciona?
  El Servicio: GreetingService es un servicio simple que contiene un método
GetGreeting que devuelve un mensaje de saludo.
 Inyección de Dependencias: Al registrar GreetingService con
AddSingleton, se garantiza que solo se creará una instancia de este
servicio durante la vida útil de la aplicación. Luego, .NET inyecta
automáticamente esta instancia donde sea necesario (en este caso, en la
ruta /greeting).
 Ruta: Cuando accedes a http://localhost:5000/greeting, la aplicación
utiliza el servicio GreetingService para obtener el mensaje de saludo y
devolverlo.

Resultado

 Al abrir http://localhost:5000/greeting, verás el mensaje: ¡Hola, bienvenido

a nuestra aplicación!

Un ejemplo sencillo y básico de cómo implementar un servicio y usarlo en una

aplicación .NET, aprovechando la inyección de dependencias para facilitar su
reutilización en diferentes partes de la aplicación.

• Administrar los diferentes servicios y librerías del framework.

Ejemplo: Administrar Múltiples Servicios en .NET

Imagina que estamos creando una aplicación que tiene dos servicios: un servicio
de Saludo y un servicio de Despedida. Vamos a administrarlos usando inyección
de dependencias para que se puedan usar en cualquier parte de la aplicación.

Paso a Paso

1. Crear los Servicios: Primero, definimos dos servicios simples,

GreetingService y FarewellService, que devuelven mensajes de saludo y
despedida.

csharp
Copiar código
public class GreetingService
 {
public string GetGreeting() => "¡Hola, bienvenido a nuestra aplicación!";
}

public class FarewellService

{
public string GetFarewell() => "¡Adiós, gracias por visitar nuestra
aplicación!";
}

2. Configurar los Servicios en Program.cs: Registramos ambos servicios

para que estén disponibles en toda la aplicación. Esto se hace en
Program.cs.

csharp
Copiar código
var builder = WebApplication.CreateBuilder(args);

// Registrar los servicios en el contenedor de dependencias

builder.Services.AddSingleton<GreetingService>();
builder.Services.AddSingleton<FarewellService>();

var app = builder.Build();

3. Usar los Servicios en la Aplicación: Ahora, podemos inyectar estos

servicios en nuestros controladores o directamente en las rutas.

csharp
Copiar código
// Ruta que usa el servicio de saludo
app.MapGet("/greeting", (GreetingService greetingService) =>
{
return greetingService.GetGreeting();
});
 // Ruta que usa el servicio de despedida
app.MapGet("/farewell", (FarewellService farewellService) =>
{
return farewellService.GetFarewell();
});

app.Run();

¿Cómo Funciona?

 Inyección de Dependencias: Cuando registramos GreetingService y

FarewellService con AddSingleton, estos servicios se crean una vez y se
reutilizan en toda la aplicación. Esto significa que puedes acceder a ellos
sin tener que crearlos manualmente en cada uso.
 Uso de los Servicios: Al acceder a las rutas /greeting y /farewell, cada ruta
llama al servicio correspondiente para obtener el mensaje.

Resultado

 Cuando accedes a http://localhost:5000/greeting, ves el mensaje de

saludo: ¡Hola, bienvenido a nuestra aplicación!
 Cuando accedes a http://localhost:5000/farewell, ves el mensaje de
despedida: ¡Adiós, gracias por visitar nuestra aplicación!

Este ejemplo básico demuestra cómo administrar múltiples servicios en .NET,

manteniendo el código limpio y organizado usando inyección de dependencias.
MAPA MENTAL
BIBLIOGRAFÍA:
 Hejlsberg, A., Wiltamuth, S., & Golde, P. (2008). The C# Programming
Language. Addison-Wesley Professional.
 Joseph, A. (2014). Advanced .NET Framework Programming. O’Reilly
Media.