Los fundamentos de .NET para el desarrollo de aplicaciones modernas

Introducción a .NET

.NET es una plataforma de desarrollo libre y de código abierto creada por Microsoft, que permite construir distintos tipos de aplicaciones: web, móviles, de escritorio, videojuegos, IoT y cloud. Es un ecosistema completo que ofrece a los desarrolladores las herramientas necesarias para crear aplicaciones modernas, eficientes y seguras.

¿Por qué elegir .NET?

• Polivalencia: desarrolla para Windows, Linux, macOS, iOS, Android y más
• Rendimiento: optimizado para la velocidad y el consumo de recursos
• Seguridad: actualizaciones frecuentes y funcionalidades de seguridad integradas
• Código abierto: proyecto de código abierto respaldado por Microsoft y una comunidad activa
• Ecosistema rico: numerosas bibliotecas y herramientas de calidad

Instalación y configuración

Instalar el SDK de .NET

El SDK (Software Development Kit) de .NET es necesario para desarrollar aplicaciones .NET.

Windows:

# Descargar desde el sitio oficial
https://dotnet.microsoft.com/download

macOS (con Homebrew):

brew install --cask dotnet-sdk

Linux (Ubuntu):

wget https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
sudo apt-get update
sudo apt-get install -y apt-transport-https
sudo apt-get install -y dotnet-sdk-6.0

Verificar la instalación

dotnet --version

Los conceptos fundamentales

Los lenguajes de programación

.NET admite varios lenguajes de programación, siendo los más populares:

• C#: el lenguaje principal, orientado a objetos y de tipado fuerte
• F#: un lenguaje funcional para programas más concisos
• Visual Basic .NET: una versión modernizada de Visual Basic

Estructura de un proyecto .NET

Un proyecto .NET suele contener los siguientes elementos:

• Archivo .csproj / .fsproj / .vbproj: configuración del proyecto
• Program.cs: punto de entrada de la aplicación
• Carpetas: Models, Controllers, Views (para las aplicaciones web), Services, etc.
• appsettings.json: configuración de la aplicación

Crear un nuevo proyecto

# Crear una aplicación de consola
dotnet new console -n MonApplication

# Crear una aplicación web ASP.NET Core
dotnet new webapp -n MonAppWeb

# Crear una API web
dotnet new webapi -n MonAPI

El lenguaje C#

Variables y tipos de datos

// Tipos básicos
int nombre = 42;
double prix = 19.99;
bool estActif = true;
string nom = "Jean Dupont";
char lettre = 'A';

// Colecciones
int[] nombres = { 1, 2, 3, 4, 5 };
List<string> noms = new List<string> { "Alice", "Bob", "Charlie" };
Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Alice", 30 },
    { "Bob", 25 }
};

Estructuras de control

// Condiciones
if (age >= 18)
{
    Console.WriteLine("Majeur");
}
else
{
    Console.WriteLine("Mineur");
}

// Switch
switch (jour)
{
    case "Lundi":
        Console.WriteLine("Début de semaine");
        break;
    case "Vendredi":
        Console.WriteLine("Bientôt le weekend");
        break;
    default:
        Console.WriteLine("Un autre jour");
        break;
}

// Bucles
for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

foreach (var nom in noms)
{
    Console.WriteLine(nom);
}

while (compteur > 0)
{
    Console.WriteLine(compteur);
    compteur--;
}

Funciones y métodos

// Método simple
void AfficherMessage(string message)
{
    Console.WriteLine(message);
}

// Método con retorno
int Additionner(int a, int b)
{
    return a + b;
}

// Método con parámetros opcionales
void Configurer(string nom, int age = 18, bool estActif = true)
{
    // ...
}

// Método de extensión
public static class StringExtensions
{
    public static bool EstPalindrome(this string texte)
    {
        string inverse = new string(texte.Reverse().ToArray());
        return texte.Equals(inverse, StringComparison.OrdinalIgnoreCase);
    }
}

Programación orientada a objetos en C#

Clases y objetos

// Definición de una clase
public class Personne
{
    // Propiedades
    public string Nom { get; set; }
    public string Prenom { get; set; }
    public int Age { get; set; }
    
    // Constructor
    public Personne(string nom, string prenom, int age)
    {
        Nom = nom;
        Prenom = prenom;
        Age = age;
    }
    
