Est-ce que C# Distinct() la méthode de garder l'original de la commande de séquence intacte?

Oui, dans l'ordre de leur première occurrence dans la liste d'origine. Il est garanti pour .Net Framework 3.5

J'ai fait une petite enquête avec Réflecteur. Après démontage System.Core.dll Version=3.5.0.0 vous pouvez voir que Distinct() est une méthode d'extension, qui ressemble à ceci:

public static class Emunmerable
{
    public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source)
    {
        if (source == null)
            throw new ArgumentNullException("source");

        return DistinctIterator<TSource>(source, null);
    }
}

Donc, intéressant ici, c'est DistinctIterator, qui implémente l'interface IEnumerable et IEnumerator. Ici est simplifié (goto et etiquettes supprimé) la mise en œuvre de cette IEnumerator:

private sealed class DistinctIterator<TSource> : IEnumerable<TSource>, IEnumerable, IEnumerator<TSource>, IEnumerator, IDisposable
{
    private bool _enumeratingStarted;
    private IEnumerator<TSource> _sourceListEnumerator;
    public IEnumerable<TSource> _source;
    private HashSet<TSource> _hashSet;    
    private TSource _current;

    private bool MoveNext()
    {
        if (!_enumeratingStarted)
        {
            _sourceListEnumerator = _source.GetEnumerator();
            _hashSet = new HashSet<TSource>();
            _enumeratingStarted = true;
        }

        while(_sourceListEnumerator.MoveNext())
        {
            TSource element = _sourceListEnumerator.Current;

             if (!_hashSet.Add(element))
                 continue;

             _current = element;
             return true;
        }

        return false;
    }

    void IEnumerator.Reset()
    {
        throw new NotSupportedException();
    }

    TSource IEnumerator<TSource>.Current
    {
        get { return _current; }
    }

    object IEnumerator.Current
    {        
        get { return _current; }
    }
}

Comme vous pouvez le voir - l'énumération va dans l'ordre prévu par la source énumérable (liste, sur laquelle nous sommes callin Distinctes). Hashset utilisé que pour déterminer si nous avons déjà rendu tel élément ou non. Si non, nous sommes de retour il, d'autre - poursuivre l'énumération de la source.

Ainsi, il est garanti que Distinct() renverra les éléments exactement dans le même ordre, qui sont fournis par la collection à laquelle Distincts a été appliquée.

Oui, Énumérable.Distinctes conserve l'ordre. En supposant que la méthode d'être paresseux "les rendements des valeurs distinctes sont dès qu'ils ont vu", il en découle automatiquement. Pensez à ce sujet.

La .NET de source de Référence confirme. Elle renvoie une sous-suite, le premier élément de chaque classe d'équivalence.

foreach (TSource element in source)
    if (set.Add(element)) yield return element;

La .NET, Base de la mise en œuvre est similaire.

Malheureusement, la documentation de Énumérable.Distinctes est confus sur ce point:

Le résultat de la séquence non triée.

Je peux seulement imaginer qu'ils signifient "le résultat de la séquence n'est pas triée." Vous pourrait mettre en œuvre Distinctes par presorting puis de les comparer chaque élément de la précédente, mais ce ne serait pas être paresseux comme défini ci-dessus.

Cela dépend fortement de votre linq-fournisseur. Sur Linq2Objects vous pouvez rester à l'intérieur du code source pour Distinct, ce qui fait supposer l'ordre d'origine est conservé.

Toutefois, pour les autres fournisseurs qui se rapportent à une sorte de SQL par exemple, qui n'est pas impérativement le cas, comme un ORDER BY-déclaration survient habituellement après tout agrégation (comme Distinct). Donc, si votre code est: est-ce

myArray.OrderBy(x => anothercol).GroupBy(x => y.mycol);

ce qui est traduit à quelque chose de semblable à la suivante dans SQL:

SELECT * FROM mytable GROUP BY mycol ORDER BY anothercol;

C'est évidemment la première des groupes de vos données et de les trier par la suite. Maintenant vous êtes coincé sur le SGBD logique propre de la façon de les exécuter. Sur certains SGBD ce n'est pas même permis. Imaginez les données suivantes:

mycol anothercol
1     2
1     1
1     3
2     1
2     3

lors de l'exécution de myArr.OrderBy(x => x.anothercol).GroupBy(x => x.mycol) nous supposons le résultat suivant:

mycol anothercol
1     1
2     1

Mais le SGBD peut regrouper les anothercol-colonne, de sorte que toujours la valeur de la première ligne est utilisé, ce qui entraîne dans les données suivantes:

mycol anothercol
1    2
2    1

qui après la commande sera le résultat de cette:

mycol anothercol
2    1
1    2

C'est semblable à la suivante:

SELECT mycol, First(anothercol) from mytable group by mycol order by anothercol;

qui est complètement l'inverse de l'ordre de ce qui vous attend.

Vous voir à l'exécution du plan peut varier selon le fournisseur sous-jacent est. C'est pourquoi theres aucune garantie à ce sujet dans la documentation.