LINQ: Utilisation .À l'exception de() sur les collections de différents types en les rendant convertible/comparables?

Donné deux listes de types différents, est-il possible de faire ces types convertibles entre ou comparables les uns aux autres (par exemple avec un TypeConverter ou similaire), de sorte qu'une requête LINQ pouvez comparer? J'ai vu d'autres questions similaires sur SI rien, mais que les points de rendre les types convertibles entre elles pour résoudre le problème.

Types De Collection:

public class Data
{
    public int ID { get; set; }
}

public class ViewModel
{
    private Data _data;

    public ViewModel(Data data)
    {
        _data = data;
    }
}

D'utilisation souhaitée:

    public void DoMerge(ObservableCollection<ViewModel> destination, IEnumerable<Data> data)
    {
        //1. Find items in data that don't already exist in destination
        var newData = destination.Except(data);

        //...
    }

Il semblerait logique que depuis que je sais comment comparer une instance de ViewModel à une instance de Données, je devrais être en mesure de fournir une comparaison logique que LINQ alors utiliser pour les requêtes comme .À l'exception de(). Est-ce possible?

Pauvre vieux for boucle, il est donc utile, mais, hélas, il n'a jamais fait le one-liner gens heureux.
Je ne suis pas d'accord avec le sentiment que vous exprimez. Nous avons les moyens de l'écriture de code maintenant que de plus en plus clairement exprime l'intention, sans vous soucier du mécanisme. for exprime mécanismes et obscurcit l'intention. Le LINQ-fonction one-liners que vous êtes en dénonçant souvent (oui, pas toujours) mieux l'intention d'exprimer et de masquer les mécanismes. Cela conduit à un code qui est plus facile à comprendre et à maintenir.
alors que j'étais irrévérencieux, toutes les fonctions à vous jeter dans une projection comme vous ne sont confère une présomption d'intention.
Je ne suis pas.
simplement que je suis d'accord lorsque le LINQ peaux de contrôle simple-structure de base de la logique. Une projection à partir d'un type à l'autre n'est pas un de ces cas, l'omi. C'est pas plus clair ce qui se passe que dans var newData = MeaningfulFunctionNameHere(destination, data); Dans les deux cas, nous faisons une hypothèse sur ce qui se passe vraiment. En réalité, j'étais vraiment juste se moquer de LINQ est cool et s'applique partout de la foule.
Quel est le problème avec vous? LINQ est cool et ne s'appliquent partout. 😉

InformationsquelleAutor James Cadd | 2012-04-03

c#comparable comparison equality linq

4

Votre meilleur pari est de fournir une projection de Data à ViewModel de sorte que vous pouvez dire
```
var newData = destination.Except(data.Select(x => f(x)));
```
où f cartes Data à ViewModel. Vous aurez besoin d'un IEqualityComparer<Data> trop.

InformationsquelleAutor jason
6

Je suppose que le fait de fournir une projection de Data à ViewModel est problématique, je vous propose donc une autre solution en plus de Jason.

À l'exception utilise un hash jeu (si je me souviens bien), de sorte que vous pouvez obtenir des performances similaires en créant votre propre hashset. Je suis aussi en supposant que vous êtes l'identification Data objets que l'égalité lors de leur IDs sont égaux.
```
var oldIDs = new HashSet<int>(data.Select(d => d.ID));
var newData = destination.Where(vm => !oldIDs.Contains(vm.Data.ID));
```
Vous pourriez avoir une autre utilisation pour une collection de "oldData" ailleurs dans la méthode, dans ce cas, vous voulez faire à la place. La mise en œuvre IEquatable<Data> sur votre classe de données, ou d'en créer un personnalisé IEqualityComparer<Data> pour l'ensemble de hachage:
```
var oldData = new HashSet<Data>(data);
//or: var oldData = new HashSet<Data>(data, new DataEqualityComparer());
var newData = destination.Where(vm => !oldData.Contains(vm.Data));
```
- Pourquoi serait-il problématique? ViewModel a un constructeur qui prend Data!
- Je veux dire "problématique" pour la performance, ou philosophiquement, et non pas en termes de trouver comment écrire le code. En terme de Performance, le ViewModel classe peut nécessiter beaucoup d'autres frais généraux dans sa construction. Philosophiquement, il semble étrange de créer un tas d'objets, il suffit de nous pouvons donc utiliser Except à sélectionner certains objets qui ne répondent pas à certains critères.
InformationsquelleAutor phoog

