Object creation, how to resolve "class-owner"?

Question

I need some solution to trace the class-owner of a method, in which the object is constructed. I mean to say, I want the constructor to automatically resolve the Type object of the "creator" class. Is it possible in C#?

Answer 1

An object doesn't naturally have any concept of a creator.

If you want to reliably determine what's creating an object, you'll need to express it explicitly in the constructor. Analysing stack frames not only has problems in low-trust environments (as Lasse mentioned) but can be inaccurate due to inlining.

What bigger problem are you trying to solve? Why is the class important to you? There may be a better approach.

Answer 2

You can use the StackFrame to find out where the object was constructed from, but there are limitations to what it can figure out and when, for instance if you're running in some kind of lowered security mode, it won't be able to work.

Answer 3

Assuming that inlining of the method that needs to check its caller and permissions aren't a problem, you can call the following method in a constructor:

[System.Runtime.CompilerServices.MethodImpl(
 System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
public static Type GetCallerType()
{
    StackTrace st = new StackTrace(2);
    StackFrame sf = st.GetFrame(0);
    return sf.GetMethod().DeclaringType;
}

So for your real question, the answer is yes, it is possible, but not recommended.

EDIT:

The method will require the reflection permission to access the GetMethod() method and the DeclaringType property. For the stack trace, a security permission for unmanaged code is needed (if I understand the documentation correctly), which basically renders this method useless for anything less than fully trusted code.

As you see, I decorated the method with an attribute that explicitly requests the JIT not to inline the method, since it walks at least one frame up the call stack. Problems arise if the calling method becomes inlined (or whatever transform the JIT applies) in its own calling method. I can give a sample with a short property, since properties are likely to be inlined by the JIT, though I cannot guarantee that this is corret:

public object PropertyThatGivesObject
{
    get { return new ObjectThatTracksItsCreator(); }
}

While this is pretty exotic (the property is not a 'property of an object', it is a factory), this has at least one problem:

1. Is the property's declaring type really the creator (suppose it is an indirection)?
2. If the property getter is inlined, should it have been the property's declaring type that was the creator? (Relevant if the method that invokes the property is declared by another type)