Oprettelse af dynamiske klasser

Du kan godt create klasser dynamisk at runtime. .NET frameworket har indbygget
compiler.

Men den slags er ikke helt simpelt.

Jeg har også nogle eksempler.

using System;
using System.Reflection;
using System.CodeDom.Compiler;

using Microsoft.CSharp;

namespace E
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            string src = @"public class X
{
    public override string ToString()
    {
        return ""I am a X"";
    }
};";
            ICodeCompiler comp = (new CSharpCodeProvider()).CreateCompiler();
            CompilerParameters param = new CompilerParameters();
            param.GenerateInMemory = true;
            param.ReferencedAssemblies.Add("System.dll");
            CompilerResults res = comp.CompileAssemblyFromSource(param, src);
            Assembly asm = res.CompiledAssembly;
            object o = asm.CreateInstance("X");
            Console.WriteLine(o);
        }
    }
}

er relativt simpelt !

Ligger klassen 'in memory' eller kommer der en fysisk fil på disk?

Jeg får en obsolete besked på denne ->
(new CSharpCodeProvider()).CreateCompiler();

har du nogen ide om, hvad jeg kan / skal bruge?

gaet paa hvad

param.GenerateInMemory = true;

goer ...

:-)

De aendrede et eller andet i .NET 1.1 til 2.0.

Jeg kan proeve at find eud af hvad den anbefaldede metode er idag.

:-)

Hvordan kan jeg teste det?

mit lille eksempel er koere klart som console app

og selv om det er deprecated, saa boer det stadig virke

og jeg skal nok finde den ikke deprecated metode at faa fat i compileren paa

senere

Hej decrypto,

Du kan sådan set også bare gøre sådan her for at initialisere en klasse dynamisk:



namespace TestNamespace
{
    class Test
    {
        public override string ToString()
        {
            return "Test class";
        }
    }

    static class Program
    {
        [STAThread]
        static void Main()
        {
            string strClassName = "Test";

            Assembly assembly = Assembly.GetExecutingAssembly();

            Type tObj = assembly.GetType("TestNamespace." + strClassName);

            //Exempel 1: Intialiser en ny instans af Test klassen (caster den til test klassen)
            Test objTest = (Test)tObj.GetConstructor(new Type[] { }).Invoke(new object[] { });

            //Exempel 2: Intialiser en ny instans af Test klassen uden at caste den
            Object objTest2 = tObj.GetConstructor(new Type[] { }).Invoke(new object[] { });

                        //Kalder den overridede ToString på Test obejkterne
            Console.WriteLine(objTest.ToString());
            Console.WriteLine(objTest2.ToString());

        }
    }
}


Dette virker ihvertfald fint i .NET 2.0 og er ikke deprecated (obsolete).  :)


Mvh.

- Snap :)

Og du skal lige huske:


using System.Reflection;


For at kunne få fat i "Assembly" :)


Mvh.

- Snap

At opbygge klasser dynamisk og at loade klasser dynamisk er to meget forskellige ting.

Nå for søren, kan være jeg skal læse spørgsmålet ordentligt så. :)

Godt så, hvis der er tale om opbygning så spring straks mit eksempel over.


Mvh.

- Snap :)

Det er jo ogsaa muligt at det er mig som er igang med et mega overkill.

http://msdn2.microsoft.com/en-us/library/microsoft.csharp.csharpcodeprovider.aspx

antyder at:

ICodeCompiler comp = (new CSharpCodeProvider()).CreateCompiler();

skal vaere:

CodeDomProvider comp = CodeDomProvider.CreateProvider("CSharp");

Og her er arnes kodestykke i udbygget version, som viser hvordan du kan kalde metoder (her vist med et parameter).

using System;
using System.Reflection;
using System.CodeDom.Compiler;
using Microsoft.CSharp;

namespace E
{
  class MainClass
  {
    public static void Main(string[] args)
    {
      string src = @"
        public class X
        {
          public int Number(int parm)
          {
            return ++parm;
          }
        };
      ";
      CodeDomProvider comp = CodeDomProvider.CreateProvider("CSharp");
      CompilerParameters param = new CompilerParameters();
      param.GenerateInMemory = true;
      param.ReferencedAssemblies.Add("System.dll");
      CompilerResults res = comp.CompileAssemblyFromSource(param, src);
      Assembly asm = res.CompiledAssembly;
      Type dynamicType = asm.GetType("X");
      object o = Activator.CreateInstance(dynamicType);
      MethodInfo mi = dynamicType.GetMethod("Number");
      Console.WriteLine(mi.Invoke(o, new Object[] { 5 }));
    }
  }
}

Dejligt....jeg prøver mig lige frem....

Synes begge to fortjener point...smid svar ind, så deler jeg kagen.

Udover det Arne...så har jeg lige den der Oracle listener issue...måske kan du også hjælpe der?

http://www.eksperten.dk/spm/767329

Inden svarene kommer ind....har jeg lige en lille detalje...

De her dynamiske klasser, skal de mere forstås some et interface eller et abstraktionslag? For hvordan laver jeg implementationen af mine metoder.

Ideelt vil jeg jo 'bare' kalde lave en instans af en anden klasse og så kalde metoden dernede hvor implementationen også vil være.

Og endnu vigtiger.....hvordan kan jeg instansiere en en class X

og på objektet fx gøre brug af en GetMessage() metode, der bare returnere en "Hello World"?

Ideen er at kunne lave en instans af klassen X, og så dotte sig til de metoder den tilbyder.

Hej decrypto,

Så var det jo bare så simpelt. Du skal bare cast'e dem til den klasse som du ved objektet er. Hvis vi tager udgangspunkt i hmortensens eksempel så bare gør følgende:

X objX = (X)Activator.CreateInstance(dynamicType);
int intNumber = objX.Number(4);


Mvh.

- Snap :)

Ok lyder godt.....
lige ser min klasse således ud:
-------------------------------------------

namespace ClassFactory
{
    public class ClassBuilder
    {
        public void BuildClass()
        {
            string src = @"

                public class ProductA
                {
                    public ProductA(){}
                           
                    public override string ToString()
                    {
                        return ""I am a X"";
                    }

                    public string GetMessage()
                    {
                        return ""I am a ProductA"";
                    }
                }
                ;";

            CodeDomProvider compiler = CodeDomProvider.CreateProvider("CSharp");
            CompilerParameters param = new CompilerParameters();
           
            param.GenerateInMemory = true;
            param.ReferencedAssemblies.Add("System.dll");
           
            CompilerResults result = compiler.CompileAssemblyFromSource(param, src);
            Assembly asembly = result.CompiledAssembly;

            object obj = asembly.CreateInstance("ProductA");
            Console.WriteLine(obj);
           
        }
    }
}

Udover det så ville det jo være rarest ikke at caste til x klassen. Min formodning vil være at dem der bruger / instansierer klassen, ikke ved hvilen type klasse det er.

Der er ikke meget pointe i at generere dynamisk kode, hvis kalder skal kende klassen.

Du har 2 muligheder:

1)  kalde metoder via reflection som i hmortensens eksempel

2)  lade alle dine dynamisk genrerede klasser implementere et interface
    eller en abstrakt basis klasse og saa caste til den

og et svar fra mig

Mener du at der ikke er ide i at generere dynamisk, hvis kalderen IKKE kender klassen?

For det er den formodning jeg vil have, at han ikke gør. Kigger lige på eksemplerne derhjemme....

nej - der er ikke nogen ide hvis kalderen skal kende - hvis han ikke kender den er der en ide i det