How to access anonymous method from generic list?

Question

I've been working on a library to generate fake data using Faker.NET. The problem I'm having is that I don't know how to access an anonymous method that I'm passing to the constructor of my DataGenerator child classes.

The issue is that in order to create a list of generics I had to create base class DataGenerator but I cannot pull my Func<T> member up because that base class is not generic so no Tavailable. However, my DataGenerator<T> class does expose the Generator property which is my anonymous method but I haven't found a way to access it while iterating my list of data generators.

Any advice will be highly appreciated.

This is what I have so far:

public class Employee
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public Guid EmpUid { get; set; }
}

// Define other methods and classes here
public abstract class DataGenerator
{
    public abstract int GetWeight(string matchingProperty);
    public abstract Type Type { get;}
}

public abstract class DataGenerator<T> : DataGenerator
{
    public readonly string[] Tags;
    public readonly Func<T> Generator; 
    protected DataGenerator(Func<T> generator, params string[] tags)
    {
        Tags = tags;
        //How to access this?
        Generator = generator;
    }

    public override int GetWeight(string matchingProperty)
    {
        int sum = (from tag in Tags
            where matchingProperty.ToLowerInvariant().Contains(tag.ToLowerInvariant())
            select 1).Sum();
        return sum;
    }

    public override Type Type {
        get { return typeof(T); }
    }
}

public class StringDataGenerator : DataGenerator<string>
{
    public StringDataGenerator(Func<string> generator, params string[] tags) : base(generator, tags)
    {
    }
}

public class GuidDataGenerator : DataGenerator<Guid>
{
    public GuidDataGenerator(Func<Guid> generator, params string[] tags)
        : base(generator, tags)
    {
    }
}

And I'm testing it here:

private static void Main(string[] args)
    {
        var dataGeneratorList = new List<DataGenerator>
        {
            new StringDataGenerator(Name.First, "first", "name"),
            new StringDataGenerator(Name.Last, "last", "name"),
            new GuidDataGenerator(Guid.NewGuid, "uid", "id")
        };

        var writeProperties = typeof (Employee).GetProperties().Where(p => p.CanWrite);
        foreach (var property in writeProperties)
        {
            foreach (var dataGenerator in dataGeneratorList)
            {
                if (property.PropertyType == dataGenerator.Type)
                {
                    var weigth = dataGenerator.GetWeight(property.Name);
                    //How to access generator here???
                    var testValue = dataGenerator.Generator.Invoke();
                }
            }
        }
    }

Answer 1

As you tagged, given your current setup, reflection is probably your only option.

var func = dataGenerator.GetType().GetField("Generator").GetValue(dataGenerator);
var testValue = func.GetType().GetMethod("Invoke").Invoke(func, null);

I'm not sure anyone could call this super nice, and it won't be super fast, but it's probably sufficient for anything you need fake data in, I suppose.

For good measure, here's it in action.

---

Your question is actually a bit more complicated than it may seem at face-value. A nice way of handling this if you only ever use it in object form is just to add an abstract Generate method to the base, non-generic class:

public abstract object Generate();

Then override it in your generic one:

public override object Generate()
{
    return this.Generator();
}

Of course, this return an object, which isn't nice in a generic class. But at least it avoids reflection.

Another solution to avoid this reflection nonsense might be the use of covariance, although that will, unfortunately, break for value types, like Guid.

public interface IDataGenerator<out T>
{
    int GetWeight(string matchingProperty);
    Type Type { get;}
    T Generate();
}

public abstract class DataGenerator<T> : IDataGenerator<T>
{
    public readonly string[] Tags;
    public readonly Func<T> Generator; 
    protected DataGenerator(Func<T> generator, params string[] tags)
    {
        Tags = tags;
        //How to access this?
        Generator = generator;
    }

    public T Generate(){
        return this.Generator();
    }

    . . .
}

That then turns into a preferable,

private static void Main(string[] args)
{
    var dataGeneratorList = new List<IDataGenerator<object>>
    {
        new StringDataGenerator(Name.First, "first", "name"),
        new StringDataGenerator(Name.Last, "last", "name")

//            But this line doesn't work
//            new GuidDataGenerator(Guid.NewGuid, "uid", "id")
    };

    var writeProperties = typeof (Employee).GetProperties().Where(p => p.CanWrite);
    foreach (var property in writeProperties)
    {
        foreach (var dataGenerator in dataGeneratorList)
        {
            if (property.PropertyType == dataGenerator.Type)
            {
                var weigth = dataGenerator.GetWeight(property.Name);

                var testValue = dataGenerator.Generate();
            }
        }
    }
}