Dynamische Erzeugung von Instanzen

[Herbert Illedits]

Hallo

Wie kann ich folgenden Delphi-Konstrukt in C# realisieren:

TKlasse = class(TObject);
TKlasseClass = class of TKlasse;

TKlasse1 = class(TKlasse);
TKlasse2 = class(TKlasse);
...

function CreateKlasse(KC: TKlasseClass): TKlasse;
begin
Result := KC.Create;
end;

procedure Run;
var
K: TKlasse;
begin
K := CreateKlasse(TKlasse2);
end;

Ich habe schon einige C#-Bücher gelesen und einiges versucht. Aber es ist mir nicht gelungen.

DANKE

[Stefan Glock]

Ich kann Code nicht mehr ganz so gut lesen (Schon lange kein Delphi mehr gemacht ) aber ich denke du möchtest ein Factory implementieren? Du könntest in deiner Funktion CreateClass einfach mittels Reflection den Übergebenen Type auswerten und von diesem dann eine Klasse erzeugen und diese zurückgeben. Also aus dem Kopf -> ohne Garantie und nur als Idee.

<PRE>
public object CreateClass(Type classType)
{
// hier dann den Type auswerten oder mittels
// Reflection eine Instanz erzeugen und
// zurückgeben.
}
</PRE>

Nur so als Idee. Ich arbeite in so Fällen mit Interfaces also zB.

<PRE>

public interface ISomeClass
{
intDoSomething();
}

public class1: ISomeClass
{
public class1()
{
}

public void DoSomething()
{
return 1;
}
}

public class2: ISomeClass
{
public class2()
{
}

public void DoSomething()
{
return 2;
}
}

public class MyFactory
{
static public IDoSomething Create()
{
//Je nach Klasse dann hier
switch ....
case 1 return new Class1;
case 2 return new Class2;
}

}

</PRE>

Die Create Funktion von MyFactory könnte dann auch mittels Reflection eine Instanz erzeugen oder in einer Config nachschauen oder du gibst einen Parameter mit in die Mehtode.

Ich hoffe es hilft dir ein wenig ;

[Andreas Kosch]

Hallo,

das folgende Beispiel ist etwas universeller. Eine Klasse kann Instanzen von anderen Klassen über einen gemeinsamen Interface-Rückgabewert erzeugen (Abstract Factory Pattern).

<b>Klassen</b>

<pre>
<b>using</b> System;
<b>using</b> System.Windows.Forms;

<b>namespace</b> AbstractFactoryDemo
{
<b>public</b> <b>interface</b> IBaseInterface
{
<b>void</b> DoWork();
}

<b>public</b> <b>abstract</b> <b>class</b> TKlasse: IBaseInterface
{
<b>public</b> TKlasse()
{
}

<b>public</b> <b>void</b> DoWork()
{
<font color="#003399"><i>// TODO: Add TKlasse.DoWork implementation</i></font>
}
}

<b>public</b> <b>class</b> TKlasse1: TKlasse, IBaseInterface
{
<b>public</b> TKlasse1()
{
}

<b>public</b> <b>void</b> DoWork()
{
MessageBox.Show(<font color="#9933CC">&quot;TKlasse1.DoWork&quot;</font>);
}
}

<b>public</b> <b>class</b> TKlasse2: TKlasse, IBaseInterface
{
<b>public</b> TKlasse2()
{
}

<b>public</b> <b>void</b> DoWork()
{
MessageBox.Show(<font color="#9933CC">&quot;TKlasse2.DoWork&quot;</font>);
}
}

<b>public</b> <b>class</b> TKlasseFactory
{
<b>public</b> TKlasseFactory()
{
}

<b>public</b> IBaseInterface CreateTKlasse(Type aType)
{
IBaseInterface aObj;
aObj = (IBaseInterface)<font color="#FF0000">Activator.CreateInstance</font>(aType, <b>false</b>);
<b>return</b> aObj;
}

}
}
</pre>

<b>Aufruf</b>

<pre>
<b>private</b> <b>void</b> button1_Click(<b>object</b> sender, System.EventArgs e)
{
IBaseInterface aObj;
TKlasseFactory aFactory = <b>new</b> TKlasseFactory();
aObj = aFactory.CreateTKlasse(<font color="#FF0000"><b>typeof</b></font>(TKlasse1));
aObj.DoWork();
}

<b>private</b> <b>void</b> button2_Click(<b>object</b> sender, System.EventArgs e)
{
IBaseInterface aObj;
TKlasseFactory aFactory = <b>new</b> TKlasseFactory();
aObj = aFactory.CreateTKlasse(<b><font color="#FF0000">typeof</font></b>(TKlasse2));
aObj.DoWork();
}
</pre&gt

[Stefan Glock]

Jo, mein Beispiel hat den Hintergrund gehabt die Beziehungen der Klassen untereinander durch Interfaces zu entkoppeln. So das typische "Circular Reference" Problem ;