Is it possible to create an instance of an class without running ANY code from the class? (no ctor, no field initializations)

Question

I have created an engine that takes in 3rd party plugins (DLL's) that implement an interface.

Since I have no control over the code that gets plugged in, I want to be able to run 1 specific method (from the interface) from the correct class (GetTypes loop untill I find the interfaced class ).

Since anyone can create nice constructor code that executes on Activator.CreateInstance, I can solve that by using FormatterServices.GetUninitializedObject. But that does not help when code is being initialized on fields in the class.

public class myclass : myinterface {

  public someotherclass name = new someotherclass()

  public myclass() {
     //Unknown code
  }

  //I only want this run.
  public string MyProperty{
    get {
      return "ANiceConstString";
    }
  }
}

The problem with both ways (CreateInstance/GetUninitializedObject) is that the constructor of someotherclass will be run.

Before you start analyze my needs. This is only run in the initializing of the engine to get a set of standard values. If this get'er relies on other initialized values the "plugin" will be marked as failed as there is no valid value returned. If not marked as failed, later on the class will be loaded properly with Activator.CreateInstance().

So stick to this question: Does .Net support any way to create an 100% non-initialized class?

Update for the answers. I tested this before I posted my question.

For the answer that someotherclass wont run, I allready tested that and it is run if static.

public class myclass : myinterface {

    static Tutle test;

    public myclass () {
         test = new Tutle();
    }

    public class Tutle {
        public Tutle() {
            MessageBox.Show("RUN!");
        }
    }
}

CreateInstance shows the messagebox. GetUninitializedObject does not.

public class myclass : myinterface {

    static Tutle test = new Tutle();

    public myclass () {
    }

    public class Tutle {
        public Tutle() {
            MessageBox.Show("RUN!");
        }
    }
}

CreateInstance shows the messagebox. GetUninitializedObject shows the messagebox.

Is there a way to get around static field intializers and ctors?

Answer 1

Simply:

var obj = (myclass)FormatterServices.GetUninitializedObject(typeof(myclass));

That will not run the constructor / field initializers. At all. It will not run the constructor for someotherclass; name will be null.

It will, however, execute any static constructor that exists, if necessary under standard .NET rules.

HOWEVER! I should note that this method is not intended for ad-hoc usage; its primary intent is for use in serializers and remoting engines. There is a very good chance that the types will not work correctly if created in this way, if you have not subsequently taken steps to put them back into a valid state (which any serializer / remoting engine would be sure to do).

Answer 2

As an alternative design consideration:

[SomeFeature("ANiceConstString")]
public class myclass : myinterface {

  public someotherclass name = new someotherclass()

  public myclass() {
     //Unknown code
  }
}

Now you can access the feature without instantiation; just use:

var attrib = (SomeFeatureAttribute)Attribute.GetCustomAttribute(
    type, typeof(SomeFeatureAttribute));
string whatever = attrib == null ? null : attrib.Name;

with:

[AttributeUsage(
    AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum)]
public sealed class SomeFeatureAttribute : Attribute
{
    private readonly string name;
    public string Name { get { return name; } }
    public SomeFeatureAttribute(string name) { this.name = name; }
}