In letzter Zeit stelle ich mir immer wieder die Frage, ob man bestimmte Funktionen nicht effizienter schreiben kann, hinsichtlich Laufzeit und Speicherverbrauch.

Zur Zeit sitze ich an einer einfachen Funktion, die das Minimum von vier Zahlen ausgeben soll. Es dürfen nicht mehr und nicht weniger Zahlen sein, sondern nur vier.
Aktuell sieht meine Funktion so aus:

/// <summary>
        /// Returns the minimum of four numbers.
        /// </summary>
        /// <param name="a">First number.</param>
        /// <param name="b">Second number.</param>
        /// <param name="c">Third number.</param>
        /// <param name="d">Fourth number.</param>
        /// <returns>Minimum of a, b, c and d.</returns>
        private int Min(int a, int b, int c, int d)
        {
            int[] numbers = new int[4];
            numbers[0] = a;
            numbers[1] = b;
            numbers[2] = c;
            numbers[3] = d;

            Array.Sort(numbers);
            return numbers[0];
        }

Jetzt habe ich mir gedacht, warum schreibe ich nicht gleich ein Array als Parameter rein. Nur weiß ich leider nicht, wie man das Array in so einem Fall auf 4 Zahlen beschränkt. Also es müsste dann irgendwie so aussehen:

private int Min(int[4] numbers)

Aber das geht wohl nicht ... ? Jedenfalls meint das Visual Studio so ...

Nur kurz der Vollständigkeithalber:

Du kannst auch eine eigenen Min-Implementierung schreiben die ein Parameter-Array entgegen nimmt und dieses anstelle der .Net-Implemtierung verwenden.

public static int Min(params int[] values){
 if(values.Length == 0)
  throw new ArgumentException("Es wurden keine Werte übergeben", "values");

 int minVal = int.MaxValue;
 
 foreach(int val in values)
  minVal = Math.Min(val, minVal);
 
 return minVal;
}

oder:

public static int Min(params int[] values){
 if(values.Length == 0)
  throw new ArgumentException("Es wurden keine Werte übergeben", "values");

 int minVal = int.MaxValue;
 var iter = values.GetEnumerator(); 

 while(iter.MoveNext()){
  minVal = Math.Min(minVal, (int)iter.Current);
 }

 if(iter is IDisposable)
  (iter as IDisposable).Dispose();
 
 return minVal;
}

Ein Beispielaufruf:

int minValue = Min(7,4,5,2,6, ...);

So werden nicht alle Zahlen sortiert, sondern es wird nur die kleinste herausgesucht. Sollte schneller gehen, als wenn du ein Array sortierst.

int min = int.MaxValue;
if (a < min) min = a;
if (b < min) min = b;
if (c < min) min = c;
if (d < min) min = d;
return min;