Generics und abgeleitete Klassen als Typparameter

Werte Kollegen,
warum ist m_friends.Add(s, t); nicht möglich???? checks nicht.
vielen Dank und gruss
lil

public class person 
{
     public string name { get; set; }
        
}

public class test<T> where T:person
{
        private Dictionary<string, test<person>> m_friends = new Dictionary<string, test<person>>();

        public void add<K>(string s, test<K> t) where K:person 
        {
            m_friends.Add(s, t);
        }
        
}

Welche .NET Version benutzt Du? 4.0?
Ist Person eine konkrete Klasse oder ein Interface? Mit Interface und .Net 4.0 sollte es gehen.

Welche .NET Version benutzt Du? 4.0?

ja genau, 4.0...

Welche .NET Version benutzt Du? 4.0?
Ist Person eine konkrete Klasse oder ein Interface? Mit Interface und .Net 4.0 sollte es gehen.

siehe oben... eine klasse

auch so.... doesn't work

 public interface iperson
    {
        string name{get;set;
    }

    public class person : iperson
    {
        public string name { get; set; }
        
    }

    public class test<T> where T:iperson
    {

        private Dictionary<string, test<iperson>> m_friends = new Dictionary<string, test<iperson>>();

        private Dictionary<string, iperson> m_others = new Dictionary<string, iperson>();
        //private Dictionary<string, T> m_others = new Dictionary<string, T>();
        
        public void add<K>(string s, test<K> t) where K:T
        {
            m_friends.Add(s, t);
        }


        public void AddOthers<K> (string s, person o)
        {
            m_others.Add(s, o);
        }

        

        
    }

Kannst du bitte die Fehlermeldung des Compilers des posten?

Der Grund ist Kovarianz und Kontravarianz in Generika.

Kannst du bitte die Fehlermeldung des Compilers des posten?

Fehlermeldung:
Error 27 The best overloaded method match for 'System.Collections.Generic.Dictionary<string,aviita.CAF.common.process.test<aviita.CAF.common.process.iperson>>.Add(string, aviita.CAF.common.process.test<aviita.CAF.common.process.iperson>)' has some invalid arguments C:\work\vs2010\Div_trunk\aviitaCAF\source\aviita.CAF.common\process\test.cs 30 13 aviita.CAF.common
Error 28 Argument 2: cannot convert from 'aviita.CAF.common.process.test<K>' to 'aviita.CAF.common.process.test<aviita.CAF.common.process.iperson>' C:\work\vs2010\Div_trunk\aviitaCAF\source\aviita.CAF.common\process\test.cs 30 30 aviita.CAF.common

Der Code macht so auch nicht wirklich Sinn. Du hast einen generischen Typ mit einem Dictionary welches auf den Basistyp verweist ( Person )

Danach willst du konkretere Ausprägungen in dieses Dictionary packen, welches aber eh nur die Basisklasse nach außen repräsentiert.

Warum also nicht die Methode folgendermaßen schreiben ?!

private Dictionary<string, test<person>> m_friends = new Dictionary<string, test<person>>();

            public void add( string s, test<person> p )
            {
                m_friends.Add( s,p );
            }

Es gibt keinen Unterschied selbst wenn es mit der Varianz funktionieren würde. In diesem Fall müsstest du halt ggf. Typprüfungen oder Casts machen.

Hallo Kroax,
ja du hast schon recht. das ganze ist ein stark vereinfachtes beispiel. denk dir einfach, das es x typen gibt die von person abgeleitet sind.
zb netteperson, boeseperson usw....
wir wollten das ganze typ-sicher haben. ansonsten kann man gleich auf generics verzichten.

Der Grund ist
> .

ja eben!
wenn gilt:

IEnumerable<Derived> d = new List<Derived>();
IEnumerable<Base> b = d;

dann gilt doch auch K:T also ist K eine person?!?

Das heißt du willst dann aber eigentlich das hier :

public class test<T> where T : person
        {
            private Dictionary<string, test<T>> m_friends = new Dictionary<string, test<T>>();

            public void add<K>( string s, test<K> p ) where K : person
            {
                m_friends.Add( s,p );
            }

        }

Ansonsten macht dein Beispiel leider keinen Sinn, da man das auch anders machen kann, wie ich eben beschrieben habe. Du kriegst ja aus einem bereits fest definierten Dictionary keinen anderen Typ zurück als der den du definiert hast

Aber ich fürchte eh das dein Vorhaben so nicht funktionieren wird