3️⃣ Fundamentos Avanzados de C#

Permiten crear clases y métodos reutilizables con tipos dinámicos pero seguros.

class Caja<T>
{
    public T Valor { get; set; }
}

Uso:

Caja<int> cajaEntero = new Caja<int>();
Caja<string> cajaTexto = new Caja<string>();

También puedes agregar restricciones:

class Repositorio<T> where T : class
{
}

Base de LINQ y programación moderna en C#.

Func<int, int> cuadrado = x => x * x;
Console.WriteLine(cuadrado(5));

Tipos comunes:

Func<> → devuelve valor

Action<> → no devuelve valor

Predicate<> → devuelve bool

Consultas complejas:

var resultado = personas
    .Where(p => p.Edad > 18)
    .OrderBy(p => p.Nombre)
    .GroupBy(p => p.Ciudad);

También puede escribirse como consulta tipo SQL:

var adultos = from p in personas
              where p.Edad > 18
              select p;

Permite ejecutar múltiples tareas al mismo tiempo.

using System.Threading;

Thread hilo = new Thread(() =>
{
    Console.WriteLine("Hilo en ejecución");
});

hilo.Start();

Más moderno:

Task.Run(() => Console.WriteLine("Tarea en segundo plano"));

Conceptos clave:

* Thread
* Task
* Parallel
* lock
* ConcurrentDictionary

Uso real en APIs:

public async Task<string> ObtenerDatosAsync()
{
    using HttpClient client = new HttpClient();
    return await client.GetStringAsync("https://api.ejemplo.com");
}

Debes entender:

* async
* await
* Task
* Task<T>
* Deadlocks
* ConfigureAwait

Usados en frameworks como Entity Framework.

Expression<Func<int, bool>> expr = x => x > 5;

Permiten construir código dinámicamente.

Permite inspeccionar clases en tiempo de ejecución.

Type tipo = typeof(Persona);
var propiedades = tipo.GetProperties();

Se usa en:

* Inyección de dependencias
* Serialización
* Frameworks

Principio clave en arquitectura limpia.

Ejemplo simple:

interface IServicio
{
    void Ejecutar();
}

class Servicio : IServicio
{
    public void Ejecutar()
    {
        Console.WriteLine("Ejecutando...");
    }
}

Se inyecta en constructor:

class Controlador
{
    private readonly IServicio _servicio;

    public Controlador(IServicio servicio)
    {
        _servicio = servicio;
    }
}

Muy usado en ASP.NET Core.

Debes conocer:

🔹 Singleton

🔹 Repository

🔹 Factory

🔹 MVC

🔹 Dependency Injection

🔹 Unit of Work

Ejemplo Singleton:

class Configuracion
{
    private static Configuracion instancia;

    private Configuracion() {}

    public static Configuracion Instancia
    {
        get
        {
                if (instancia == null)
                instancia = new Configuracion();
            return instancia;
        }
    }
}

En proyectos reales se trabaja con:

* Capas (Presentation, Application, Domain, Infrastructure)
* Clean Architecture
* SOLID
* Microservicios
* APIs REST
* ORM (como Entity Framework)
* Testing (xUnit, NUnit)

* Records
* Pattern Matching
* Nullable Reference Types
* Span<T>
* Memory<T>
* ValueTask
* Minimal APIs
* Top-level statements

Ejemplo Record:

public record Persona(string Nombre, int Edad);

Un desarrollador avanzado en C# domina:

* Genéricos
* LINQ avanzado
* Multithreading
* Async/await profundo
* Reflection
* DI
* Patrones de diseño
* Arquitectura limpia
* Frameworks como ASP.NET Core
* Entity Framework