[c#] Generic oplossing voor Equals van 2 onbekende objecten

[BasieP]

Beetje wazige topictitel misschien, maar ik leg het even uit.

Ik heb een situatie waarin ik classes genereer.
Al de gegenereerde classes erven over van een (eigen) baseclass.

nu wil ik een Equals() functie schrijven waarin ik kan zien of object1 gelijk is aan object2.
Echter is het type van object1 en object2 onbekend.

Dat wil zeggen. Ze zijn gegenereerd, erven over van de baseclass, maar ik wil ze vergelijken op specifieke gegevens.

resumé:
Class1 heeft property 'naam'
Class2 heeft property 'kleur'
Class3 heeft property 'x'
...
etc.

Ze erven allen over van baseclass.

Nu heb ik 2 van die objecten (wel allebij van dezelfde class, maar ik weet niet welke) en wil ik kijken of deze objecten gelijk zijn.

Mijn Class1 heeft de onderstaande functie:

C#:

public bool Equals(Class1 obj)
{
  return naam.Equals(obj.naam);
}

Echter kan ik deze niet aanroepen, omdat in mijn programma ik niet weet dat het een Class1 betreft.

Nu heb ik het volgende, wat wel werkt:

C#:

public class BaseClass
{
    public override bool Equals(object obj)
    {
        if (obj == null || GetType() != obj.GetType())
            return false;

        if (obj is Class1)
        {
            Class1 c1 = (Class1)this;
            Class1 c2 = (Class1)obj;

            return c1.Equals(c2);
        }
        else if (obj is Class2)
        {
            //...etc.
        }
        return false;
    }
}

public class Class1 : BaseClass
{
    public string naam;

    public bool Equals(Class1 obj)
    {
        return naam.Equals(obj.naam);
    }
}

class Program
{
    static void Main(string[] args)
    {
        //dus puur om te testen even wat objecten aanmaken
        Class1 c1_0 = new Class1();
        c1_0.naam = "bas";
        Class1 c1_1 = new Class1();
        c1_1.naam= "bas";


        //hier doen we dus alsof we niet meer weten wat het is.
        BaseClass b1 = c1_0;
        BaseClass b2 = c1_1;

        //en hier vergelijken we ze, wat dus goed gaat
        Console.WriteLine(b1.Equals(b2));
    }
}

Echter is wel duidelijk dat je zoiets met generics wilt oplossen.
Ik wil dus niet voor al mijn classes zeggen:

C#:

if (obj is Class1) { ... }
if (obj is Class2) { ... }
if (obj is Class3) { ... }

voordat mensen nu gaan roepen "je ontwerp is fout" etc., zal ik even iets meer uitleg geven:

Het gaat om class generatie adhv een database.
Ik wil de objecten cachen, en genereer daarom nu in alle classes een eigen caching mechanisme. Dit werkt prima, maar 99% van de code van het mechanisme komt in AL die classes terug.
Hierdoor vind ik mijn dll te groot worden, en ik wil dit op een ander niveau regelen. Zodoende wil ik op het niveau van de baseclass mijn caching code plaatsen, echter is die één procent code die wel class specifiek is nogal lastig te bouwen als ik niet weet welke class het is.
Ik weet namelijk niet of ik op naam moet vergelijken of op kleur of lengte of whatever..

Hoe vlieg je zoiets aan?

[Wijnbo]

Hele stomme vraag misschien, maar kun je die 99% zelfde code niet in de baseclass kiepen? En verder, je kunt toch gewoon kijken of je object van het zelfde type is? Op moment dat ze van het zelfde type zijn, ga je gewoon met reflection er door heen en kijk je naar alle property waarden etc...

In de baseclass:

Pseudo:

code:

boolean equals(object a)
{
  if not object a zelfde type als object b
  {
    return false
  }
  else
  {
    foreach alle properties van object a en vergelijk met property van b. ongelijk? exit for, return false.
    return true
  }
}

[Voor 87% gewijzigd door Wijnbo op 07-07-2011 13:04]

[BasieP]

Wijnbo schreef op donderdag 07 juli 2011 @ 13:00:
Hele stomme vraag misschien, maar kun je die 99% zelfde code niet in de baseclass kiepen?

euh ja daarvoor open ik dit topic.
Punt is dat ik niet weet hoe ik dan die 1% moet gaan doen

Je kunt toch gewoon kijken of je object van het zelfde type is? Op moment dat ze van het zelfde type zijn, ga je gewoon met reflection er door heen en kijk je naar alle property waarden etc...

Ja en nee.
Zoals ik al zei is het een caching voor objecten die uit DB komen.
Wat ik nu heb zijn 2 objecten. 1 oud, (uit cache) en 1 nieuw (uit DB)
Om te zorgen dat ik niet 2 versies van 1 object ga gebruiken in mijn applicatie wil ik deze vergelijken en als ze hetzelfde zijn de referenties naar object1 naar object2 laten wijzen of andersom.

Echter kan het zijn dat het nieuwe object anders is dan het oude, omdat het record in de DB in die tussentijd is gewijzigd.
De PK's van de objecten zijn echter wel hetzelfde, en daarop moet dus gecontroleerd worden. niet zomaar op 'alle property waarden'.

[Voor 57% gewijzigd door BasieP op 07-07-2011 13:05]

[BCC]

Ja, of implementeer in alle klasses naast deze equals functie een functie die expliciet een equals string oplevert. De implementatie kan je dan per klasse anders maken en defaulten in je base class.

code:

public class BaseClass 
{ 
    public override bool Equals(object obj) 
    { 
       return EqualsString.Equals(obj.EqualsString); 
    }

    public string EqualsString() 
    { 
        return ""; 
    } 
} 

public class Class1 : BaseClass 
{ 
    public string naam; 

    public override string EqualsString() 
    { 
        return naam; 
    } 
} 
}

