C# Generics

List<int> numbers = [1, 2, 3];
List<string> strings = ["a", "b", "c"];

List<object> objects = ["a", 4];

void TypeChecker<T>(T value)
{
    Console.WriteLine("Type: " + typeof(T));
    Console.WriteLine("Value: " + value);
}

record PersonRecord(string firstName, string lastName);
TypeChecker(new PersonRecord("fn", "ln");

public class BetterList<T>
{
    private List<T> data = new();

    public void AddToList(T value)
    {
        data.Add(value);
        Console.WriteLine($"{value} has been added to the list");
    }
}

BetterList<int> betterNumbers = new();
betterNumbers.AddToList(5);

BetterList<PersonRecord> people = new();
betterNumbers.AddToList(new PersonRecord("fn", "ln"));

public interface IImportance<T>
{
    T MostImportant(T a, T b);
}

public class EvaluateImportance : IImportance<int>, IImportance<string>
{
    public int MostImportant(int a, int b)
    {
        ...
    }

    public string MostImportant(string a, string b)
    {
        ...
    }
}

// Constraints: new() -> this class must have an empty constructor
public class SomeClass<T> where T : new()
{
}

// Constraints: class -> this class must be of type class
public class SomeClass<T> where T : class
{
}

// Constraints: class? -> this class must a nullable class
public class SomeClass<T> where T : class?
{
}

// Constraints: notnull-> this class must not be null
public class SomeClass<T> where T : notnull
{
}

// Constraints: BetterList<T>-> this class must be of BetterList class
public class SomeClass<T> where T : BetterList<T>
{
}

// Constraints: The class can be of 2 types and they 
// need to be the same or u derived from T
public class SomeClass<T, U> where T : U
{
}

// Constraints: T has to be INumber
// The operation x+y can be implementer, only because T is INumber
// Otherwise you can't use + between 2 objects.
public class SomeClass<T> where T : INumber<T>
{
    public T Add(T x, T y)
    {
        return x+y;
    }
}

public interface IRepository<T> where T : class
{
    IEnumerable<T> GetAll();
    T GetById(int id);
    void Add(T entity);
    void Update(T entity);
    void Delete(int id);
}

public class Repository<T> : IRepository<T> where T : class
{
    private readonly DbContext _context;
    private readonly DbSet<T> _dbSet;

    public Repository(DbContext context)
    {
        _context = context;
        _dbSet = context.Set<T>();
    }

    public IEnumerable<T> GetAll()
    {
        return _dbSet.ToList();
    }

    public T GetById(int id)
    {
        return _dbSet.Find(id);
    }

    public void Add(T entity)
    {
        _dbSet.Add(entity);
        _context.SaveChanges();
    }

    public void Update(T entity)
    {
        _dbSet.Update(entity);
        _context.SaveChanges();
    }

    public void Delete(int id)
    {
        var entity = _dbSet.Find(id);
        if (entity != null)
        {
            _dbSet.Remove(entity);
            _context.SaveChanges();
        }
    }
}

var productRepository = new Repository<Product>(dbContext);
var orderRepository = new Repository<Order>(dbContext);

public class ServiceResponse<T>
{
    public T Data { get; set; }
    public bool Success { get; set; } = true;
    public string Message { get; set; } = string.Empty;

    public ServiceResponse() { }

    public ServiceResponse(T data)
    {
        Data = data;
    }
}

public ServiceResponse<Product> GetProductById(int id)
{
    var product = _productRepository.GetById(id);
    if (product == null)
    {
        return new ServiceResponse<Product>
        {
            Success = false,
            Message = "Product not found"
        };
    }

    return new ServiceResponse<Product>(product);
}

public class PagedResult<T>
{
    public IEnumerable<T> Items { get; set; }
    public int TotalCount { get; set; }
    public int PageSize { get; set; }
    public int CurrentPage { get; set; }

    public PagedResult(IEnumerable<T> items, int totalCount, int pageSize, int currentPage)
    {
        Items = items;
        TotalCount = totalCount;
        PageSize = pageSize;
        CurrentPage = currentPage;
    }
}

public class PagingHelper
{
    public static PagedResult<T> GetPagedResult<T>(IQueryable<T> query, int page, int pageSize)
    {
        var totalCount = query.Count();
        var items = query.Skip((page - 1) * pageSize).Take(pageSize).ToList();

        return new PagedResult<T>(items, totalCount, pageSize, page);
    }
}

var pagedProducts = PagingHelper.GetPagedResult(_context.Products, page: 1, pageSize: 10);
var pagedOrders = PagingHelper.GetPagedResult(_context.Orders, page: 2, pageSize: 5);