✔ Überladenes Equals wird nicht aufgerufen

[engelmarkus]

Wenn das ein Bug ist, dann nicht in Visual Studio, sondern im .Net Framework 1.1. Da wirst du auch mit einer teureren als der Professional Version nicht weiterkommen.

Jetzt im .Net Framework 2 kannst du ja außerdem irgendwas aus Collections.Generic hernehmen, dann erledigt sich das Problem von alleine, oder?

 

[jokey2]

Jetzt im .Net Framework 2 kannst du ja außerdem irgendwas aus Collections.Generic hernehmen, dann erledigt sich das Problem von alleine, oder?

Das habe ich auch getan. Ich probiere es gerade mit einer generischen Liste List<T> aus. Allerdings habe ich da jetzt das Problem mit der Find-Methode. Das mit diesen Predicates gefällt mir gar nicht. Wieso kann ich nicht einfach in der find-Methode ein Objekt angeben, nach dem in der Liste mittels der Equals-methode gesucht wird?

 

[Kyoko]

Warum überprüfst du nicht einfach mit Contains, ob das von dir gesucht enthalten ist?

 

[jokey2]

1.: Das tue ich an anderer Stelle
2.: An dieser Stelle möchte ich das Element mit diesem Namen aus der Liste haben und nicht nur prüfen, ob es vorhanden ist. Ich hab's jetzt mit anonymen Predicates in einer eigenen Suchfunktion gemacht. Aber wirklich gefallen tut mir das immer noch nicht.

 

[Kyoko]

Das Element mit diesem Namen aus der Liste? Ein Element in einer Liste hat doch gar keinen Namen, bist du dir sicher, dass du nicht Dictionary<TKey, TValue> verwendest?

Aber auch da würd das mit Contains funktionieren:

if (objDictionary.ContainsKey("Blubb"))
    irgendnevariable = objDictionary["Blubb"];

Nur mal so als Beispiel.

 

[Spyke]

Kyoko jokey meint List<T> nicht Dictionary<TKey, TValue>

Und jokey du könntest ja jetzt mal die Schnittstelle IEquatable<T> ausprobieren.

 

[jokey2]

Was bringt mir die Schnittstelle denn? Kann ich dann auch direkt mit der Klasse bzw mit string vergleichen? Ich werd's mal ausprobieren. auch wenn es ja mit der Equals(object)-Methode jetzt funktioniert.

Kyoko jokey meint List<T> nicht Dictionary<TKey, TValue>

Exakt. Und die Objekte in der Liste haben einen Namen. Ich wollte ja nur mal äußern, daß mir das mit dem Suchen in der Liste mittels Predicate nicht sehr gefällt. In einer anständigen generischen Liste sollte es eine Find-Methode geben, bei der man das zu suchende Objekt angibt und die dieses dann mittels der Equals-Methode findet. So wie das ja z.B. in der C++ STL auch geht. Da funktioniert das mit dem '=='-Operator, den man entsprechend überladen kann.

 

[engelmarkus]

Aber durch diese Predicates hast du (eigentlich) nur Vorteile. Mal angenommen, du willst nicht exakte Übereinstimmungen finden, sondern nur nach Teilstrings suchen, dann wirds ohne die Predicates doch wesentlich komplizierter.

        l.Add("Hallo, du")
        l.Add("Wie gehts dir")
        l.Add("Mir gehts gut")

        Dim s = l.Find(Function(x) x = "Hallo, du")

        l.Add("Hallo, du")
        l.Add("Wie gehts dir")
        l.Add("Mir gehts gut")

        Dim ss = l.Find(Function(x) x.Contains("du"))

Oder täusche ich mich da? Man hat sich eigentlich schnell an diese Schreibweise gewöhnt.

 

[jokey2]

Wenn man das so schreibt, dann sieht es tatsächlich besser aus. In C# sieht das allerdings etwas anders aus. Zuerst hatte ich eine Suchfunktion so implementiert:

private CSyncOrder FindSyncOrder(string Name)
{
    Predicate<CSyncOrder> FindSOPred = delegate(CSyncOrder SO)
    {
        return SO.Equals(Name);
    };
    return m_listSyncOrders.Find(FindSOPred);
}

Nach Deiner Anregung habe ich es etwas umformuliert:

CSyncOrder SOFind = m_listSyncOrders.Find(delegate(CSyncOrder SO){return SO.Equals(Name);});

Du hast natürlich Recht, wenn du sagst, daß dadurch die Suchmöglichkeiten erweitert werden.
Wirklich schön sieht das allerdings nicht aus. Gibt es da in C# noch andere Schreibweisen?
Am besten wäre es natürlich, wenn es beide Möglichkeiten gäbe: Eine Find-Methode mit Delegat und eine mit dem Objekttyp als Parameter, welche dann die Equals-Methode aufruft. Aber darüber kann man ewig fruchtlos diskutieren. Und am Ende müßte es von MS implementiert werden (wenn ich mir nicht eine eigene generische Listenklasse ableiten will). Ich kann ja mal ne Anregung nach Redmond schicken. ;-)

 

[engelmarkus]

Da kriegt man ja einen Schreikrampf

So geht das richtig:

            List<string> l = new List<string>();

            l.Add("Hallo, du");
            l.Add("Wie gehts dir");
            l.Add("Mir gehts gut");

            var s = l.Find(x => x == "Hallo, du");

            Console.WriteLine(s);
            Console.ReadKey();

bzw

            List<string> l = new List<string>();

            l.Add("Hallo, du");
            l.Add("Wie gehts dir");
            l.Add("Mir gehts gut");

            var s = l.Find(x => x.Contains("du"));

            Console.WriteLine(s);
            Console.ReadKey();

Am besten suchst du mal nach "C# 3.0", "Lambda Expressions", "LINQ", "Anonymous Types". Dann hast du gleich die neuen Sprachfeatures beieinander. ;-)

In LINQ-Schreibweise (die sollte leichter verständlich sein):

            List<string> l = new List<string>();

            l.Add("Hallo, du");
            l.Add("Wie gehts dir");
            l.Add("Mir gehts gut");

            var s = from eintrag in l where eintrag.Contains("du") select eintrag;

            Console.WriteLine(s.FirstOrDefault());
            Console.ReadKey();