CODEWITHSUNDEEP
c#dynamic
Schroedingers Cat
Schroedingers Cat

Reputation: 3139

Dynamic creation of object instances

We have a system that creates dynamically defined objects as a core aspect of the processing. I would like to be able to create an class object and make these objects instances of this class, implementing all of the functionality that this particular object has.

The problem is, these objects really need to dynamically inherit from a base class, and override null methods etc. In essence, I need something of a dynamic class structure (and I have proposed compiling the definitions into a proper class model, but that is some distance away). The best approach i can come up with is to create a class instance with a set of blank properties, and dyamically replace these properties with methods if these features are implemented.

I have also looked at Castles DynamicProxy approach, which might be a useful route (intercepting the calls and actioning them if appropriate), but this seems more complex than it should be.

So any suggestions? What would the best, most .Net-like approach to this be? As I look at the problem, it seems like there should be a really good and easy solution.

Just to help, a simple example (semi-pseudocode - I know it is not fully working):

class thing
{
    public void Process()
    {
        foo();
        bar();
    }
    private foo(){}
    private bar(){}
}

a=new thing() {foo=DoFoo}
b=new thing() {bar=DoBar}

I want to be able to call a.Process and b.Process, and have them both run. Bear in mind that these objects have some 20-30 properties/methods that might need setting (setting them is easy, but some of them might be substantial methods)

Upvotes: 1

Views: 175

Answers (2)

Jcl
Jcl

Reputation: 28272

Not sure if I really understand your requirements, but have you looked at the DynamicObject class?

The idea behind it is that you derive from it, and every time a member is accessed, it gets a call to TryGetMember, TrySetMember, or TryInvokeMember for methods, where you can do your custom logic.

You can make a base class inheriting from DynamicObject then make the set of classes you want by deriving from that base class, implementing the logic on each one of them, this way you can have both defined members, and other non-defined ones which you can use using a dynamic type.

Check the documentation on MSDN for DynamicObject

Alternative

Otherwise, as a very simple solution and based on the pseudo-code you provided only (which admittedly might be a little simple for the requirements stated in the question), you could just make a Thing class which has Action properties:

class Thing
{
    public void Process()
    {
       if(Foo!=null) Foo();
       if(Bar!=null) Bar();
    }
    public Action Foo {get;set;}
    public Action Bar {get;set;}
}

var a=new Thing() {Foo=DoFoo};
var b=new Thing() {Bar=DoBar};
a.Process();
b.Process();

Upvotes: 1

H W
H W

Reputation: 2596

create a class instance with a set of blank properties, and dyamically replace these properties with methods if these features are implemented

This sounds a lot like the "decorator" design pattern might be a good choice for you here. You basically implement a set of functionalities and then build your objects by subsequently assigning several "decorations" (functionalities) to a baseobject.

http://www.codeproject.com/Articles/479635/UnderstandingplusandplusImplementingplusDecoratorp seems to be a very good summary with clear examples on how and when to use decorator patterns

However if your properties heavily interact with each other, or need a significant different implementation depending on other "decorations" i would not suggest using a decorator. In that case you might need to get a bit more specific on your requirements.

Upvotes: 1

Related Questions