can we instantiate an object of a class just declared and passed to a method in another class

Question

I am implementing an auto mapper and stuck at this kind of scenario:

1. There is object of class common inside the object of class source which is just declared but not instantiated
2. when i pass the object of class source to a method map of program class

how can i get type of inner object(common class object) and instantiate it?

public class common
{
    public int x;
}

public class source
{
    public common obj;
}

class program
{
    static void main()
    {
        source obj = new source();
        map(obj);
    }

    void map(source obj)
    {
        **how can i get type of inner object class and instantiate it**
    }
}

i used Type.GetType() but is giving empty.

Answer 1

So working implementation of map method:

common map(source obj)
{
    var typeOfObj = obj.GetType().GetFields(
        BindingFlags.Public |
        BindingFlags.NonPublic |
        BindingFlags.Instance)
        .First(fi=>fi.Name == "obj");
    return (common) Activator.CreateInstance(typeOfObj.FieldType);
}

ARCHIVED If you need get type for obj.obj then you have use:

void map(source obj){
   obj.obj.GetType() ...
}

But since you have not instantiate it yet then you need reflection:

var f = typeof(source).GetField("obj");
f.FieldType // contains expected

If private field is a problem then you have to iterate by all array of fields resolved by:

FieldInfo[] fields = source.GetFields(
                     BindingFlags.NonPublic | 
                     BindingFlags.Instance);

And locate field named "obj"

Answer 2

And if you want to instantiate your received class you can use Activator:

Activator.CreateInstance(obj.obj.GetType());

Although I'm not sure what you are trying to achieve.

Answer 3

correct my understanding if I am wrong.

you want to instantiate the inner common object once you instantiated the source object. if so you could write an constructor inside your source which will instantiate your private common object. something like this

class source
{ 
    common obj;
    public source()
    {
        obj = new common();
    }

}

Answer 4

Where is the problem on this? No need for reflection:

void map(source obj)
{
    obj.obj = new common();
}

Basically you can modify any passed object as you want, the only thing you can´t do within your method is to set obj to a new instance of source for which you´d need the ref-keyword. In your case you know the type of the passed object, so I guess you also know what the concerning class consists of and thus the type for the obj-property.

Answer 5

Get type field info from your input object then instantiate the object of that field's type and set the value back to your input object :

// Get field info for source.obj
FieldInfo fieldInfo = obj.GetType().GetField("obj", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);
// Instantiate object without initializing it
object instance = FormatterServices.GetUninitializedObject(fieldInfo.FieldType);
// set instantiated object reference to the field source.obj
fieldInfo.SetValue(obj, instance);

If you're making "AutoMapper" then this will fit your needs because it doesnt use constructor which in other answers should be the default ( parameterless ) one.

Here you can compare different methods of instantiating object without default ( parameterless ) constructor.

Full code example that will map recursively :

public static void Main()
{
    _genericMapInfo = typeof(Program).GetMethod("map", BindingFlags.NonPublic | BindingFlags.Static);
    Test t = null;
    map(ref t);
    Console.WriteLine(t == null); // False
    Console.WriteLine(t.A); // Hello World!
    Console.WriteLine(t.B.A); // 1337
    Console.WriteLine(t.B.B); // Hello World!
}

static MethodInfo _genericMapInfo;

static void map<T>(ref T obj)
    where T : class
{
    if(obj == null)
        obj = (T)FormatterServices.GetUninitializedObject(typeof(T));

    foreach(FieldInfo fInfo in typeof(T).GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
    {
        Type fieldType = fInfo.FieldType;   
        TypeCode tCode = Type.GetTypeCode(fInfo.FieldType);
        if(tCode == TypeCode.Object)
        {
            object[] param = new object[] { fInfo.GetValue(obj) };
            _genericMapInfo.MakeGenericMethod(fieldType).Invoke(null, param);
            fInfo.SetValue(obj, param[0]);
        }
        else if(tCode == TypeCode.String)
        {
            fInfo.SetValue(obj, "Hello World!");    
        }
        else if(tCode == TypeCode.Int32)
        {
            fInfo.SetValue(obj, 1337);  
        }

    }
}

public class Test
{
    public string A { get; set; }   
    public TestInside B { get; private set; }

    public Test()
    {
        A = "no siema"; 
    }
}

public class TestInside
{
    public int A { get; private set; }
    public string B { get; set; }   

    public TestInside(int _someInteger)
    {
        A = _someInteger;   
    }
}

Online check

Answer 6

we can get the type by using

.GetType()

method but ofcourse my case is different since i stored all fields in

FieldInfo[]

so i used

FieldInfo.FieldType

to get the type of my object. Once we had our object type we can use

Activator.CreateInstance(Class Type);

to create the instance of class.