Médio C#

Método genérico com restrição IComparable

Enunciado

Implemente um método genérico Maior<T> que recebe dois argumentos do tipo T e retorna o maior. Use a restrição where T : IComparable<T> para garantir que os tipos possam ser comparados. Teste com int e string.

Requisitos

  • O método deve ser genérico: public static T Maior<T>(T a, T b).
  • Deve ter a restrição where T : IComparable<T>.
  • Retorna o maior valor usando CompareTo.
  • O programa principal deve testar com int e string e imprimir os resultados.

Código inicial

using System;

public static class Utilitarios
{
    // implemente o método Maior
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Utilitarios.Maior(10, 20)); // 20
        Console.WriteLine(Utilitarios.Maior("Ana", "Bia")); // Bia
    }
}

Saída esperada

20
Bia
Ver dica

Use a.CompareTo(b) > 0 para decidir qual é o maior.

Mostrar solução 
using System;

public static class Utilitarios
{
    public static T Maior<T>(T a, T b) where T : IComparable<T>
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Utilitarios.Maior(10, 20)); // 20
        Console.WriteLine(Utilitarios.Maior("Ana", "Bia")); // Bia
    }
}

Passo a passo

  1. Declaramos a classe estática Utilitarios para conter o método.
  2. O método Maior<T> recebe dois parâmetros do tipo T.
  3. A restrição where T : IComparable<T> garante que T implementa a interface IComparable<T>, permitindo chamar CompareTo.
  4. Comparamos a com b usando a.CompareTo(b) > 0; se verdadeiro, retornamos a, senão b.
  5. No Main, chamamos o método com int e string, que implementam IComparable<T>.

Por que funciona

A restrição permite que o compilador saiba que T tem o método CompareTo, então o código genérico pode usá-lo. Isso evita casts e mantém a segurança de tipos. Qualquer tipo que implemente IComparable<T> pode ser usado.

Erros comuns

  • Esquecer a restrição: o compilador não permitirá chamar CompareTo em T, gerando erro CS1061.
  • Usar IComparable não genérico: funciona, mas perde a segurança de tipos e pode causar boxing.
  • Tentar comparar tipos que não implementam IComparable<T>, como uma classe personalizada sem a interface; isso causará erro de compilação.

Outra forma de resolver

Usar Comparer<T>.Default.Compare(a, b) > 0 permite comparar sem restrição, pois Comparer<T>.Default lida com tipos que implementam IComparable<T> ou IComparable. É útil quando não se quer restringir o tipo.

Saída esperada

20
Bia