1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

Int32[] liste = { 10, 11, 12, 13, 16, 17, 18, 19, 20 }; //ist eigentlich eine list<T>, habe ich nur zum Demo so gemacht.


Int32 match = Result(15);


private Int32 Result(Int32 intValue)
{ 
    return result; //wäre in diesem Fall 16
}					

1:

var liste = new List<int> { 10, 11, 12, 13, 16, 17, 18, 19, 20 };					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:

Double[] list = { 22.1145, 5.1178, 1.1234, 2.3265, 3.7896, 4.1478, 14.1111, 10.1125, 11.7896, 12.5558, 13.7822 };

private double FindDouble(double rtValue)
{
    if (list.Length > 0)
    {
        List<double> lowerList = new List<double>();
        List<double> upperList = new List<double>();

        for (Int32 i = 0; i < list.Length; i++)
        {
            if (list[i] <= rtValue)
                lowerList.Add(list[i]);
            else
                upperList.Add(list[i]);
        }

        lowerList.Sort();
        upperList.Sort();

        Double lowerValue = 0;
        Double upperValue = 0;

        if (lowerList.Count > 0)
        {
            lowerValue = rtValue - lowerList[lowerList.Count - 1];
        }

        if (upperList.Count > 0)
        {
            upperValue = upperList[0] - rtValue;
        }

        if (lowerValue <= upperValue)
        {
            if (lowerList.Count > 0)
            {
                return lowerList[lowerList.Count - 1];
            }
            else
                return upperList[0];
        }
        else
        {
            if (upperList.Count > 0)
            {
                return upperList[0];
            }
            else
                return lowerList[lowerList.Count - 1];
        }
    }
    else
        return 0;
}					

1:

liste.Where(x => x >= rtValue).Min()					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

namespace System.Collections.Generic
{
    // Zusammenfassung:
    //     Stellt eine Auflistung von Objekten dar, auf die einzeln über einen Index
    //     zugegriffen werden kann.
    public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
    {
        // Zusammenfassung:
        //     Ruft das Element am angegebenen Index ab oder legt dieses fest.
        //
        // Parameter:
        //   index:
        //     Der nullbasierte Index des Elements, das abgerufen oder festgelegt werden
        //     soll.
        //
        // Rückgabewerte:
        //     Das Element am angegebenen Index.
        //
        // Ausnahmen:
        //   System.ArgumentOutOfRangeException:
        //     index ist kein gültiger Index in der System.Collections.Generic.IList<T>.
        //
        //   System.NotSupportedException:
        //     Die Eigenschaft wird festgelegt, und die System.Collections.Generic.IList<T>
        //     ist schreibgeschützt.
        T this[int index] { get; set; }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

static double Nearest(List<double> sortedList, double item)
{
  int i = sortedList.BinarySearch(item);
  if (i < 0)
    i = ~i;
  if (i == 0)
    return sortedList[i];
  else 
    return item - sortedList[i-1] < sortedList[i] - item ? sortedList[i-1] : sortedList[i];
}					

1:
2:
3:
4:
5:
6:
7:
8:

static double Nearest(List<double> list, double item)
{
  double result = 0; // Der Faulheit halber, sonst ein isFirst-Flag benutzen
  for (int i = 0; i++; i < list.Count)
    if (i == 0 || Math.Abs(list[i] - item) < Math.Abs(result - item))
      result = list[i];
  return result;
}					

1:

liste.Min(d => Math.Abs(d - rtValue));					

1:
2:
3:
4:
5:
6:
7:
8:

static double Nearest(List<double> list, double item)
{
  double result = 0; // Der Faulheit halber, sonst ein isFirst-Flag benutzen
  for (int i = 0; i++; i < list.Count)
    if (i == 0 || Math.Abs(list[i] - item) < Math.Abs(result - item))
      result = list[i];
  return result;
}					

1:
2:
3:
4:
5:
6:
7:
8:

static double Nearest(List<double> list, double value)
{
  double? nearest = null; // Nullable<double> ersetzt double-Variable und bool-"Gesetzt"-Flag
  foreach (var item in list)
    if (!nearest.HasValue || Math.Abs(item - value) < Math.Abs(nearest.Value - item))
      nearest = item;
  return nearest.Value; // Bei list.Count == 0 knallt's...
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

double[] ergebnisse ={10.1,  1.2222, 13.1, 20.1,25 };//Ergebnisdaten
double[] datenbank ={10, 1.5, 13.6, 21.0 }; //Referenzdaten 

void Identify()//suchen ob die Daten vorliegen, die in der Datenbank vorhanden sind
{
    List<double> ergebnisListe = new List<double>(ergebnisse);
    List<double> datenbankListe = new List<double>(datenbank);

    Debug.WriteLine("Ist" + "   " + "Soll(aus DB)");
    foreach (double value in datenbankListe)
    {
        Debug.WriteLine(Nearest(ergebnisListe, value) + "  " + value);
    }
}
static double Nearest(List<double> list, double value)
{
    double? nearest = null; // Nullable<double> ersetzt double-Variable und bool-"Gesetzt"-Flag
    foreach (double item in list)
        if (!nearest.HasValue || Math.Abs(item - value) < Math.Abs(nearest.Value - item))
            nearest = item;
    return nearest.Value; // Bei list.Count == 0 knallt's...
}					

1:
2:
3:
4:
5:

Ist   Soll(aus DB)
13,1  10
13,1  1,5
20,1  13,6
25    21					

1:
2:
3:
4:
5:

Ist    Soll(aus DB)
10,1   10
1,2222 1,5
13,1   13,6
20,1   21					

1:
2:
3:
4:
5:
6:
7:
8:

static double Nearest(List<double> list, double value)
{
    double? nearest = null; 
    foreach (double item in list)
        if (!nearest.HasValue || Math.Abs(item - value) < Math.Abs(nearest.Value - value))
            nearest = item;
    return nearest.Value; 
}