Dynamically map one class to another at runtime C#

Question

I am trying to build a system that converts data from a vertical key value pair store system into a more traditional horizontal column store.

The source data looks something like this

public class Container
{
  public string Type { get; set; }
  public IEnumerable<Attribute> Attributes { get; set; }
  public IEnumerable<Container> RelatedContainers { get; set; }
}

public class Attributes
{
  public string Name{ get; set; }
  public string Value { get; set; }
}

It will generate data something like

public class Person
{
  public string Name { get; set; }
  public IEnumerable<Address> Addresses { get; set; }
}


public class Address
{
  public string Line1 { get; set; }
  public string City { get; set; }
  public string State { get; set; }
  public string Zip { get; set; }
}

There are a few gotchas in this situation. First of all, I don't know all of the fields in the target types until runtime. I have a rough solution for that and can generate new classes at runtime based upon the structure of the source data.

I can't figure out a good way to map the data itself into the new classes though. I would love to be pointed at a simpler way to solve the problem, or have some help with the next step on the path I am on.

Answer 1

Here is some code that I think provides you with something to start with. It doesn't handle the nested objects, but there should be enough here for you to fill in the gaps.

It uses the classes from your question, and populates an Address object. The method "CreateObjectFromContainer" being the place where the work is actually performed.

using System;
using System.Collections.Generic;
using System.Linq;

namespace PopulateFromAttributes
{
class Program
{
    static void Main(string[] args)
    {
        // Set up some test data - an address in a Container
        var attributeData = new List<Attributes> 
        {
            new Attributes { Name = "Line1", Value = "123 Something Avenue" },
            new Attributes { Name = "City", Value = "Newville" },
            new Attributes { Name = "State", Value = "New York" },
            new Attributes { Name = "Zip", Value = "12345" },
        };
        Container container = new Container { Type = "Address", Attributes = attributeData };

        // Instantiate and Populate the object
        object populatedObject = CreateObjectFromContainer("PopulateFromAttributes", container);
        Address address = populatedObject as Address;

        // Output values
        Console.WriteLine(address.Line1);
        Console.WriteLine(address.City);
        Console.WriteLine(address.State);
        Console.WriteLine(address.Zip);
        Console.ReadKey();
    }

    /// <summary>
    /// Creates the object from container.
    /// </summary>
    /// <param name="objectNamespace">The namespace of the Type of the new object.</param>
    /// <param name="container">The container containing the object's data.</param>
    /// <returns>Returns a newly instantiated populated object.</returns>
    private static object CreateObjectFromContainer(string objectNamespace, Container container)
    {
        // Get the Type that we need to populate and instantiate an object of that type
        Type newType = Type.GetType(string.Format("{0}.{1}", objectNamespace, container.Type));
        object newObject = Activator.CreateInstance(newType);

        // Pass each attribute and populate the values
        var properties = newType.GetProperties();
        foreach (var property in properties)
        {
            var singleAttribute = container.Attributes.Where(a => a.Name == property.Name).FirstOrDefault();
            if (singleAttribute != null)
            {
                property.SetValue(newObject, singleAttribute.Value, null);
            }
        }

        return newObject;
    }
}

public class Container
{
    public string Type { get; set; }
    public IEnumerable<Attributes> Attributes { get; set; }
    public IEnumerable<Container> RelatedContainers { get; set; }
}

public class Attributes
{
    public string Name { get; set; }
    public string Value { get; set; }
}

public class Address
{
    public string Line1 { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Zip { get; set; }
}
}

Answer 2

What about use .NET Reflection to bind your destination class? I found one sample that I'll believe will give the way to do what you want:

http://www.codeproject.com/Articles/55710/Reflection-in-NET

Answer 3

One piece of advice I can offer is to use the System.Convert.ChangeType(...) method to coerce values to the destination types where possible, and look for a static Parse(...) method on the destination Type if you're starting from string values (as your code above indicates).

Answer 4

This seems like it might work:

object CreateObjectFromNVPair(Container c)
{
    Type t = Type.GetType(this.GetType().Namespace + "." + c.Type);
    object o = Activator.CreateInstance(t);
    if (c.Attributes != null)
    {
        foreach (Attribute a in c.Attributes)
        {
            PropertyInfo pi = o.GetType().GetProperty(a.Name);
            pi.SetValue(o, a.Value, null);
        }
    }
    if (c.RelatedContainers != null)
    {
        foreach (Container c2 in c.RelatedContainers)
        {
            Type lt = typeof(List<>);
            Type t2 = Type.GetType(this.GetType().Namespace + "." + c2.Type);
            PropertyInfo pi = o.GetType().GetProperty(c2.Type + "List");
            object l = pi.GetValue(o, null);
            if (l == null)
            {
                l = Activator.CreateInstance(lt.MakeGenericType(new Type[] { t2 }));
                pi.SetValue(o, l, null);
            }
            object o2 = CreateObjectFromNVPair(c2);
            MethodInfo mi = l.GetType().GetMethod("Add");
            mi.Invoke(l, new object[] { o2 });
        }
    }
    return o;
}

Some changes may be needed to namespace and which Activator or Assembly is used for CreateInstance.

Note: I renamed from plural lists to appending "List" at the end for consistency.