Pass FieldName as a Parameter in C#

Question

I'm not quite sure what I'm attempting to do is called, so I'm struggling to find any clues from google.

I have a couple of methods with the same logic in them, the only thing that differs is the property they are using on an object.

class Foo
{
   public int A(Bar bar)
   {
      return bar.A * 2;
   }

   public int B(Bar bar)
   {
      return bar.B * 2;
   }

   public int C(Bar bar)
   {
      return bar.C * 2;
   }
}

class Bar
{
  public int A;
  public int B;
  public int C;
}

Instead of the three separate methods in Foo I want one, with a signature that looks more like

public int X(Bar bar, ??? x)
{
   return bar.x * 2;
}

Is this possible?

Answer 1

I misread the question the first time, my bad.

You can do this with Reflection:

public int Method(Bar bar, string propertyName)
{
   var prop = typeof(Bar).GetProperty(propertyName);
   int value = (int)prop.GetValue(bar,null);
   return value * 2;
}

Then, you call it like this:

Method(bar,"A");

Just noticed that in your example, the 3 variables in Bar are public instance variables. I'm assuming that you just did this for your sample, but if this is in fact the case in your real class, use Rex M's approach.

Answer 2

You can achieve this using reflection. It will have some performance impact

Answer 3

you can use the PropertyInfo class to retrieve the desired property via reflection: http://articles.techrepublic.com.com/5100-10878_11-6099345.html

Answer 4

public int X(Bar bar, string target)
{
    object value = bar.GetType().GetField(target, BindingFlags.Public | BindingFlags.Instance).GetValue(bar);
    return (int)value * 2;
}

Answer 5

Try using reflection. Here's some simple code to achieve the effect.

using System.Reflection;    

public int X(Bar bar, FieldInfo x)
{
    return (int)x.GetValue(bar) * 2;
}

Now, you can call X by first getting the FieldInfo for one of the fields on Bar.

Bar b = new Bar();
b.A = 20;
b.B = 30;
b.C = 40;

FieldInfo fieldA = typeof(Bar).GetField("A");
int result = X(b, fieldA);

Answer 6

Use FieldInfo

BindingFlags flags = BindingFlags.Instance | BindingFlags.Public;
FieldInfo field = typeof(Bar).GetField("A", flags);

field.SetValue(..) to set the value.

Answer 7

internal class Program {
    private static void Main(string[] args) {
        var bar = new Bar {A = 1, B = 2, C = 3};
        Console.WriteLine(new Foo().X(bar, it => it.A));
        Console.WriteLine(new Foo().X(bar, it => it.B));

        // or introduce a "constant" somewhere
        Func<Bar, int> cFieldSelector = it => it.C;
        Console.WriteLine(new Foo().X(bar, cFieldSelector));
    }
}

internal class Foo {
    // Instead of using a field by name, give it a method to select field you want.
    public int X(Bar bar, Func<Bar, int> fieldSelector) {
        return fieldSelector(bar) * 2;
    }

    public int A(Bar bar) {
        return bar.A * 2;
    }

    public int B(Bar bar) {
        return bar.B * 2;
    }

    public int C(Bar bar) {
        return bar.C * 2;
    }
}

internal class Bar {
    public int A;
    public int B;
    public int C;
}

Answer 8

you could use an extension method.. for the example you posted.. but i guess that your example is just a simplified version of some more complex code.

public static class IntExt
{
    //use Bar.A.Double();
    public int Double(this int value)
    {
        return value * 2;
    }
}

Answer 9

Why not use an enumeration and pass it into the function to determine which to use? It seems reflection is kinda going west around the world to take a step to the right...

class Foo
{
   public enum BarChoice { a,b,c };
   public int x(Bar bar, BarChoice bc)
   {
     switch(bc) 
     {
       case a:
         return bar.A * 2;
       case b:
         return bar.B * 2;
       case c:
         return bar.C * 2;
     }
     return int.MinValue;
   }
}

Then your call would be

 Foo f = new foo();
 Bar b = new Bar();
 f.x(b, Foo.BarChoice.a);
 f.x(b, Foo.BarChoice.b);
 f.x(b, Foo.BarChoice.c);

Answer 10

I would consider using an anonymous delegate to get your value instead.

public int X(Bar bar, Func<Bar,int> getIt)
{
   return getIt(bar) * 2;
}

Then call it like:

var x = X(mybar, x=>x.A);