.Contains () em uma lista de objetos de classe personalizados

Estou tentando usar a .Contains()função em uma lista de objetos personalizados

Esta é a lista:

List<CartProduct> CartProducts = new List<CartProduct>();

E o CartProduct:

public class CartProduct
{
    public Int32 ID;
    public String Name;
    public Int32 Number;
    public Decimal CurrentPrice;
    /// <summary>
    /// 
    /// </summary>
    /// <param name="ID">The ID of the product</param>
    /// <param name="Name">The name of the product</param>
    /// <param name="Number">The total number of that product</param>
    /// <param name="CurrentPrice">The currentprice for the product (1 piece)</param>
    public CartProduct(Int32 ID, String Name, Int32 Number, Decimal CurrentPrice)
    {
        this.ID = ID;
        this.Name = Name;
        this.Number = Number;
        this.CurrentPrice = CurrentPrice;
    }
    public String ToString()
    {
        return Name;
    }
}

Então, tento encontrar um produto de carrinho semelhante na lista:

if (CartProducts.Contains(p))

Mas ele ignora produtos de carrinho semelhantes e eu não pareço saber o que ele verifica - o ID? ou tudo isso?

Desde já, obrigado! :)

Você precisa implementar IEquatableou substituir Equals()eGetHashCode()

Por exemplo:

public class CartProduct : IEquatable<CartProduct>
{
    public Int32 ID;
    public String Name;
    public Int32 Number;
    public Decimal CurrentPrice;

    public CartProduct(Int32 ID, String Name, Int32 Number, Decimal CurrentPrice)
    {
        this.ID = ID;
        this.Name = Name;
        this.Number = Number;
        this.CurrentPrice = CurrentPrice;
    }

    public String ToString()
    {
        return Name;
    }

    public bool Equals( CartProduct other )
    {
        // Would still want to check for null etc. first.
        return this.ID == other.ID && 
               this.Name == other.Name && 
               this.Number == other.Number && 
               this.CurrentPrice == other.CurrentPrice;
    }
}

Se estiver usando .NET 3.5 ou mais recente, você pode usar métodos de extensão LINQ para obter uma verificação "contém" com o Anymétodo de extensão:

if(CartProducts.Any(prod => prod.ID == p.ID))

Isso verificará a existência de um produto dentro do CartProductsqual tenha um ID correspondente ao ID de p. Você pode colocar qualquer expressão booleana após o =>para realizar a verificação.

Isso também tem a vantagem de trabalhar para consultas LINQ-to-SQL, bem como consultas na memória, onde Containsnão funciona.

Ele verifica se o objeto específico está contido na lista.

Você pode usar o método Find da lista melhor.

Aqui está um exemplo

List<CartProduct> lst = new List<CartProduct>();

CartProduct objBeer;
objBeer = lst.Find(x => (x.Name == "Beer"));

espero que ajude

Você também deve olhar para o LinQ - um exagero para isso, talvez, mas uma ferramenta útil, no entanto ...

Por padrão, os tipos de referência têm igualdade de referência (ou seja, duas instâncias são iguais apenas se forem o mesmo objeto).

Você precisa substituir Object.Equals(e Object.GetHashCodecombinar) para implementar sua própria igualdade. (E, então, é uma boa prática implementar um ==operador de igualdade ,,.)

Você precisa criar um objeto de sua lista como:

List<CartProduct> lst = new List<CartProduct>();

CartProduct obj = lst.Find(x => (x.Name == "product name"));

Esse objeto obtém o valor procurado pesquisando por suas propriedades: x.name

Em seguida, você pode usar métodos List como Contains ou Remove

if (lst.Contains(obj))
{
   lst.Remove(obj);
}

Implementar override Equals()eGetHashCode()

public class CartProduct
{
    public Int32 ID;
    ...

    public CartProduct(Int32 ID, ...)
    {
        this.ID = ID;
        ...
    }

    public override int GetHashCode()
    {
        return ID;
    }

    public override bool Equals(Object obj)
        {
            if (obj == null || !(obj is CartProduct))
                return false;
            else
                return GetHashCode() == ((CartProduct)obj).GetHashCode();
        }

}

usava:

if (CartProducts.Contains(p))

Se você quiser ter controle sobre isso, você precisa implementar a [interface IEquatable] [1]

[1]: http: // Este método determina a igualdade usando o comparador de igualdade padrão, conforme definido pela implementação do objeto do método IEquatable.Equals para T (o tipo de valores na lista).