[c#] interface implementation probleem

[Verwijderd]

Ik ben een (hele simpele) datamapper aan het in elkaar knutselen om mn asp.net / c# wat bij te vijzelen, nou loop ik echter tegen wat issues aan met interface implementation.

Ik heb een IMapper interface:

C#:

    public interface IMapper
    {
        void update(AbstractDomainObject obj);
        void insert(AbstractDomainObject obj);
        void delete(AbstractDomainObject obj);
    }

En een AbstractMapper class als volgt:

C#:

    public abstract class AbstractMapper<T> : IMapper where T : AbstractDomainObject
    {
        public void update(T obj)
        {
            // update obj
        }
        public void insert(T obj)
        {
            // insert obj
        }
        public void delete(T obj)
        {
            // delete obj
        }
    }

AbstractDomainObject class:

C#:

    public abstract class AbstractDomainObject : ICloneable
    {
        // implementatie van ICloneable en wat basic object state management shizzle
    }

Als ik de zaak probeer te compileren zegt ie nu dat ik de methodes update, insert en delete van
IMapper niet implementeer. Maar dat doe ik toch wel, want ik geef aan dat het generieke object T een afgeleide is van AbstractDomainObject?

[whoami]

Nee, dat doe je niet want je method signature van je class stemt niet overeen met de signature van die methods in de interface.

Je legt in je abstract class wel op dat het type T moet overerven van AbstractDomainObject, maar de compiler zal dat gewoon niet toestaan.
Net zoals hij dit ook niet zal toestaan:

code:

public class Customer : AbstractDomainObject
{
  // ...
}

interface IMapper
{
   void update(AbstractDomainObject o);
}

public CustomerMapper
{
   public void update( CustomerDomainObject obj )
   {
   }
}

[Verwijderd]

whoami schreef op woensdag 28 december 2005 @ 18:32:
Nee, dat doe je niet want je method signature van je class stemt niet overeen met de signature van die methods in de interface.

Je legt in je abstract class wel op dat het type T moet overerven van AbstractDomainObject, maar de compiler zal dat gewoon niet toestaan.
Net zoals hij dit ook niet zal toestaan:
[..]

Hoe moet ik dat dan implementeren? Zie het licht even helemaal niet meer. Dit leek me net zo'n fijne manier om de domein objecten los te trekken van de mapper-implementaties.

[ Voor 10% gewijzigd door Verwijderd op 28-12-2005 18:38 ]

[whoami]

Je zal de signature in de abstractmapper class moeten wijzigen, zodanig dat er een AbstractDomainObject als parameter meegenomen wordt.

Ik zie echter niet in, waarom je in die abstractmapper gebruik gaat maken van generics ?

[Verwijderd]

whoami schreef op woensdag 28 december 2005 @ 18:39:
Je zal de signature in de abstractmapper class moeten wijzigen, zodanig dat er een AbstractDomainObject als parameter meegenomen wordt.

Ik zie echter niet in, waarom je in die abstractmapper gebruik gaat maken van generics ?

Het leek me wel handig omdat je dan weer heel makkelijk zoiets kunt doen:

C#:

PersonMapper : AbstractMapper<Person> // Person : AbstractDomainObject

En dan kan de abstractmapper een heleboel 'algemene' mapping code herbergen, zodat dat niet dubbel wordt uitgevoerd in de concrete classes.

[ Voor 27% gewijzigd door Verwijderd op 28-12-2005 18:47 ]

[whoami]

'Algemene mapping code', zoals ?
Waarom heb je dan je 'Person' class nodig in je AbstractMapper als je daar enkel 'algemene' mapping gaat doen ?
Als je die Person nodig hebt in je abstract-mapper, dan wil dat zeggen dat je ook specifieke dinges gaat uitvoeren mbt die Person .

[Verwijderd]

whoami schreef op woensdag 28 december 2005 @ 18:49:
'Algemene mapping code', zoals ?
Waarom heb je dan je 'Person' class nodig in je AbstractMapper als je daar enkel 'algemene' mapping gaat doen ?
Als je die Person nodig hebt in je abstract-mapper, dan wil dat zeggen dat je ook specifieke dinges gaat uitvoeren mbt die Person .

Bijvoorbeeld zoiets (?):

C#:

        // pseudocode

        protected List<T> findMany(DbCommand selectCommand)
        {
            haal dataset uit database met behulp van selectCommand

            List<T> list = new List<T>();
            foreach (DataRow row in dataset.Tables["Table"].Rows)
            {
                // getObjectFromDataRow(row) zou dan in de concrete mappers worden geimplementeerd

                T obj = getObjectFromDataRow(row);

                list.Add(obj);
            }

            return list;
        }

edit:
ik ben ook maar pas een paar weken OOP aan het leren, dus als ik hier gewoon slap zit te lullen, mag je me daar gerust op wijzen

[ Voor 16% gewijzigd door Verwijderd op 28-12-2005 18:58 ]

[whoami]

Je zal zowiezo in je abstractmapper je method signatures moeten veranderen zodanig dat ze een 'AbstractDomainObject' nemen, en geen 'T'.

Ik zie niet direct in waarom je een 'T' zou nodig hebben in die update / insert / delete methods van je abstract-mapper, maar, mocht dat nodig zijn, dan kan je je abstractdomainobject nog altijd casten naar een 'T'

[Verwijderd]

whoami schreef op woensdag 28 december 2005 @ 19:01:
Je zal zowiezo in je abstractmapper je method signatures moeten veranderen zodanig dat ze een 'AbstractDomainObject' nemen, en geen 'T'.

Ik zie niet direct in waarom je een 'T' zou nodig hebben in die update / insert / delete methods van je abstract-mapper, maar, mocht dat nodig zijn, dan kan je je abstractdomainobject nog altijd casten naar een 'T'

Het lijkt mij vooral handig omdat je dan overal met strongly-typed lists kunt werken en je niet de hele tijd dingen heen en weer hoeft te casten? Maar zoals ik al zei, goede kans dat ik er helemaal verkeerd naar zit te kijken

[ Voor 16% gewijzigd door Verwijderd op 28-12-2005 19:12 ]