Instanzen vergleichen mit eigener Methode

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 19 Antworten in diesem Thema. Der letzte Beitrag () ist von VaporiZed.

    Instanzen vergleichen mit eigener Methode

    Hallo,

    ich habe eine Klasse deren Instanzen ich in List(Of )s sammle. Jetzt würde ich gerne in der Klasse festlegen, wann eine Instanz einer anderen gleicht, sodass ich in meiner Liste herausfinden kann, ob mehrere gleiche Elemente enthalten sind.
    Wie muss man sowas umsetzen?

    In der Enumerable.Distinct Methode gibt es eine Überladung, die mir so aussieht als könnte man dort eigene Kriterien festlegen, nur hab ich das mit der IEqualityComparer Schnittstelle noch nicht begriffen. Der dort angegebene "comparer" könnte der ein Bestandteil der Klasse werden oder muss das ein separates Objekt sein?

    Edit:
    Pseudo

    VB.NET-Quellcode

    1. Friend Class Oberklasse
    2. Friend Property Zuordnung
    3. Sub New(input)
    4. SetZuordnung(input)
    5. End Sub
    6. Friend Function IchbindieseInstanz As ???
    7. ???
    8. End Function
    9. End Class
    11. Friend Class Zuordnung
    12. Friend Property Länge As Single
    13. Friend Property Breite As Single
    14. Friend Property Typ As String
    15. End Class
    17. Sub Main
    18. Dim lst as New List(Of Oberklasse)
    19. lst.Add(New Oberklasse(input1))
    20. lst.Add(New Oberklasse(input2))
    21. Console.Writeline((lst.Count = lst.SpecialDistinct.Count).ToString)
    22. End Sub



    Viele Grüße

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „Haudruferzappeltnoch“ ()

    Hallo,
    der mMn bessere Weg ist, deine Klasse implementiert IEquatable<T>, IComparable und IComparable<T>. Damit kannst du a) deine Kriterien einfach festlegen, wann ein Objekt gleich ist und b) so ganz leicht IEnumerable.Distinct verwenden.
    Beispiel:
    Achtun, ich habe den Code von C# nach VB umgewandelt. Keine Garantie, dass der so direkt funktioniert.
    Spoiler anzeigen
    ​

    VB.NET-Quellcode

    1. ​Friend Class MyT
    2. Implements IEquatable(Of MyT), IComparable, IComparable(Of MyT)
    3. Public Property Width As Integer
    4. Public Property Height As Integer
    6. Public Function CompareTo(ByVal other As MyT) As Integer
    7. If other Is Nothing Then
    8. Return 1
    9. End If
    11. If Width <> other.Width Then
    12. If Width > other.Width Then
    13. Return 1
    14. Else
    15. Return -1
    16. End If
    17. End If
    19. If Height <> other.Height Then
    20. If Height > other.Height Then
    21. Return 1
    22. Else
    23. Return -1
    24. End If
    25. End If
    26. Return 0
    27. End Function
    29. Public Function CompareTo(ByVal obj As Object) As Integer
    30. If obj Is Nothing Then
    31. Return 1
    32. End If
    34. Dim other As MyT = TryCast(obj, MyT)
    35. If other Is Nothing Then
    36. Return 1
    37. End If
    39. If Width <> other.Width Then
    40. If Width > other.Width Then
    41. Return 1
    42. Else
    43. Return -1
    44. End If
    45. End If
    47. If Height <> other.Height Then
    48. If Height > other.Height Then
    49. Return 1
    50. Else
    51. Return -1
    52. End If
    53. End If
    54. Return 0
    55. End Function
    57. Public Overloads Function Equals(ByVal other As MyT) As Boolean
    58. If other Is Nothing Then Return False
    60. If Width <> other.Width OrElse Height <> other.Height Then Return False
    62. Return True
    63. End Function
    65. Public Overrides Function Equals(ByVal obj As Object) As Boolean
    66. Dim other As MyT = TryCast(obj, MyT)
    67. If other Is Nothing Then
    68. Return False
    69. End If
    71. If Width <> other.Width OrElse Height <> other.Height Then Return False
    73. Return True
    74. End Function
    76. Public Overrides Function GetHashCode() As Integer
    77. Dim accumulator = 0
    79. accumulator = accumulator Or (Width And &H0000000F) << 28
    80. accumulator = accumulator Or (Height And &H000000FF) << 20
    82. Return accumulator
    83. End Function
    84. End Class



    Spoiler anzeigen

    VB.NET-Quellcode

    1. ​Dim l As List(Of MyT) = New List(Of MyT)()
    2. l.Add(New MyT() With {
    3. .Width = 1,
    4. .Height = 2
    5. })
    6. l.Add(New MyT() With {
    7. .Width = 1,
    8. .Height = 2
    9. })
    10. l.Add(New MyT() With {
    11. .Width = 4,
    12. .Height = 2
    13. })
    14. l.Add(New MyT() With {
    15. .Width = 2,
    16. .Height = 3
    17. })
    18. l.Add(New MyT() With {
    19. .Width = 6,
    20. .Height = 2
    21. })
    23. Dim distinctList = l.Distinct()

    Ich weiß ja nicht, wie Du das konkret einsetzen willst, aber die gewünschte Funktion IchbindieseInstanz ließe sich so machen:

    VB.NET-Quellcode

    1. Friend Function IchbindieseInstanz(Oberklasseninstanz As Oberklasse) As Boolean
    2. Return Me Is Oberklasseninstanz
    3. End Function

    ->

    VB.NET-Quellcode

    1. Dim Oberklasseninstanz1 As New Oberklasseninstanz
    2. Dim Oberklasseninstanz2 As New Oberklasseninstanz
    3. MessageBox.Show(Oberklasseninstanz1.IchbindieseInstanz(Oberklasseninstanz1).ToString)
    4. MessageBox.Show(Oberklasseninstanz1.IchbindieseInstanz(Oberklasseninstanz2).ToString)
    5. MessageBox.Show(Oberklasseninstanz2.IchbindieseInstanz(Oberklasseninstanz1).ToString)
    6. MessageBox.Show(Oberklasseninstanz2.IchbindieseInstanz(Oberklasseninstanz2).ToString)


    Ansonsten reicht ggf auch schon das Überladen der entsprechenden Operatoren:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Friend Class FrmMain
    2. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    3. Dim Foo1 As Foo = Nothing
    4. Dim Foo2 As Foo = Nothing
    5. If Foo1 = Foo2 Then Stop 'stoppt
    6. Foo1 = New Foo
    7. If Foo1 = Foo2 Then Stop
    8. Foo2 = New Foo
    9. If Foo1 = Foo2 Then Stop 'stoppt
    10. Foo1.Bar = "asd"
    11. If Foo1 = Foo2 Then Stop
    12. Foo2.Bar = "asd"
    13. If Foo1 = Foo2 Then Stop 'stoppt
    14. End Sub
    16. Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
    17. Dim Foo1 As Foo = Nothing
    18. Dim Foo2 As Foo = Nothing
    19. If Foo1 <> Foo2 Then Stop
    20. Foo1 = New Foo
    21. If Foo1 <> Foo2 Then Stop 'stoppt
    22. Foo2 = New Foo
    23. If Foo1 <> Foo2 Then Stop
    24. Foo1.Bar = "asd"
    25. If Foo1 <> Foo2 Then Stop 'stoppt
    26. Foo2.Bar = "asd"
    27. If Foo1 <> Foo2 Then Stop
    28. End Sub
    29. End Class
    31. Friend Class Foo
    32. Property Bar As String
    34. Public Overloads Shared Operator =(F1 As Foo, F2 As Foo) As Boolean
    35. If F1 Is Nothing AndAlso F2 Is Nothing Then Return True
    36. If F1 Is Nothing OrElse F2 Is Nothing Then Return False
    37. Return F1.Bar = F2.Bar
    38. End Operator
    40. Public Overloads Shared Operator <>(F1 As Foo, F2 As Foo) As Boolean
    41. Return Not F1 = F2
    42. End Operator
    44. End Class


    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    @Haudruferzappeltnoch Wenn Du Instanzen von Klassen vergleichen willst, bau Dir eine Klasse, wie sie von @ISliceUrPanties vorgeschlagen wurde.
    Ich hab sie mal etwas getunt:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class MyT
    2. Implements IEquatable(Of MyT), IComparable, IComparable(Of MyT)
    3. Public Property Width As Integer
    4. Public Property Height As Integer
    6. Public Function Equals(other As MyT) As Boolean Implements IEquatable(Of MyT).Equals
    7. If other Is Nothing Then Return False
    8. Return Width = other.Width AndAlso Height = other.Height
    9. End Function
    11. Public Function CompareTo(obj As Object) As Integer Implements IComparable.CompareTo
    12. Dim other As MyT = TryCast(obj, MyT)
    13. Return Me.CompareTo(other)
    14. End Function
    16. Public Function CompareTo(other As MyT) As Integer Implements IComparable(Of MyT).CompareTo
    17. If other Is Nothing Then
    18. Return 1
    19. End If
    21. If Width <> other.Width Then
    22. Return Width.CompareTo(other.Width)
    23. End If
    25. If Height <> other.Height Then
    26. Return Height.CompareTo(other.Height)
    27. End If
    28. Return 0
    29. End Function
    30. End Class
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Kommt immer drauf an was man will.
    Wenn man richtig wasserdicht, komfortabel und ohne Überraschungen vergleichbarkeit implementieren will, muss man IComparable, IComparable(Of T), IEquatable, IEquatable(Of T) implementieren, und zusätzlich die Operatoren <, >, <>, =, >=, <= überladen.
    Und Gethashcode() überschreiben, damit Gleichheit auch in einem Dictionary richtig festgestellt wird.
    Ehrlich gesagt, ich back da lieber kleinere Brötchen, und sortiere und vergleiche einfach mit einer Comparison(Of T). Sone Comparison kann man auch Shared iwo statisch bereitstellen, dass das einfürallemal geklärt ist.
    Hat den Vorteil, dass man auch andere Comparison(Of T) definieren kann, und dann sortierts halt anders.

    Ja das ich mir da eine Schnittstelle reinholen muss habe ich schon gedacht. Ich arbeite mich da mal rein. Meine Funktion ist in der Hinsicht Käse gewesen.
    Das Überschreiben der Operatoren verstehe ich; wenn jemand einen Vergleich machen möchte ist ja nicht unbedingt klar, was er benutzt.
    Ich benötige in dem Sinne noch keine umfangreiche Vergleichbarkeit, mir reicht es wenn List(Of MyClass).Distinct nach anderen Regeln funktioniert.(Dafür brauchts ja eventuell doch umfangreiche Vergleichbarkeit)

    Die IEquatable ohne (Of T) finde ich gar nicht. Den Unterschied zwischen IComparable und IComparable(Of T) verstehe ich nicht ganz. IComparable ist zum vergleichen mit allem Möglichem IComparable(Of T) zum Vergleich zwischen T-Instanzen? Aber im Beispiel von IComparable wird das Vergleichsobjekt einfach versucht auf T zu casten. Ab dem Punkt ist es ja dasselbe, ich schätze das ist relevant für Vererbung.

    Ich schätze mal Distinct sortiert vorher für die Effizienz und braucht daher IComparable? Ich hab es mal versucht nach meinen Verständnis nachzubilden, allerdings funktioniert es noch nicht, ich übersehe noch etwas.
    Edit: Mit eigenem Loop funktionierts

    Versuch

    VB.NET-Quellcode

    1. Friend Class Oberklasse
    2. Implements IEquatable(Of Oberklasse)
    3. Implements IComparable(Of Oberklasse)
    4. Implements IComparable
    6. Friend Property ZuOrd As Zuordnung
    7. Sub New(length As Single, width As Single, kind As String)
    8. ZuOrd = New Zuordnung With {.Länge = length, .Breite = width, .Typ = kind}
    9. End Sub
    11. Public Overloads Function Equals(other As Oberklasse) As Boolean Implements IEquatable(Of Oberklasse).Equals
    12. If other Is Nothing Then Return False
    13. Dim tolerance As Single = 5.0
    14. Return Math.Abs(ZuOrd.Länge - other.ZuOrd.Länge) < tolerance AndAlso Math.Abs(ZuOrd.Breite - other.ZuOrd.Breite) < tolerance AndAlso ZuOrd.Typ <> other.ZuOrd.Typ
    15. End Function
    16. Public Overrides Function Equals(other As Object) As Boolean
    17. Return False
    18. End Function
    20. Public Function CompareTo(other As Oberklasse) As Integer Implements IComparable(Of Oberklasse).CompareTo
    21. If other Is Nothing Then Return 1
    22. If Me.Equals(other) Then
    23. Return 0
    24. Else
    25. Dim a = ZuOrd.Länge - other.ZuOrd.Länge
    26. If a > Zuordnung.tolerance Then
    27. Return 1
    28. ElseIf a < -Zuordnung.tolerance Then
    29. Return -1
    30. Else
    31. Dim b = ZuOrd.Breite - other.ZuOrd.Breite
    32. If b > Zuordnung.tolerance Then
    33. Return 1
    34. ElseIf b < -Zuordnung.tolerance Then
    35. Return -1
    36. Else
    37. Return 0 'Gleiche Größen, gleicher Typ
    38. End If
    39. End If
    40. End If
    41. End Function
    43. Public Function CompareTo(obj As Object) As Integer Implements IComparable.CompareTo
    44. Return 1
    45. End Function
    46. End Class
    48. Friend Class Zuordnung
    49. Friend Property Länge As Single
    50. Friend Property Breite As Single
    51. Friend Property Typ As String
    52. End Class
    54. Sub Main()
    55. Dim lst As New List(Of Oberklasse)
    56. lst.Add(New Oberklasse(50.0, 49.9, "a"))
    57. lst.Add(New Oberklasse(50.0, 50.0, "b"))
    58. lst.Sort()
    59. Dim test As Boolean = True
    60. For i = 0 To lst.Count - 2
    61. If lst(i).Equals(lst(i + 1)) Then test = False : Exit For
    62. Next
    63. Console.WriteLine(test.ToString)
    64. Console.ReadKey()
    65. End Sub

    Dieser Beitrag wurde bereits 8 mal editiert, zuletzt von „Haudruferzappeltnoch“ ()

    IEquatable gibt's auch nicht untypisiert, also ohne Of T.

    Haudruferzappeltnoch schrieb:

    IComparable ist zum vergleichen mit allem Möglichem IComparable(Of T) zum Vergleich zwischen T-Instanzen
    richtig; Da ältere Konstrukte vor Einführung von Generika (also mit diesem Of T) existierten und die auch Dinge vergleichen woll(t)en, gab es da nur die untypisierte Object-Variante. Die Of T-Varianten machen den Umgang leichter, kamen allerdings eben erst später.

    Haudruferzappeltnoch schrieb:

    im Beispiel von IComparable wird das Vergleichsobjekt einfach versucht auf T zu casten. Ab dem Punkt ist es ja dasselbe
    Genau. Der alte Rumpf wird genommen und zu dem neuen Kram kompatibel gemacht. Mit Vererbung hat das jetzt weniger zu tun als mit Abwärtskompatibilität.

    Wenn Du tiefergreifende/fortgeschrittene Vergleiche machen willst/wirst, solltest Du Dich weiter damit beschäftigen. Aber Dein Codebeispiel würde ich noch mit einer einfachen, "manuellen" Funktion umsetzen (also so, wie Du selbst vorgeschlagen hast) und gar nicht mit Distinct arbeiten.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Ja ich habe es gerade probiert. Habe oben das Distinct ersetzt, so funktioniert es schon.

    Nachtrag: Eine Frage hätte ich noch

    VB.NET-Quellcode

    1. Public Overloads Function Equals(other As Oberklasse) As Boolean Implements IEquatable(Of Oberklasse).Equals
    2. End Function

    Wenn ich hier das Overloads weglasse sagt mir das Studio die Funktion führt Shadowing durch und empfiehlt Overrides. Mit Overrides sagt das Studio es gibt keine Funktion die überschrieben werden kann. Das klingt widersprüchig, was bedeutet das?

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „Haudruferzappeltnoch“ ()

    Haudruferzappeltnoch schrieb:

    Ja das ich mir da eine Schnittstelle reinholen muss habe ich schon gedacht.
    Was ich sage ist aber das Gegenteil:
    Sortieren, insbesondere Sortieren nach beliebigen Kriterien, geht viel einfacher ohne dieses Schnittstellen-Gehampel - einfach einer List(Of T).Sort() - Überladung eine Comparison mitgeben, dann sortiert sie unter Anwendung der angegebenen VergleichsRegel.
    Geht natürlich nicht immer. Bei Dingen aus der Steinzeit (DatagridViewSorter) muss man leider tun, was da an Umständlichkeiten verlangt ist.
    Oder man verwendet DGV datengebunden - dann kann man über bindingSource.Sort sortieren.

    Du hast ja nicht nur vom Comparison geredet.
    Ja das ist schon einfacher. Für mich hat das zu sortierende Objekt eine Eigenschaft, die es als sortierbar auszeichnet. Ich fand die Schnittstelle ist vom Modell da schonmal nah dran.

    Aber sortieren reicht mir ja nicht (Die Sortierung macht nur den Prozess, den ich benötige effizienter), also die IEquatable Schnittstelle brauche ich in jedem Fall, weil es einen Fall gibt in dem der Comparer nicht entscheiden kann welches Element größer oder kleiner ist, sie sind nur nicht gleich. Das ist ganz ähnlich mit komplexen Zahlen, die haben keine Anordnung, können sich aber unterscheiden.

    Haudruferzappeltnoch schrieb:

    sie sind nur nicht gleich.
    Meinst Du, dass zwei Instanzen derselben Klasse mit gleichem Inhalt als verschieden erkannt werden sollen?

    VB.NET-Quellcode

    1. Dim a = New WhatEver(1, 2, 3)
    2. Dim b = New WhatEver(1, 2, 3)
    3. If a.Equals(b) Then
    4. MessageBox("Gleich")
    5. Else
    6. MessageBox("nicht Gleich")
    7. End If
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Haudruferzappeltnoch schrieb:

    weil es einen Fall gibt in dem der Comparer nicht entscheiden kann welches Element größer oder kleiner ist
    Verstehe ich nicht.
    wenn ein Comparer comparen kann, dann ist damit auch ein Gleichheits-Zustand definiert.
    Nämlich wenn die Compare-methode 0 return.
    Achso - sorry: er kann ja nicht Comparen. (komischer comparer)

    Ja ok. Also ich habe Element A und Element B.
    Der Comparer hat also die Möglichkeit A>B return 1, A<B return -1, A=B return 0

    In meinem Fall gibt es aber auch noch A<>B (Keins der obigen). Dann gibts auch 0. Und ich suche eine 0, aber welche 0 ist die richtige?
    Man muss hier das Ziel berücksichtigen, dass ein Comparer nicht compared hab ich nicht gesagt.

    Nein, dann ist die Compare-Verwendung aber unsinnig. Ungleich ist so ziemlich vieles. Nämlich alles, was nicht gleich ist. Bedenke, worum es geht: Sortierung. Wenn Du zwei Dinge sortieren sollst, die einfach "ungleich" sind, aber weder A > B noch A < B, und Dein Chef von Dir verlangt, dass Du die trotzdem sortieren sollst, wie willst Du dann entscheiden, was zuerst kommt? Was bedeutet denn in Deinem Fall "ungleich"? Zwei verschiedene Objekte? Also irgendwas stimmt da noch nicht vom Ablauf.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Nein es stimmt alles. Das ist ja der Punkt^^
    Mein Problem ist gelöst und ich wollte nur mitteilen warum ich es nicht nur mit einer Comparison lösen konnte, ich hab es ja versucht. Da wie Edr schon sagte das die einfachere Lösung ist.

    Sortieren ist fein was die Elemente angeht die tatsächlich größer oder kleiner sind. Für die anderen Elemente brauche ich keine Sortierung, diese müssen nur "entdeckt" werden. Die Sortierung hilft das Entdecken effizienter zu machen, es geht auch ganz ohne sortieren.

    Ich frage mich jetzt gerade, ob man das nicht auch mit einer Binary-Serialisierung hingekriegt hätte.
    Sind zwei Instanzen gleich sollte auch die gleiche Bytefolge entstehen.

    Wenn aber da zuerst irgendwelche Sachen sortiert werden müssen, dann wird es wahrscheinlich nicht gehen.

    Freundliche Grüsse

    exc-jdbi

    Ich kenn den Artikel.

    Ich finde es ein bisschen schade, dass die Binary-Serialisierung obsolate wird. Klar, wenn eine Binary-Serialisierung falsch angewendet wird, dann ist es gefährlich. Leider wird nicht genau beschrieben in der Dokumentation wie das gemeint ist.
    Net Standard hat vermutlich ganz neue Ansichten und hoch optimierte Möglichkeiten der strukturierten Daten auf sequenzielle Darstellungsform hervorgebracht.

    Als Alternative für die Binary-Serialisierung gibt es den DataContract-Serialisierer und XmlDictionaryWriter.CreateBinaryWriter(stream) bietet eine Binary-Version an. Die ist aber nicht direkt vergleichbar mit dem Binary-Formatter.

    Eine weitere Möglichkeit die ich gefunden habe, ist die MessagePack, eine sehr performante die gleichzeitig eine sehr kurze Bytefolge ausgibt. Und natürlich gibt es noch den Json-Serialisierer.

    Alle 3 Serialisierer sind schnell, und erfüllen in dem Sinne den Zweck der Serialisierung. Ob die für den Vergleich von Objekten herangezogen werden können müsste man zuerst ausprobieren.

    EDIT: Zuordnung.tolerance habe ich nicht gesehen. Da wäre die Lösung #6 wohl die beste vorgehensweise.

    Freundliche Grüsse

    exc-jdbi

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „exc-jdbi“ ()

    Ich glaube nicht, dass das mit BinarySerialisierung überhaupt geht. Ich hatte das früher mal versucht, aber zwei Klasseninstanzen mit identischen Daten wurden (zurecht) als unterschiedliche Objekte betrachtet, daher flog das für mich raus. XML-Serialisierung flog für mich raus, weil ich da überall das <Serializable>-Attribut setzen musste. Oder war das beim Binary? Na wurscht, irgendwas hat mich ja eben auch genervt. Daher bin ich sehr zufrieden beim NewtonSoft-JSON-Serializer geblieben, den kann ich so einstellen, wie ich ihn brauche und kann dann sehr einfach die Daten vergleichen und mir (fast alle) Unterschiede anzeigen lassen.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

Facebook
Telefonspende