C# Multiple generic types in single collection

Question

There are a lot of answers for this using a single Type with interfaces and abstract classes which all work fine for one generic T value. What I am trying to achieve I have not seen and am wondering if anyone has an idea.

Scenario

    public class Field<T>
    {
        public Expression<Func<T,object>> FieldName { get; set; }
    }

    public class FValue<T, F> : Field<T>
    {

        public F FieldValue { get; set; }
    }

//Test

var fieldList = new List<Field<Person>>();
fieldList.Add(new FValue<Person, DateTime> { FieldName=x=>x.SomeDate, FieldValue=DateTime.Now });
fieldList.Add(new FValue<Person, string> { FieldName=x=>x.SomeData, FieldValue="test" });

Ideally i want to do the following:- The list will contain the same type for T, the type for F will change to various types like date,string etc.

When iterating over the list i want both the FieldName and FieldValue

I can't start the list using new <List<FValue<Persion,string>>(); for the obvious reason that all F values will have to be string.

Also when obtaining the FieldName somehow the value should be casted to Expression<Func<T,F>>.

Any suggestions would be appreciated.

Answer 1

Whenever you want to use generics you need a specific reason to use it. See this answer about when to use Generics What is cool about generics, why use them?

As you can see in the link, one of the main reason is to have type-safe properties. This also means that your class will be limited to the specific type. And taking this in consideration, the usages of your class will be limited.

Here is how I could use your class with limited usages that don't require (boxing/unboxing), but still requires casting

private static void UseFieldList<T>(List<Field<T>> fieldList)
{
    foreach (var field in fieldList)
    {
        var propName = field.FieldNameText;
        var textField = field as FValue<T, string>;
        if (textField != null)
        {
            // Now can use string specific functions without (boxing/unboxing) 
            Console.WriteLine(propName + " " + textField.FieldValue );
            continue;
        }
        var dateField = field as FValue<T, DateTime>;
        if (dateField != null)
        {
            // Now can use date specific functions without (boxing/unboxing) 
            Console.WriteLine(propName + " " + dateField.FieldValue.ToShortDateString());
            continue;
        }

        throw new NotSupportedException("The type of the field is not supported: " + field.GetType().Name);
    }
}

To get the name out of a expression you can see the answer here Retrieving Property name from lambda expression

And to use this I would change the way you are creating the objects to something similar to the usages of Tuple:

// Newer code storing name 
fieldList.Add(FValue<Person>.Create(x => x.DateOfBirth, DateTime.Now ));
fieldList.Add(FValue<Person>.Create(x => x.Name, "test"));

// Old code storing expression instead of name 
fieldList.Add(new FValue<Person, DateTime> { FieldName = x => x.DateOfBirth, FieldValue = DateTime.Now });
fieldList.Add(new FValue<Person, string> { FieldName = x => x.Name, FieldValue = "test" });

// Not supported Type Int 
fieldList.Add(new FValue<Person, int> {FieldName = x => x.Name, FieldValue = 12});

And here is the factory class

public class FValue<T>
{
    public static Field<T> Create<F>(Expression<Func<T, F>> fieldNameExpression, F value)
    { 
        return new FValue<T, F>
        {
            FieldNameText = GetPropertyInfo(fieldNameExpression).Name,
            FieldValue = value
        };
    }
}

Results of the console:

DateOfBirth 1/19/2017
Name test

x => Convert(x.DateOfBirth) 1/19/2017
x => x.Name test

The type of the field is not supported: FValue`2

Answer 2

I'm not sure I see a way around this one without using Reflection. Using these classes:

public class Field<T>
{
    public Expression<Func<T, object>> FieldName { get; set; }
}

public class FValue<T, F> : Field<T>
{
    public F FieldValue { get; set; }
}

You can iterate over them like so:

var list = new List<Field<string>>();
list.Add(new FValue<string, int>() { FieldName = null, FieldValue = 5 });

foreach (var x in list)
{
    Type[] types = x.GetType().GetGenericArguments();

    // Dirty check to confirm this is an FValue not a Field
    if (types.Length == 2)
    {
        var fieldName = x.FieldName;
        object fieldValue = x.GetType().GetProperty("FieldValue").GetValue(x);
        // fieldValue will be "5"
    }
}