Generic Reflection of static types with code reuse

I have a method that iterates the fields of a class, returning t开发者_Go百科heir values as a CSV. I need a way to give classes access to this method in a generic fashion.

For some reason, Statics must derive from object or you get a compile error. In this case, deriving from a different base class does increase code re-useability for me. Is there another way to accomplish my goal?

I believe the only choice I have is to make my static class an instance class.

//a data container used for Mocking in inversion of control
public class FieldContainer : ReflectionHelper<FieldContainer>
{
    public static string Field1 = "Some Data";
    public static string Field2 = "Persons Name";
    public static string Field3 = "3030 Plane Ave.";
}

    public class ReflectionHelper<T>
    {
    public static string ToCSV()
    {
        StringBuilder fieldCollector = new StringBuilder();

        Type type = typeof(T);
        FieldInfo[] fields = type.GetFields();
        foreach (FieldInfo f in fields)
        {
            fieldCollector.Append(f.GetValue(null) + ",");
        }

        return fieldCollector.ToString();
    }
    }

Your code is perfectly valid (at least technically). Your class FieldContainer is not a static class and therefore it can derive from ReflectionHelper<T>.

However, you normally would not implement the method ToCSV in a base class, because it can basically work on ANY class. Because you want to work on static members, an extension method isn't the best way either. The simplest and cleanest way to do it, will be to have a static helper class that implements this method:

public static class ReflectionHelper
{
    public static string ToCSV<T>()
    {
        StringBuilder fieldCollector = new StringBuilder();

        Type type = typeof(T);
        FieldInfo[] fields = type.GetFields();
        foreach (FieldInfo f in fields)
        {
            fieldCollector.Append(f.GetValue(null) + ",");
        }

        return fieldCollector.ToString();
    }
}

You can use it like this:

var csv = ReflectionHelper.ToCSV<FieldContainer>();

However, I fail to see, why you would want to implement something like that at all. It doesn't seem to make too much sense.

You could form it as an extension method, as such:

public static class ReflectionHelperExtensions
{
    public static string ToCSV<T>(this T instance)
    {
        var type = instance.GetType();
        var fields = type.GetFields();
        var fieldCollector = new StringBuilder();        
        foreach (FieldInfo f in fields)
        {
            fieldCollector.Append(f.GetValue(null) + ",");
        }
        return fieldCollector.ToString();
    }
}

This way, your field container classes don't need to derive from any given type, as this applies to all derivatives of object.

Have you concidered using an extension method?

public static class ReflectionExtensions
{
     public static string ToCSV(this object input)
     { 
         StringBuilder fieldCollector = new StringBuilder();

         Type type = input.GetType();
         FieldInfo[] fields = type.GetFields();
         foreach (FieldInfo f in fields)
         {
             fieldCollector.Append(f.GetValue(null) + ",");
         }

         return fieldCollector.ToString();
    }
}

Then you could simply call the following on any object:

FieldContainer c = new FieldContainer();
string result = c.ToCSV();

It's fine if you have the class as an instanced type.

public abstract class ReflectionHelper<T>
{
    protected ReflectionHelper()
    { }


    public static string ToCsv(string delimiter = ",")
    {
        var fieldCollector = new StringBuilder();

        var type = typeof(T);
        var fields = type.GetFields();
        foreach (var f in fields)
        {
            fieldCollector.Append(f.GetValue(null) + delimiter);
        }

        return fieldCollector.ToString();
    }
}

public class Something : ReflectionHelper<Something>
{
    protected Something() : base()
    {

    }
    public static string Field1 = "Some Data";
    public static string Field2 = "Persons Name";
    public static string Field3 = "3030 Plane Ave.";
}