Lazy loading Constructors

[LexManos]

I have a Lazy object whos Value has a constructor that I need to call.
But I can't find a way to do it with out initializing the class at least once using a default constructor.

                    if (plugin.IsValueCreated)
                    {
                        return Activator.CreateInstance(plugin.Value.GetType(), parameters);
                    }
                    else
                    {
                        //I need to figure out how to initilize the value with parameters..
                        return Activator.CreateInstance(plugin.Value.GetType(), parameters);
                    }

After creating the value once, I can create a new one like above, but I would like to change it to make it so we don't have a useless image in memory...

[hspc]

You can use the Activator.CreateInstance Method (String, String, Object[]) overload.
I takes the assembly name and type name, that way you can make it configurable too. And no need at all to create an instance first.

[LexManos]

Is there a way to get the type of a Lazy's Value without initilizing it?
I have a Lazy<Object> which I populate using using MEF imports.

[Mutant_Fruit]

Lazy<SomeClass> x;


x.GetType ().GetGenericParameters [0]

The above (or something like it) will return "typeof (SomeClass)".

For the original question:

Type valueType = Type.Find ("Full.NameSpace.To.Value");

Or something similar

[LexManos]

That doesnt work because like I said, I have to use Lazy<Object>, so The type of the generic parameter is typeof(Object)
As for using Type.Find I don't know the fill name space!
I'm using MEF and importing lots of extensions.

[Mutant_Fruit]

As for using Type.Find I don't know the fill name space!

The 'Type' class has methods for creating a Type object using just a string. This is what you want.

That doesnt work because like I said, I have to use Lazy<Object>, so The type of the generic parameter is typeof(Object)

Maybe it'd be possible to refactor things so you don't have to use Lazy<object> but can use strongly typed versions instead.

[LexManos]

Its impossible to use strongly typed vars instead because we are importing things from a arbitrary assembily.
I can do something like:
[ImportMany(typeof(PluginBase))]
Collection(Lazy<PluginBase>) _plugins;

[Export(typeof(PluginBase))]
public class TestPlugin : PluginBase{}

but if I try and get the type of any of the plugins, it'll return typeof(PluginBase) not typeof(TestPlugin);

No use to me at all.