    // Método
    public string ObtenirNomComplet()
    {
        return $"{Prenom} {Nom}";
    }
}

// Uso
Personne personne = new Personne("Dupont", "Jean", 30);
Console.WriteLine(personne.ObtenirNomComplet());

Herencia

public class Employe : Personne
{
    public string Poste { get; set; }
    public decimal Salaire { get; set; }
    
    public Employe(string nom, string prenom, int age, string poste, decimal salaire)
        : base(nom, prenom, age)
    {
        Poste = poste;
        Salaire = salaire;
    }
    
    public void AugmenterSalaire(decimal pourcentage)
    {
        Salaire += Salaire * (pourcentage / 100);
    }
}

Interfaces

public interface IPayable
{
    decimal CalculerPaiement();
}

public class Consultant : Personne, IPayable
{
    public decimal TarifHoraire { get; set; }
    public int HeuresTravaillees { get; set; }
    
    public Consultant(string nom, string prenom, int age, decimal tarifHoraire)
        : base(nom, prenom, age)
    {
        TarifHoraire = tarifHoraire;
    }
    
    public decimal CalculerPaiement()
    {
        return TarifHoraire * HeuresTravaillees;
    }
}

ASP.NET Core para el desarrollo web

ASP.NET Core es un framework web eficiente, multiplataforma y de código abierto para construir aplicaciones web modernas.

Estructura de una aplicación web ASP.NET Core

MonAppWeb/
├── Controllers/     # Controladores MVC o de API
├── Models/          # Clases de modelos
├── Views/           # Vistas Razor (para MVC)
├── wwwroot/         # Archivos estáticos (CSS, JS, imágenes)
├── appsettings.json # Configuración de la aplicación
├── Program.cs       # Punto de entrada
└── Startup.cs       # Configuración de los servicios y del pipeline

Crear una API REST sencilla

// Controllers/PersonnesController.cs
[ApiController]
[Route("api/[controller]")]
public class PersonnesController : ControllerBase
{
    private static List<Personne> _personnes = new List<Personne>
    {
        new Personne { Id = 1, Nom = "Dupont", Prenom = "Jean", Age = 30 },
        new Personne { Id = 2, Nom = "Martin", Prenom = "Sophie", Age = 25 }
    };
    
    [HttpGet]
    public ActionResult<IEnumerable<Personne>> Get()
    {
        return _personnes;
    }
    
    [HttpGet("{id}")]
    public ActionResult<Personne> Get(int id)
    {
        var personne = _personnes.Find(p => p.Id == id);
        if (personne == null)
            return NotFound();
            
        return personne;
    }
    
    [HttpPost]
    public ActionResult<Personne> Post(Personne personne)
    {
        personne.Id = _personnes.Max(p => p.Id) + 1;
        _personnes.Add(personne);
        return CreatedAtAction(nameof(Get), new { id = personne.Id }, personne);
    }
}

Razor Pages para vistas sencillas

// Pages/Index.cshtml.cs
public class IndexModel : PageModel
{
    public List<Personne> Personnes { get; set; }
    
    public void OnGet()
    {
        Personnes = new List<Personne>
        {
            new Personne { Id = 1, Nom = "Dupont", Prenom = "Jean", Age = 30 },
            new Personne { Id = 2, Nom = "Martin", Prenom = "Sophie", Age = 25 }
        };
    }
}

<!-- Pages/Index.cshtml -->
@page
@model IndexModel
@{
    ViewData["Title"] = "Liste des personnes";
}

<h1>Liste des personnes</h1>

<table class="table">
    <thead>
        <tr>
            <th>ID</th>
            <th>Prénom</th>
            <th>Nom</th>
            <th>Âge</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var personne in Model.Personnes)
        {
            <tr>
                <td>@personne.Id</td>
                <td>@personne.Prenom</td>
                <td>@personne.Nom</td>
                <td>@personne.Age</td>
            </tr>
        }
    </tbody>
</table>

Entity Framework Core para el acceso a datos

Entity Framework Core es un ORM (Object-Relational Mapping) que permite interactuar con una base de datos utilizando objetos C#.

Configuración básica

