Ability to use converters and a type factory

[robsonfelix]

Giacomo, your library rocks!

I am trying to accommodate some needs we have for a project using the library and I need your help. We successfully added a way to use custom types (classes) as Options property types by changing the TypeConverter class on the MakeType function delegate by adding a try/catch with the constructor. That way we redirected the constructor to some other static factory method that was able to create the value instance.

The other thing we did was to change the ReflectionExtensions class on the SetValue method by adding a way to get the TypeDescriptor for a particular property once the original property.SetValue method failed on setting the property value.

However it looks like adding a Type Factory to the ParserSettings (instead of hardcoding such factory into the TypeConverter class) is too complicated. That would be the ideal scenario.

Is there anything you suggest we do to make this change easier?

We believe the changes we did are very good for other developers to use (we created a sort of type-variant class set that can work interchangeably with boolean, integer and other numeric types, text, etc). Hence the need to use other types (rather than struct or base .NET CLR types). As for the changes we did to your code, they can be gladly shared.

[nemec]

Hi @robsonfelix, if I understand you correctly, you're trying to add the ability for Options/Values to be custom classes with no default constructor?

class Options
{
    [Option('n')]
    public MyClass Nothing { get; set; }
}

class MyClass
{
    public MyClass(int counter)
    {
    }
}

The easiest way I can think of is to allow custom TypeConverters to be created and applied to the property. Then you simply check that the converter can convert from typeof(string) and let the converter create the new instance (along with populating its data from the option value).

Within the code, you'd have to use reflection to get any TypeConverterAttributes attached to the property (not the property Type itself, though you can do that too) and use them to convert the "string value" into a real type.

public class CustomDateTimeOptions
{
    [System.ComponentModel.TypeConverter(typeof(CustomDateTimeConverter))]
    [Option('d', "date", Description = "Store the date.")]
    public DateTime CurrentDate { get; set; }
}

You can, of course, do what you're suggesting with an entry in the parser settings, but you'll have to make sure those factories are passed into the inner parts of the code where conversion happens.