db4o sortieren

[Luckie]

Ich will also meine Datensätze sortieren, nur leider bringt die Datenbank dafür nichts mit. Als Workaround wird hier gesagt:

Zitat:

das ObjectSet in eine Collection zu kopieren und dann Collections.sort() darauf aufzurufen).

So bekomme ich alle datensätze in ein ObjectSet:

Code:

public IList<Person> Sort()
        {
            Person prs = new Person(null, null, 0);
            ObjectSet os = oc.Get(prs);
        }

und wie jetzt weiter?

[MathiasSimmack]

Gab es nicht bei Datenbanken die Möglichkeit, die Query-Ergebnisse gleich so zu filtern, dass sie unter Umständen schon sortiert ankommen? Wenn nicht, dann meinen die im Forum wohl den Weg, dass du die Ergebnisse der Datenbank in eine Liste (= Collection) kopierst und dann selbst eine Sortierroutine ansetzt.

Keine Ahnung, ob das besonders elegant ist (wo ist der Robert, wenn man ihn mal braucht? ), aber es funktioniert:

Code:

public List<Person> SortByAge()
{
   IList<Person> personen  = oc.Query<Person> (typeof(Person));
   List<Person> sortedList = new List<Person>(personen);
   AgeComparer ageCompare  = new AgeComparer();

   sortedList.Sort(ageCompare);
   return sortedList;
}

class AgeComparer : IComparer<Person>
{
   public int Compare(Person a, Person b)
   {
      return decimal.Compare(a.Alter, b.Alter);
   }
}


// Beispiel:

Queries queries = new Queries(db);
List<Person> sortedResult = queries.SortByAge();
foreach(Person person4 in sortedResult)
{
   Console.WriteLine("{0} ist {1} Jahre alt", person4.Name, person4.Alter);
}

[Elvis]

Ich habe mal den Rest der Mittagspause geopfert um das hier runterzuhacken.
Ist eigentlich nur ein billiger Quicksort, welcher entweder mit einem IComparer<T> oder einem delegate arbeitet:

Code:

public static class QuickSorter<T>
{
  public static void Sort(IList<T> list)
  {
    Sort(list, Comparer<T>.Default);
  }

  public static void Sort(IList<T> list, IComparer<T> comparer)
  {
    Sort(list, comparer, 0, list.Count - 1);
  }

  public static void Sort(IList<T> list, Comparison<T> comparison)
  {
    Sort(list, comparison, 0, list.Count - 1);
  }

  public static void Sort(IList<T> list, int lowerBound, int upperBound)
  {
    IComparer<T> comparer = Comparer<T>.Default;
    Sort(list, comparer, lowerBound, upperBound);
  }

  public static void Sort(IList<T> list, IComparer<T> comparer, int lowerBound, int upperBound)
  {
    if (lowerBound < upperBound)
    {
      int split = Partition(list, comparer, lowerBound, upperBound);
      Sort(list, comparer, lowerBound, split - 1);
      Sort(list, comparer, split + 1, upperBound);
    }
  }

  public static void Sort(IList<T> list,
                          Comparison<T> comparison,
                          int lowerBound,
                          int upperBound)
  {
    if (lowerBound < upperBound)
    {
      int split = Partition(list, comparison, lowerBound, upperBound);
      Sort(list, comparison, lowerBound, split - 1);
      Sort(list, comparison, split + 1, upperBound);
    }
  }
  
  static int Partition(IList<T> list,
                       IComparer<T> comparer,
                       int lowerBound,
                       int upperBound)
  {
    int left = lowerBound + 1;
    int right = upperBound;

    T pivot = list[lowerBound];
    T swap = default(T);

    while (left <= right)
    {
      while (left <= right && comparer.Compare(list[left], pivot) <= 0)
        left++;
      while (left <= right && comparer.Compare(list[right], pivot) > 0)
        right--;

      if (left < right)
      {
        swap = list[left];
        list[left] = list[right];
        list[right] = swap;
        left++;
        right--;
      }
    }

    swap = list[lowerBound];
    list[lowerBound] = list[right];
    list[right] = swap;
    return right;
  }

  static int Partition(IList<T> list,
                       Comparison<T> comparison,
                       int lowerBound,
                       int upperBound)
  {
    int left = lowerBound + 1;
    int right = upperBound;

    T pivot = list[lowerBound];
    T swap;

    while (left <= right)
    {

      while (left <= right && comparison(list[left], pivot) <= 0)
        left++;
      while (left <= right && comparison(list[right], pivot) > 0)
        right--;

      if (left < right)
      {
        swap = list[left];
        list[left] = list[right];
        list[right] = swap;
        left++;
        right--;
      }
    }

    swap = list[lowerBound];
    list[lowerBound] = list[right];
    list[right] = swap;
    return right;
  }
}

Er ist wirklich nur schnell auf Vorlage von irgendeinem Quicksort runtergerödelt, also kein Gewehr.

Benutzen kannst du ihn mit jeder IList<T> Implementierung (Die Java deklaration auf deren Seite sieht mir sehr nach einem generischen Container aus ):

Code:

ObjectSet<Person> os = oc.Get(prs); 
QuickSorter<Person>.Sort(os, delegate(Person left, Person right)
                             { return left.Name.CompareTo(right.Name); });