// Models/Personne.cs
public class Personne
{
    public int Id { get; set; }
    public string Nom { get; set; }
    public string Prenom { get; set; }
    public int Age { get; set; }
}

// Data/ApplicationDbContext.cs
public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
    
    public DbSet<Personne> Personnes { get; set; }
}

// Program.cs
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

Operaciones CRUD sencillas

// Services/PersonneService.cs
public class PersonneService
{
    private readonly ApplicationDbContext _context;
    
    public PersonneService(ApplicationDbContext context)
    {
        _context = context;
    }
    
    public async Task<List<Personne>> ObtenirToutesAsync()
    {
        return await _context.Personnes.ToListAsync();
    }
    
    public async Task<Personne> ObtenirParIdAsync(int id)
    {
        return await _context.Personnes.FindAsync(id);
    }
    
    public async Task AjouterAsync(Personne personne)
    {
        _context.Personnes.Add(personne);
        await _context.SaveChangesAsync();
    }
    
    public async Task MettreAJourAsync(Personne personne)
    {
        _context.Entry(personne).State = EntityState.Modified;
        await _context.SaveChangesAsync();
    }
    
    public async Task SupprimerAsync(int id)
    {
        var personne = await _context.Personnes.FindAsync(id);
        if (personne != null)
        {
            _context.Personnes.Remove(personne);
            await _context.SaveChangesAsync();
        }
    }
}

Buenas prácticas en .NET

Arquitectura en capas

Una estructura clásica de una aplicación .NET:

1. Capa de presentación: UI, API, etc.
2. Capa de aplicación: servicios, lógica de negocio
3. Capa de dominio: entidades, lógica de negocio esencial
4. Capa de infraestructura: acceso a datos, servicios externos

Inyección de dependencias

// Registro de los servicios en Program.cs
builder.Services.AddScoped<IPersonneService, PersonneService>();
builder.Services.AddScoped<IPersonneRepository, PersonneRepository>();

// Uso en un controlador
public class PersonnesController : ControllerBase
{
    private readonly IPersonneService _personneService;
    
    public PersonnesController(IPersonneService personneService)
    {
        _personneService = personneService;
    }
    
    // ...
}

Pruebas unitarias

// Tests/PersonneServiceTests.cs
public class PersonneServiceTests
{
    [Fact]
    public async Task ObtenirToutesAsync_RetourneToutesLesPersonnes()
    {
        // Arrange
        var mockRepository = new Mock<IPersonneRepository>();
        mockRepository.Setup(repo => repo.ObtenirToutesAsync())
            .ReturnsAsync(new List<Personne>
            {
                new Personne { Id = 1, Nom = "Dupont", Prenom = "Jean" },
                new Personne { Id = 2, Nom = "Martin", Prenom = "Sophie" }
            });
            
        var service = new PersonneService(mockRepository.Object);
        
        // Act
        var resultat = await service.ObtenirToutesAsync();
        
        // Assert
        Assert.Equal(2, resultat.Count);
    }
}

.NET en la nube

Azure y .NET

Azure ofrece un excelente soporte para las aplicaciones .NET:

• Azure App Service: despliegue sencillo de aplicaciones web
• Azure Functions: funciones serverless
• Azure SQL Database: base de datos SQL compatible con Entity Framework
• Azure Storage: almacenamiento en la nube (blobs, tablas, colas)

Docker y .NET

# Dockerfile
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["MonApp.csproj", "./"]
RUN dotnet restore "MonApp.csproj"
COPY . .
RUN dotnet publish "MonApp.csproj" -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MonApp.dll"]

Recursos para seguir aprendiendo

• Documentación oficial: docs.microsoft.com/dotnet
• Microsoft Learn: learn.microsoft.com
• GitHub .NET: github.com/dotnet
• Canal de YouTube de .NET: youtube.com/dotnet

Conclusión

.NET es una plataforma madura, eficiente y en constante evolución que ofrece un excelente entorno de desarrollo para crear aplicaciones modernas. Su polivalencia permite apuntar a distintas plataformas y desarrollar diversos tipos de aplicaciones, desde la web hasta el móvil, pasando por el escritorio y la nube. Al dominar estos fundamentos, dispones de una base sólida para explorar con mayor profundidad las posibilidades que ofrece el ecosistema .NET.