Si vous utilisez ce :

var newData = destination.Except(data.Select(x => f(x)));

Vous avez pour projet de 'données' de même type figurant dans "destination", mais à l'aide du code ci-dessous, vous pourriez se débarrasser de cette limitation :

//Here is how you can compare two different sets.
class A { public string Bar { get; set; } }
class B { public string Foo { get; set; } }
IEnumerable<A> setOfA = new A[] { /*...*/ };
IEnumerable<B> setOfB = new B[] { /*...*/ };
var subSetOfA1 = setOfA.Except(setOfB, a => a.Bar, b => b.Foo);
//alternatively you can do it with a custom EqualityComparer, if your not case sensitive for instance.
var subSetOfA2 = setOfA.Except(setOfB, a => a.Bar, b => b.Foo, StringComparer.OrdinalIgnoreCase);
//Here is the extension class definition allowing you to use the code above
public static class IEnumerableExtension
{
public static IEnumerable<TFirst> Except<TFirst, TSecond, TCompared>(
this IEnumerable<TFirst> first,
IEnumerable<TSecond> second,
Func<TFirst, TCompared> firstSelect,
Func<TSecond, TCompared> secondSelect)
{
return Except(first, second, firstSelect, secondSelect, EqualityComparer<TCompared>.Default);
}
public static IEnumerable<TFirst> Except<TFirst, TSecond, TCompared>(
this IEnumerable<TFirst> first,
IEnumerable<TSecond> second,
Func<TFirst, TCompared> firstSelect,
Func<TSecond, TCompared> secondSelect,
IEqualityComparer<TCompared> comparer)
{
if (first == null)
throw new ArgumentNullException("first");
if (second == null)
throw new ArgumentNullException("second");
return ExceptIterator<TFirst, TSecond, TCompared>(first, second, firstSelect, secondSelect, comparer);
}
private static IEnumerable<TFirst> ExceptIterator<TFirst, TSecond, TCompared>(
IEnumerable<TFirst> first,
IEnumerable<TSecond> second,
Func<TFirst, TCompared> firstSelect,
Func<TSecond, TCompared> secondSelect,
IEqualityComparer<TCompared> comparer)
{
HashSet<TCompared> set = new HashSet<TCompared>(second.Select(secondSelect), comparer);
foreach (TFirst tSource1 in first)
if (set.Add(firstSelect(tSource1)))
yield return tSource1;
}
}

Certains pourraient faire valoir que la mémoire inefficace en raison de l'utilisation d'un HashSet. Mais en réalité, l'Énumérable.À l'exception de la méthode du cadre est de faire de même avec une même classe interne appelé " Set " (j'ai pris un coup d'oeil par la décompilation).

InformationsquelleAutor Pataphysicien

Je sais que c'est tard, mais il y a une syntaxe plus simple à l'aide de la touche Func qui élimine le besoin d'un comparateur.

public static class LinqExtensions
{
public static IEnumerable<TSource> Except<TSource, VSource>(this IEnumerable<TSource> first, IEnumerable<VSource> second, Func<TSource, VSource, bool> comparer)
{
return first.Where(x => second.Count(y => comparer(x, y)) == 0);
}
public static IEnumerable<TSource> Contains<TSource, VSource>(this IEnumerable<TSource> first, IEnumerable<VSource> second, Func<TSource, VSource, bool> comparer)
{
return first.Where(x => second.FirstOrDefault(y => comparer(x, y)) != null);
}
public static IEnumerable<TSource> Intersect<TSource, VSource>(this IEnumerable<TSource> first, IEnumerable<VSource> second, Func<TSource, VSource, bool> comparer)
{
return first.Where(x => second.Count(y => comparer(x, y)) == 1);
}
}

donc, avec les listes de la classe Foo et Bar

public class Bar
{
public int Id { get; set; }
public string OtherBar { get; set; }
}
public class Foo
{
public int Id { get; set; }
public string OtherFoo { get; set; }
}

on peut courir Linq des déclarations comme

var fooExceptBar = fooList.Except(barList, (f, b) => f.Id == b.Id);
var barExceptFoo = barList.Except(fooList, (b, f) => b.OtherBar == f.OtherFoo);

en gros, c'est une légère variation sur le dessus mais semble plus propre à moi.

InformationsquelleAutor Geoff Scott

Vous devez vous connecter pour publier un commentaire.