La syntaxe Linq pour OrderBy à la coutume de Comparer<T>

Il existe deux formats pour une expression Linq avec un tri personnalisé comparer:

Format 1

var query =
    source
    .Select(x => new { x.someProperty, x.otherProperty } )
    .OrderBy(x => x, new myComparer());

Format 2

var query =
    from x in source
    orderby x //comparer expression goes here?
    select new { x.someProperty, x.otherProperty };

Question:

Quelle est la syntaxe de la commande-par l'expression, dans le second format?

Pas la question:

Comment utiliser un comparateur comme indiqué dans le premier format.

Bonus de crédit:

Y sont réels, les noms formels pour les deux Linq formats mentionnés ci-dessus?

InformationsquelleAutor Steve Konves | 2012-10-05
  1. 21

    Quelle est la syntaxe de la commande-par l'expression, dans le second format?

    Il n'existe pas. À partir de la orderby de la clause de la documentation:

    Vous pouvez également spécifier une coutume comparer. Cependant, il n'est disponible que par l'aide de la méthode basée sur la syntaxe.

    Comment utiliser un comparateur dans le premier format.

    Vous l'avez écrit correctement. Vous pouvez passer à la IComparer<T> comme vous l'avez écrit.

    Y sont réels, les noms formels pour les deux Linq formats mentionnés ci-dessus?

    Format 1 est appelée "Méthode de Base de la Syntaxe" (de lien précédent), et Format 2 "Syntaxe d'Expression de Requête" (à partir de ici).

    • La qualité de linq liens! Bien que la déclaration sur l'ordre par la syntaxe de la méthode basée sur la syntaxe n'était pas censé être une partie de la réponse. 🙂
    • J'ai juste compris de toute façon. Vous pouvez facilement ignorer 😉
    InformationsquelleAutor Reed Copsey
  2. 2

    Comment utiliser un comparateur comme indiqué dans le premier format.

    Vous ne pouvez pas utiliser un comparateur dans ce format.

    Y sont réels, les noms formels pour les deux Linq formats mentionnés ci-dessus?

    Format 1 est la Méthode la syntaxe, Format 2 "la syntaxe de la requête",

    InformationsquelleAutor Servy
  3. 2

    Question:

    Ce n'est pas possible dans la syntaxe de la requête, car il n'y a pas de surcharges.

    Pas la question:

    Vous pouvez utiliser un comparateur avec les types anonymes uniquement si vous utiliser la réflexion pour comparer les objets, il est préférable d'utiliser une tapée de mise en œuvre pour la comparaison.

    Si vous ne voulez pas créer un tapé la mise en œuvre, vous pouvez utiliser un Tuple:

    var query =
    source
    .Select(x => new Tuple<string, int>(x.someProperty, x.otherProperty))
    .OrderBy(x => x, new MyComparer());

public class MyComparer : IComparer<Tuple<string, int>>
{
  public int Compare(Tuple<string, int> x, Tuple<string, int> y)
  {
    return x.Item1.CompareTo(y.Item1);
  }
}

    Bonus de crédit:

    • La syntaxe de la requête ou de la Compréhension de la Syntaxe
    • Méthode de la syntaxe ou de la méthode d'Extension de la Syntaxe
    InformationsquelleAutor Erwin
  4. 2

    Ce n'est pas nécessairement de répondre à la question d'origine, mais il s'étend un peu certaines des possibilités décrites. Je vous poste ça dans le cas où d'autres viennent à travers le problème similaire.
    La solution posté ici les contours d'un générique de commande en option qui peut être utile dans d'autres cas. Dans cet exemple, j'ai voulu trier une liste de fichiers par des propriétés différentes.

    ///<summary>
///Used to create custom comparers on the fly
///</summary>
///<typeparam name="T"></typeparam>
public class GenericCompare<T> : IComparer<T>
{
    //Function use to perform the compare
    private Func<T, T, int> ComparerFunction { set; get; }

    //Constructor
    public GenericCompare(Func<T, T, int> comparerFunction)
    {
        ComparerFunction = comparerFunction;
    }

    //Execute the compare
    public int Compare(T x, T y)
    {

        if (x == null || y == null) 
        {
            //These 3 are bell and whistles to handle cases where one of the two is null, to sort to top or bottom respectivly
            if (y == null && x == null) { return 0; }
            if (y == null) { return 1; }
            if (x == null) { return -1; }
        }

        try
        {
            //Do the actual compare
            return ComparerFunction(x, y);
        }
        catch (Exception ex)
        {
            //But muffle any errors
            System.Diagnostics.Debug.WriteLine(ex);
        }

        //Oh crud, we shouldn't be here, but just in case we got an exception.
        return 0;
    }
}

    Puis dans la mise en œuvre...

            GenericCompare<FileInfo> DefaultComparer;

        if (SortOrder == SORT_FOLDER_FILE)
        {
            DefaultComparer = new GenericCompare<FileInfo>((fr1, fr2) =>
            {
                return fr1.FullName.ToLower().CompareTo(fr2.FullName.ToLower());
            });
        }
        else if (SortOrder == SORT_SIZE_ASC)
        {
            DefaultComparer = new GenericCompare<FileInfo>((fr1, fr2) =>
            {
                return fr1.Length.CompareTo(fr2.Length);
            });
        }
        else if (SortOrder == SORT_SIZE_DESC)
        {
            DefaultComparer = new GenericCompare<FileInfo>((fr1, fr2) =>
            {
                return fr2.Length.CompareTo(fr1.Length);
            });
        }
        else
        {
            DefaultComparer = new GenericCompare<FileInfo>((fr1, fr2) =>
            {
                return fr1.Name.ToLower().CompareTo(fr2.Name.ToLower());
            });
        }

        var ordered_results = (new DirectoryInfo(@"C:\Temp"))
                .GetFiles()
                .OrderBy(fi => fi, DefaultComparer);

    Le gros avantage est que vous n'avez pas besoin de créer une nouvelle classe pour chaque commande par cas, il vous suffit de fil un nouveau lambda. Évidemment, cela peut être étendu à toutes sortes de façons, donc espérons que cela aide quelqu'un, quelque part, d'.

    InformationsquelleAutor Brad Joss