Feedback

C# - LINQ Erweiterung: SingleMin/SingleMax

Veröffentlicht von am 29.08.2015
(0 Bewertungen)
Diese Erweiterungsmethoden suchen ein einzelnes Element aus der Liste heraus, bei dem ein bestimmter Wert Minimal bzw. Maximal in der ganzen Liste ist.
Dieser bestimmte Wert kann mit einer Funktion für jedes Element einzeln ermittelt werden.

Hinweis: Diese Methoden arbeiten so zu sagen wie die Min/Max Methoden, nur dass meine das Element statt dem jeweiligen Wert zurück geben.
GFU-Schulungen  [Anzeige]

ASP.NET Core - Der Einstieg

In nur 3 Tagen lernen Sie, wie man mit ASP.NET Core und den Technologien MVC, Entity Framework, WebAPI und Razor professionelle Web-Anwendungs-Architekturen aufbaut. Diese Schulung ist der perfekte Einstieg, um datengetriebene und präsentations-orientierte Applikationen auf Basis der ASP.NET Core Plattform zu erstellen.

C# Komplett

Sie kennen sich in objektorientierter Programmierung aus. Sie schreiben C++ oder Java? Und nun stehen Sie vor der Aufgabe, in C# Anwendungen zu erstellen. Das C# Komplett-Seminar verschafft Ihnen umfassende Programmierkenntnisse in dieser Sprache. Nach der Schulung entwickeln Sie selbständig Anwendungen mit C#. Sie kennen die Datentypen und Klassenbibliotheken der objektorientierten Programmiersprache C#. Der Komplettkurs setzt bei den Grundlagen von C# ein. Sie arbeiten mit Variablen und konvertieren Typen. Multithreading, Delegates, Generics sind nach dem Seminar für Sie kein Geheimnis mehr.

using System.Collections.Generic;

namespace System.Linq
{
    public static class LINQ_SingleMinMax
    {
        /// <summary>
        /// Wählt ein einzelnes Element aus, dessen bestimmter Wert das Minimum aller bestimmter Werte ist.
        /// </summary>
        /// <typeparam name="TResult">Der Typ der Elemente in der Quellauflistung.</typeparam>
        /// <typeparam name="TComparable">Der Typ der zum Größenvergleich der Werte dient.</typeparam>
        /// <param name="source">Die Quellliste mit den Elementen.</param>
        /// <param name="predicate">Eine Funktion zum auswählen des bestimmten Wertes eines Elements.</param>
        /// <returns>Das Element aus <paramref name="source"/> dessen mit <paramref name="predicate"/> bestimmter Wert Minimal ist.</returns>
        /// <exception cref="System.ArgumentNullException">Wird ausgelöst, wenn einer der Parameter <c>null</c> ist.</exception>
        /// <exception cref="System.InvalidOperationException">Wird ausgelöst, wenn <paramref name="source"/> 
        /// kein Element enthält oder aber mehr als eines, dessen Wert minimal ist.</exception>
        public static TResult SingleMin<TResult, TComparable>(this IEnumerable<TResult> source, Func<TResult, TComparable> predicate)
            where TComparable : IComparable<TComparable>
        {
            return SelectMinMax(source, predicate, 1);
        }

        /// <summary>
        /// Wählt ein einzelnes Element aus, dessen bestimmter Wert das Maximum aller bestimmter Werte ist.
        /// </summary>
        /// <typeparam name="TResult">Der Typ der Elemente in der Quellauflistung.</typeparam>
        /// <typeparam name="TComparable">Der Typ der zum Größenvergleich der Werte dient.</typeparam>
        /// <param name="source">Die Quellliste mit den Elementen.</param>
        /// <param name="predicate">Eine Funktion zum auswählen des bestimmten Wertes eines Elements.</param>
        /// <returns>Das Element aus <paramref name="source"/> dessen mit <paramref name="predicate"/> bestimmter Wert Maximal ist.</returns>
        /// <exception cref="System.ArgumentNullException">Wird ausgelöst, wenn einer der Parameter <c>null</c> ist.</exception>
        /// <exception cref="System.InvalidOperationException">Wird ausgelöst, wenn <paramref name="source"/> 
        /// kein Element enthält oder aber mehr als eines, dessen Wert maximal ist.</exception>
        public static TResult SingleMax<TResult, TComparable>(this IEnumerable<TResult> source, Func<TResult, TComparable> predicate)
            where TComparable : IComparable<TComparable>
        {
            return SelectMinMax(source, predicate, -1);
        }

        private static TResult SelectMinMax<TResult, TComparable>(IEnumerable<TResult> source, Func<TResult, TComparable> predicate, int compareToResult)
            where TComparable : IComparable<TComparable>
        {
            if (source == null)
            {
                throw new ArgumentNullException("source", "Source connot be null.");
            }
            if (predicate == null)
            {
                throw new ArgumentNullException("predicate", "predicate connot be null.");
            }
            var item = source.FirstOrDefault();
            if (item == null)
            {
                throw new InvalidOperationException("The Sequence is empty");
            }
            var key = predicate(item);
            bool foundMultipleOccurences = false;
            foreach (var inner in source.Skip(1))
            {
                var innerKey = predicate(inner);
                var compareResult = key.CompareTo(innerKey);
                if (compareResult == compareToResult)
                {
                    item = inner;
                    key = innerKey;
                    foundMultipleOccurences = false;
                }
                else if (compareResult == 0)
                {
                    foundMultipleOccurences = true;
                }
            }
            if (foundMultipleOccurences)
            {
                throw new InvalidOperationException("The Sequence contain more than one matching elements.");
            }
            return item;
        }
    }
}

Abgelegt unter LINQ, Erweiterungsmethode, Single, Min, Max.

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!