Nach Instanzierung eines generisches Typs mit Activator.CreateInstance: Methodenzugriff

Hallo!

Ich habe eine generische Methode mit zwei Generikas.
Ich möchte beide instanzieren und auf die Methoden des eigentlichen Typs zugreifen.
Die Instanz habe ich erstellt, doch wie komme ich auf die Methoden?

public bool Selection<T, U>(out Fehler fehler)
        {
            fehler = new Fehler();

            try
            {
                T sqlConnection = default(T);
                U sqlCommand = default(U);

                Type typConnection = typeof(T);
                Type typCommand = typeof(U);
                
                StringBuilder sb = new StringBuilder();
                sb.Append("SELECT * FROM ");
                sb.AppendLine(dbTable);

                object oConnection = Activator.CreateInstance(typConnection, new object[] { GetConnectionString(dbUser, dbPassword, dbServer, dbDatabase) });
                object oCommand = Activator.CreateInstance(typCommand, new object[] { sb.ToString(), oConnection });

                sqlConnection = (T)oConnection;
                sqlCommand = (U)oCommand;                

                return true;
            }
            catch(Exception ex)
            {
                fehler.Message = ex.Message;
                return false;
            }
        }

a: du zwingst mit einem constraint den generischen typ ein interface zu implementieren.
b: du zwingst den generischen typ über ein contraint einen bestimmten basistyp zu implementieren
c: reflection

edit: in deinem fall ist "b" vorzuziehen.

Folgende Typen können angenommen werden:

• SqlConnection oder OleDbConnection bzw.
• SqlCommand oder OleDbCommand

nimm lieber DbConnection und DbCommand

Ich verstehe nicht wieso du in diesem Fall Generika verwendest? Kannst du als Parameter nicht einfach DbConnection und DbCommand verwenden? Sollte doch dank Polymorphie funktionieren.

/Edit: Die Constraints, von denen Jack30Lena (der mal wieder schnell war) spricht, könnten übrigens so aussehen:

public bool Selection<T, U>(out Fehler fehler) where T : DbConnection where U: DbCommand {
    // ...
}

/Edit2: Aber wie gesagt, machs lieber nicht mit Generikas. 😉

gutes argument. hier sind generics wirklich fehl am platz.

nimm noch lieber IDbConnection und IDbCommand (das wäre dann allerdings die Variante a). Es sei denn du brauchst an einer Stelle wirklich die Methoden von DbConnection bzw. DbCommand.

Wenn du die Klassen auch instanziieren willst, dann empfiehlt es sich außerdem per TypeConstraint einen parameterlosen Konstruktor vorzuschreiben, dann kannst du den auch benutzen.

//edit: Beim Beispielcode sind die Generika wirklich überflüssig, ja

Hallo onlinegurke

nimm noch lieber IDbConnection und IDbCommand (das wäre dann allerdings die Variante a). Es sei denn du brauchst an einer Stelle wirklich die Methoden von DbConnection bzw. DbCommand.

DbXYZ sind neuer als die Interfaces und von Microsoft empfohlen, über den Interfaces.

Gruss Peter