Vraag is of je Equals wel wil overriden. Misschien kun je beter een LooksLike functie implementeren oid. Hangt af van de rest van de rest van je app.

En wat je dan aan het doen bent is ducktyping (handig voor google) Wikipedia: Duck typing

[Voor 73% gewijzigd door BCC op 07-07-2011 13:09]

[H!GHGuY]

Even googlen en je komt hierop uit:
http://weblogs.asp.net/tgraham/archive/2004/03/23/94870.aspx

[BasieP]

BCC schreef op donderdag 07 juli 2011 @ 13:02:
Ja, of implementeer in alle klasses naast deze equals functie een functie die expliciet een equals string oplevert. De implementatie kan je dan per klasse anders maken en defaulten in je base class.

code:

public bool Equals(Class1 obj) 
{ 
  return EqualsString.Equals(obj.EqualsString()); 
}

public string EqualsString()
{
  return name;
}

mja dat had ik niet helemaal duidelijk gezegt, maar soms zijn het meerdere objecten, die niet altijd string zijn.
Je hebt gewoon per gegenereerde class een PK.
Soms is dat een decimal, soms een integer, soms 2 integers, soms een int en een string.
Die wil je vergelijken.

H!GHGuY schreef op donderdag 07 juli 2011 @ 13:03:
Even googlen en je komt hierop uit:
http://weblogs.asp.net/tgraham/archive/2004/03/23/94870.aspx

Jij mag me SP nog een keer lezen. ik weet hoe je een normale Equals() implementeert. Dit is echter geen normale.


Waar ik zelf aan zit te denken is om de baseclass een list<object> Keys; te geven, en elke class deze te laten vullen met zijn eigen 'keys'.
De .Equals in de baseclass kan dan zoiets doen:

C#:

public override Equals(object obj)
{
    if (obj == null || GetType() != obj.GetType())
        return false;

    for (int i = 0; i< Keys.Count(); i++)
    {
        if (!Keys[i].Equals(obj.Keys[i]))
            return false;
    }
    return true;
}

[steffex]

BasieP schreef op donderdag 07 juli 2011 @ 13:21:

C#:

public override Equals(object obj)
{
    if (obj == null || GetType() != obj.GetType())
        return false;

    for (int i = 0; i< Keys.Count(); i++)
    {
        if (!Keys[i].Equals(obj.Keys[i]))
            return false;
    }
    return true;
}

krijg je met die for loop geen problemen als je Keys niet in dezelfde volgorde staan?

[Voor 39% gewijzigd door steffex op 07-07-2011 13:28]

[BasieP]

steffex schreef op donderdag 07 juli 2011 @ 13:28:
[...]


