Efficient way of initializing a generic class' fields and/or properties

I am writing a ConfigParser class, which reads from a config file structured like this:

[Section]
option1 = foo
option2 = 12
option3 = ;
...

The information read is actually stored in a Dictionary<string, string>. What i'd like to achieve is the following:

struct ConfigStruct
{
    public string option1;
    public int option2;
    public char option3 { get; set; }
    // Any other _public_ fields or properties
}

ConfigParser Cp = new ConfigParser("path/to/config/file"); // Loads content
ConfigStruct Cs = Cp.CreateInstance<ConfigStruct>("Section");

Console.WriteLine(Cs.option1); // foo
Console.WriteLine(Cs.option2.ToString()); // 12
Console.WriteLine(Cs.option3.ToString()); // ;

The struct (or class, it doesn't matter) ConfigStruct, is application-specific, and the ConfigParser class should know nothing about it. Basically, I want to parse the value from a specific option, and store it into the field/property with the same name. Parsing should be done according to the field/property type.

I've developed a stub method for it:

public T CreateInstance<T>(string Section) where T : new()
{
    // Gets options dictionary from loaded data
    Dictionary<string, string> Options = this.Data[Section];

    T Result = new T();

    Type StructType = Result.GetType();

    foreach (var Field in StructType.GetFields())
    {
        if (!Options.ContainsKey(Field.Name))
            continue;

        Object Value;

        if (Field.FieldType == typeof(bool))
            Value = Boolean.Parse(Options[Field.Name]);

        else if (Field.FieldType == typeof(int))
            Value = Int32.Parse(Options[Field.Name]);

        else if (Field.FieldType == typeof(double))
            Value = Double.Parse(Options[Field.Name]);

        else if (Field.FieldType == typeof(string))
            Value = Options[Field.Name];

        else if (Field.FieldType == typeof(char))
            Value = Options[Field.Name][0];

        // Add any ifs if needed

        else { /* Handle unsupported types */ }

        Field.SetValue(Result, Value);
    }

    foreach (var Property in StructType.GetProperties())
    {
         // Do the same thing with public properties
    }

    return Result;
}

1. Do you think this is the right approach to the problem? Or should I move the responsability of initializing the struct to the application logic instead of the ConfigParser class? I know it's more efficient, but using reflection I write this method only once, and works for every struct.
2. Should I use reflection to invoke Parse() so that I can avoid all those ifs? Or you'd rather make those conversions type by type, to prevent unexpected behaviour?

Thanks 开发者_运维百科for your time.

Assuming there is a specific reason why you are not using app.config/web.config or other built-in configuration files.

1. I think this comes down to what the rest of the application is doing, but personally I would do it this way. It allows you to get the return type cleanly and you are not passing an extra stuct down the stack that you don't need to be.

2. Reflection is a fantastic tool but has some overhead so if the list of types is finite then specifying them manually is more efficient, or alternately only reflecting the unknown types. Also I would change your if blocks to a switch statement, you will gain efficiencies if the IL complier can fully optimise the condition block.

I think there is a simpler solution. You could use a custom section handler to store your settings, custom section handlers are well described here: http://devlicio.us/blogs/derik_whittaker/archive/2006/11/13/app-config-and-custom-configuration-sections.aspx).