LINQ: Farklı değerler

Bir XML set aşağıdaki öğe var:

id           category

5            1
5            3
5            4
5            3
5            3

Bu öğelerin ayrı bir listesine ihtiyacım var:

5            1
5            3
5            4

LINQ'da Kategori VE Kimliği için nasıl farklı olabilirim?

Birden fazla alandan farklı olmaya mı çalışıyorsunuz? Öyleyse, anonim bir tür ve Distinct operatörü kullanın ve tamam olmalıdır:

var query = doc.Elements("whatever")
               .Select(element => new {
                             id = (int) element.Attribute("id"),
                             category = (int) element.Attribute("cat") })
               .Distinct();

Eğer bir "büyük" türündeki değerler ayrı set almak için çalışıyorsanız, fakat sadece belirginliği yönü için bazı özelliklerini alt kümesi bakarak, muhtemelen istediğiniz DistinctByuygulandığı şekliyle MoreLINQ içinde DistinctBy.cs:

 public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
     this IEnumerable<TSource> source,
     Func<TSource, TKey> keySelector,
     IEqualityComparer<TKey> comparer)
 {
     HashSet<TKey> knownKeys = new HashSet<TKey>(comparer);
     foreach (TSource element in source)
     {
         if (knownKeys.Add(keySelector(element)))
         {
             yield return element;
         }
     }
 }

(Karşılaştırma nullaracı olarak iletirseniz, anahtar türü için varsayılan karşılaştırıcıyı kullanır.)

Sadece Distinct()kendi karşılaştırıcınızla kullanın.

http://msdn.microsoft.com/en-us/library/bb338049.aspx

Jon Skeet'in cevabına ek olarak, her grup yinelemesi için w / sayım boyunca benzersiz grupları elde etmek için grubu ifadelerle de kullanabilirsiniz:

var query = from e in doc.Elements("whatever")
            group e by new { id = e.Key, val = e.Value } into g
            select new { id = g.Key.id, val = g.Key.val, count = g.Count() };

Hala bakanlar için; özel bir lambda karşılaştırıcısı uygulamanın başka bir yolu.

public class LambdaComparer<T> : IEqualityComparer<T>
    {
        private readonly Func<T, T, bool> _expression;

        public LambdaComparer(Func<T, T, bool> lambda)
        {
            _expression = lambda;
        }

        public bool Equals(T x, T y)
        {
            return _expression(x, y);
        }

        public int GetHashCode(T obj)
        {
            /*
             If you just return 0 for the hash the Equals comparer will kick in. 
             The underlying evaluation checks the hash and then short circuits the evaluation if it is false.
             Otherwise, it checks the Equals. If you force the hash to be true (by assuming 0 for both objects), 
             you will always fall through to the Equals check which is what we are always going for.
            */
            return 0;
        }
    }

daha sonra linq Distinct için lambda'yı alabilecek bir uzantı oluşturabilirsiniz

   public static IEnumerable<T> Distinct<T>(this IEnumerable<T> list,  Func<T, T, bool> lambda)
        {
            return list.Distinct(new LambdaComparer<T>(lambda));
        }  

Kullanımı:

var availableItems = list.Distinct((p, p1) => p.Id== p1.Id);

Cevaba biraz geç kaldım, ancak bunu sadece gruplandırmak istediğiniz değerleri değil, tüm öğeyi istiyorsanız yapmak isteyebilirsiniz:

var query = doc.Elements("whatever")
               .GroupBy(element => new {
                             id = (int) element.Attribute("id"),
                             category = (int) element.Attribute("cat") })
               .Select(e => e.First());

Bu, DistinctBy kullanan Jon Skeets ikinci örneğinde olduğu gibi, IEqualityComparer karşılaştırıcısını uygulamadan, grubunuza seçimle eşleşen ilk tüm öğeyi verecektir. DistinctBy büyük olasılıkla daha hızlı olacaktır, ancak performans bir sorun değilse yukarıdaki çözüm daha az kod içerecektir.

// First Get DataTable as dt
// DataRowComparer Compare columns numbers in each row & data in each row

IEnumerable<DataRow> Distinct = dt.AsEnumerable().Distinct(DataRowComparer.Default);

foreach (DataRow row in Distinct)
{
    Console.WriteLine("{0,-15} {1,-15}",
        row.Field<int>(0),
        row.Field<string>(1)); 
}

Her öğeye tam olarak bir kez sahip olduğumuzdan bahsettiğimiz için, bir “set” benim için daha anlamlı.

Sınıflar ve uygulanan IEqualityComparer örneği:

 public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public Product(int x, string y)
        {
            Id = x;
            Name = y;
        }
    }

    public class ProductCompare : IEqualityComparer<Product>
    {
        public bool Equals(Product x, Product y)
        {  //Check whether the compared objects reference the same data.
            if (Object.ReferenceEquals(x, y)) return true;

            //Check whether any of the compared objects is null.
            if (Object.ReferenceEquals(x, null) || Object.ReferenceEquals(y, null))
                return false;

            //Check whether the products' properties are equal.
            return x.Id == y.Id && x.Name == y.Name;
        }
        public int GetHashCode(Product product)
        {
            //Check whether the object is null
            if (Object.ReferenceEquals(product, null)) return 0;

            //Get hash code for the Name field if it is not null.
            int hashProductName = product.Name == null ? 0 : product.Name.GetHashCode();

            //Get hash code for the Code field.
            int hashProductCode = product.Id.GetHashCode();

            //Calculate the hash code for the product.
            return hashProductName ^ hashProductCode;
        }
    }

şimdi

List<Product> originalList = new List<Product> {new Product(1, "ad"), new Product(1, "ad")};
var setList = new HashSet<Product>(originalList, new ProductCompare()).ToList();

setList benzersiz unsurlara sahip olacak

Bunu .Except()bir set farkı döndürürken uğraşırken düşündüm