consulta LINQ con distintas y Unión

Question

Actualmente tengo 2 consultas que están regresando listas de MyModel como esto:

var q1 = .... 
     select new MyModel() 
     { 
      TheData1 = ... 
      TheData2 = ... 
      TheUniqueID = ... 
     } 

var q2 = .... 
     select new MyModel() 
     { 
      TheData1 = ... 
      TheData2 = ... 
      TheUniqueID = ... 
     } 

Si en la Q1 que tengo:

TheUniqueID = 2,3,6,9,11 

y en la Q2 que tienen:

TheUniqueID = 2,4,7,9,12 

¿Cómo escribir la consulta para que me sale una lista de MyModel donde

TheUniqueID = 2,3,4,6,7,9,11,12 

En otras palabras, cada TheUniqueID está presente solo una vez (es decir. 2 y 9 no repetidos).

Empecé a buscar en Union y distinto pero me pregunto si necesito 2 de declaraciones o no.

Cualquier sugerencia es bienvenida.

Answer 1

Creo que frenchie quiere una lista de MyModel en lugar de solo TheUniqueID.

Es necesario crear una clase MyModelTheUniqueIDComparer y aprobar una nueva instancia de la misma como un segundo argumento en Union:

class MyModelTheUniqueIDComparer : IEqualityComparer<MyModel> 
{ 
    public bool Equals(MyModel x, MyModel y) 
    { 
     return x.TheUniqueID == y.TheUniqueID; 
    } 

    // If Equals() returns true for a pair of objects 
    // then GetHashCode() must return the same value for these objects. 

    public int GetHashCode(MyModel myModel) 
    { 
     return myModel.TheUniqueID.GetHashCode(); 
    } 
} 

A continuación, puede llamar para obtener el resultado:

var result = q1.Union(q2, new MyModelTheUniqueIDComparer()); 

Ver http://msdn.microsoft.com/en-us/library/bb358407.aspx para más detalles.

Actualización:

Prueba esto:

public class A 
{ 
    public string TheData1 { get; set; } 
    public string TheData2 { get; set; } 
    public string UniqueID { get; set; } 
} 

public class AComparer : IEqualityComparer<A> 
{ 

    #region IEqualityComparer<A> Members 

    public bool Equals(A x, A y) 
    { 
     return x.UniqueID == y.UniqueID; 
    } 

    public int GetHashCode(A obj) 
    { 
     return obj.UniqueID.GetHashCode(); 
    } 

    #endregion 
} 

Y prueba con esto:

var listOfA = new List<A>(); 
var q1 = from a in listOfA 
       select new A() 
      { 
       TheData1 = "TestData", 
       TheData2 = "TestData", 
       UniqueID = a.UniqueID 
      }; 

var anotherListOfA = new List<A>(); 
var q2 = from a in anotherListOfA 
       select new A() 
       { 
        TheData1 = "TestData", 
        TheData2 = "TestData", 
        UniqueID = a.UniqueID 
       }; 

q1.Union(q2, new AComparer()); 

Asegúrate de que tienes using System.Linq;

Answer 2

Como se señaló si está combinando las listas con .Union() tendrá que definir la singularidad usando la sobrecarga que pasa un IEqualityComparer para su tipo.

var result = q1.Union(q2, myEqualityComparer); 

lo contrario, y más fácil que usted podría utilizar DistinctBy(x=> x.TheUniqueId) del proyecto MoreLinq:

var result = q1.Concat(q2).DistinctBy(c => c.TheUniqueID); 

Answer 3

Union crea un Enumerable con valores únicos de ambas colecciones. En otras palabras, no necesita Distinct.

edición: ejemplo de Unión here

Edit2: se olvidó de que no es la lista de UniqueIDs que está concatenando. Eliminé el código sugerido porque era incorrecto. Debería poder hacer un simple Union si implementa un IEqualityComparer, pero eso podría ser excesivo.

Answer 4

ans sola línea ineficiente wer sin IEqualityComparerer

Usando el código fuente de inspiración MoreLinq, esto le dará una lista única:

respuesta corta (el OrdenarPor no es necesario, pero si no se utiliza la respuesta sale como 2,3,6 , 9,11,4,7,12):

var concattedUniqueList = theUniqueIDList1.Concat(theUniqueIDList2) 
      .GroupBy(f=>f.UniqueID, f=>f).Select(g => g.First()).OrderBy(f=>f.UniqueID); 

la respuesta completa:

//INPUT 
//theUniqueIDList1 = 2,3,6,9,11 
//theUniqueIDList2 = 2,4,7,9,12 
//OUTPUT 
//2,3,4,6,7,9,11,12 
public class MyModel 
{ 
    public string TheData1 { get; set; } 
    public string TheData2 { get; set; } 
    public int UniqueID { get; set; } 
} 

public static void GroupByEx1() 
    { 
     // Create a list of Models. 
     List<MyModel> theUniqueIDList1 = 
      new List<MyModel>{ new MyModel { TheData1="Barley", UniqueID=2 }, 
            new MyModel { TheData1="Boots",  UniqueID=3 }, 
            new MyModel { TheData1="Whiskers", UniqueID=6 }, 
            new MyModel { TheData1="Daisy",  UniqueID=9 }, 
            new MyModel { TheData1="Preti",  UniqueID=11 } }; 
     List<MyModel> theUniqueIDList2 = 
      new List<MyModel>{ new MyModel { TheData1="Barley", UniqueID=2 }, 
            new MyModel { TheData1="Henry",  UniqueID=4 }, 
            new MyModel { TheData1="Walsh",  UniqueID=7 }, 
            new MyModel { TheData1="Daisy",  UniqueID=9 }, 
            new MyModel { TheData1="Ugly", UniqueID=12 } }; 

     var concattedUniqueList = theUniqueIDList1.Concat(theUniqueIDList2) 
      .OrderBy(f=>f.UniqueID).GroupBy(f=>f.UniqueID, f=>f).Select(g => g.First()); 

     foreach (var item in concattedUniqueList) 
     { 
      Console.WriteLine("UniqueId: {0}({1})", item.UniqueID, item.TheData1); 
     } 
    } 

void Main() 
{ 
    GroupByEx1();    
    //2,3,4,6,7,9,11,12 
} 

Nota: en comparación con el uso de un IEqualityComparer para la velocidad - 10000 veces para cada 698 ns para Concat 100 ns para IEqualityComparer

desarrollan en LinqPad