Liste von Generischer Klasse

Hallo,
ich habe eine Klasse etwa:

class myclass<T>
{
  public myclass(T oldval, T newval)
  {
  }
}

Ist es möglich, nun eine Liste von myclass<T> zu bekommen?

Mein ziel ist es, innerhalb eines Businessobjektes eine Liste der veränderungen der Propertys zu halten.

Geht das irgendwie oder muss ich myclass nicht generisch machen und mit object arbeiten?

Hi,

So weit mir bekannt ist das nicht möglich.
Da die Generischen Typen nicht von einander Erben sondern zur Laufzeit erzeugt werden (neben einander).

Gruß
Juy Juka

Hallo daniel,

du kannst jedoch ein Interface mit denselben Membern wie Myclass<object> erstellen und dieses in Myclass explizit implementieren.
Dann erhälst du zumindest die Typsicherheit, wenn du direkt mit Myclass<> arbeitest.

Hallo,
wie meinst du das mit dem Interface?
Das muss ja dann auch generisch sein: IMyClass<T>

Kannst du das vielleicht ein einem kl. beispiel verdeutlichen?
Danke

Also wenn ich das Problem richtig verstanden habe, meine ich das ungefähr so:

public class Myclass<T> : IMyInterface
{
    public T OldValue
    {
        //getter + setter
    }
    public T NewValue
    {
        //getter + setter
    }

    public void TueWas()
    {
        throw new NotImplementedException();
    }


    object IMyInterface.OldValue
    {
        get
        {
            return this.OldValue;
        }
        set
        {
            if (!(value is T))
                throw new ArgumentException();

            this.OldValue = (T)value;
        }
    }

    object IMyInterface.NewValue
    {
        get
        {
            return this.NewValue;
        }
        set
        {
            if (!(value is T))
                throw new ArgumentException();

            this.NewValue = (T)value;
        }
    }
}

public interface IMyInterface
{
    object OldValue
    {
        get;
        set;
    }
    object NewValue
    {
        get;
        set;
    }

    void TueWas();
}

Dann könntest du Myclass<T> Objekte in einer List<IMyInterface> speichern.

Hallo daniel,

Ist es möglich, nun eine Liste von myclass<T> zu bekommen?

hm, das ist doch ganz einfach, oder übersehe ich was: List<myclass<T>>.

herbivore

oder übersehe ich was: List<myclass<T>>.

Also ich habe das so verstanden, dass diese Liste Objekte enthalten soll, deren "T" verschieden ist.

Ja, du hast das schon richtig verstanden.

Wenn ich das mit T mache kommt "The type or namespace name 'T' could not be found.."

Ich hab mich jetzt damit etwas rumgespielt, um das zu testen und war gleich total erschrocken, als ich festgestellt habe, dass statische Variablen in einer anderen T Version der Klasse nicht mehr existieren(kann auch logisch so sein, wie mans halt auffasst).

Auf jedenfall ist es so, dass jede Variation von T eine neue (andere) Klasse erzeugt, die miteinander sonst nichts gemeinsam haben. Darum hab ich jetzt eine BasisKlasse dazu implementiert, die sich den alten und den neuen Wert von T merkt.

Übrigens T ist nur eine Typ und keine Variable.

    public class BaseTest
    {
        public static Type oldType;
        public static Type newType;

        public static List<Type> types = 
            new List<Type>();
    }

    public class Test<T> : BaseTest
    {
        public Test()
        {
            oldType = newType;
            newType = typeof(T);

            types.Add(newType);
        }

        public void TueEtwas()
        {
            Console.WriteLine(oldType + " " + newType);
        }
    }

Alternativ kann man statt einer BasisKlasse auch eine HilfsKlasse verwenden, die den Typ des alten und des aktuellen T's merkt. Nur die Klasse selbst kann es nicht.

Alternativ schnell eine HilfsVariante gepfuscht:

    public class TestHelper
    {
        public static Type oldType;
        public static Type newType;

        public static List<Type> types =
            new List<Type>();
    }

    public class Test<T>
    {
        public Test()
        {
            TestHelper.oldType = TestHelper.newType;
            TestHelper.newType = typeof(T);

            TestHelper.types.Add(TestHelper.newType);
        }

        public void TueEtwas()
        {
            Console.WriteLine(TestHelper.oldType + " " + TestHelper.newType);
        }
    }

Lg XXX