krijg je met die for loop geen problemen als je Keys niet in dezelfde volgorde staan?

ja, daarom moet de volgorde hetzelfde zijn, of ik moet er KeyValuePairs van maken..

[Roxors]

Om te zorgen dat ik niet 2 versies van 1 object ga gebruiken in mijn applicatie wil ik deze vergelijken en als ze hetzelfde zijn de referenties naar object1 naar object2 laten wijzen of andersom.

Kan je niet tijdens het aanmaken van een object in de constructor van dat object een GUID (ObjectId ofzo) aanmaken, zodat je deze later kunt vergelijken?

Echter kan het zijn dat het nieuwe object anders is dan het oude, omdat het record in de DB in die tussentijd is gewijzigd.
De PK's van de objecten zijn echter wel hetzelfde, en daarop moet dus gecontroleerd worden. niet zomaar op 'alle property waarden'.

Misschien is het handig om een hash van het object bij te houden en te vergelijken. Of on the fly berekenen en vergelijken.

Edit: Overigens neem ik aan dat je met caching bedoelt het cachen van de properties van een object, en niet het cachen van het hele object zelf? Anders had ik niet verwacht dat je je cache mechanisme in de classes zelf stopt.

[Voor 12% gewijzigd door Roxors op 07-07-2011 13:46]

[JaWi]

Als ik dit zo lees, dan zou ik in de Equals van je BaseClass alleen kijken of de te-vergelijken-object niet null is en van hetzelfde type, en dan deze Equals weer overriden in je specifieke subklasse, waar je eerst kijkt of de Equals van je superklasse "true" teruggeeft, en zo ja, dan kun je veilig casten naar je concrete subtype en de specifieke vergelijking doen.

Pseudo code:

C#:

public class BaseClass
{
    public override bool Equals(object obj)
    {
        if (obj == null || GetType() != obj.GetType())
            return false;
        return true;
    }
}
...
public class Class1 : BaseClass
{
    public string naam;

    public override bool Equals(object obj)
    {
        if (!base.Equals(obj))
           return false;

        return naam.Equals(((Class1)obj).naam);
    }
}

Of begrijp ik je TS (nog steeds) niet?

[Danot]

Er zal vast een goede reden zijn, maar ik ben benieuwd. Waarom gebruik je geen NHibernate of Entity Framework?

[BasieP]

JaWi schreef op donderdag 07 juli 2011 @ 13:51:
Als ik dit zo lees, dan zou ik in de Equals van je BaseClass alleen kijken of de te-vergelijken-object niet null is en van hetzelfde type, en dan deze Equals weer overriden in je specifieke subklasse, waar je eerst kijkt of de Equals van je superklasse "true" teruggeeft, en zo ja, dan kun je veilig casten naar je concrete subtype en de specifieke vergelijking doen.

Pseudo code:

C#:

public class BaseClass
{
    public override bool Equals(object obj)
    {
        if (obj == null || GetType() != obj.GetType())
            return false;
        return true;
    }
}
...
public class Class1 : BaseClass
{
    public string naam;

    public override bool Equals(object obj)
    {
        if (!base.Equals(obj))
           return false;

        return naam.Equals(((Class1)obj).naam);
    }
}

Of begrijp ik je TS (nog steeds) niet?

Nee ik denk dat jij me heel goed begrijpt.

Dit is inderdaad de oplossing.
Ik had op de een of andere manier in mijn hoofd dat je vanaf je programma eerst naar de baseclass moest, en dan pas naar je subclass, en dat kan niet omdat je niet weet welke dat is.

Dmv overerving van de Equals in zowel je baseclass als je subclass ga je natuurlijk eerst naar je subclass, waarin je dan wel weer je baseclass kunt aanroepen.

many thanks.

[RayNbow]

Je kunt het ook omdraaien. In plaats van dat de subclasses altijd de superclass methode aanroepen, kun je ook ervoor zorgen dat de superclass de subclass methode aanroept:

C#:

public abstract class Base
{
    public sealed override bool Equals(object obj)
    {
        return obj != null && GetType() == obj.GetType() && DoEquals(obj);
    }
        
    public abstract bool DoEquals(object obj);
}

public class Sub : Base
{
    public override bool DoEquals(object obj)
    {
        /* ... */
    }
}