Assigning fields dynamically

Question

I have set of properties as follows:

public string Foo1 {set;get;}
public string Foo2 {set;get;}
public string Foo3 {set;get;}
public string Foo4 {set;get;}
public string Foo5 {set;get;}
public string Foo6 {set;get;}
public string Foo7 {set;get;}
public string Foo8 {set;get;}
public string Foo9 {set;get;}
......
public string Foo50 {set;get;}

then i m iterating through a collection as follows:

foreach(var element in sortedCollection.Keys){
   if(element != null)
   // in this block I would like to assign the element to the properties above
   // ex:
   foo?? = sortedCollection[element];
   // ?? need to be replaced by index.
}

Is there an easy way to do this?

You'll probably run into more trouble later if go with reflection rather than refactoring to a better design... (After you add reflection, it gets really hard to refactor/redesign it) — Arjan Einbu, Oct 06 '11 at 14:38

Matthew Abbott · Accepted Answer · 2011-10-06T14:41:08.673

5

I think a better design would be:

public List<string> Foos { get; private set; }

If you can't change it, you could probably do something like:

var type = typeof(MyCalss);
int index = 1;
foreach (var key in sortedCollection.Keys)
{
   var value = sortedCollection[key];
   var prop = type.GetProperty("Foo" + index);
   if (prop != null) prop.SetValue(this, value, null);

   index++;
}

... of course with some error handling, and where this assumes this is a method within your class. Can you determine an index based on the values in your sortedCollection?

edited Oct 06 '11 at 14:41

answered Oct 06 '11 at 14:34

Matthew Abbott

60,571
9
104
129

1

Well, as a workaround, you could create an indexer which would use reflections to access Foo properties. That would, at least, look nicer. – Dmytro Shevchenko Oct 06 '11 at 14:39
5

@user177883: You should protest to whoever's saying you can't improve the design - fixing poor design like this is almost always better done earlier rather than later. – Jon Skeet Oct 06 '11 at 14:40
Like i mentioned, i cant change the design. and i dont like it as well. sigh. – DarthVader Oct 06 '11 at 15:02

score 2 · Answer 2 · answered Oct 06 '11 at 14:36

you can use reflection and do it in a loop:

for ( int i = 1 ; i < 51 ; i++)
  this.GetType().GetProperty(string.Format("Foo{0}",i)).SetValue(this,desiredValue,null);

but i think i'll recommend using indexers

http://msdn.microsoft.com/en-us/library/2549tw02%28v=vs.80%29.aspx

score 1 · Answer 3 · answered Oct 06 '11 at 14:36

You can do what you want by:

Using a for loop instead of foreach. This way you can operate with the current index.
Using reflections. You can get a list of properties for your class and access them dynamically. For example, see Type.GetProperties.

But why don't you just use a List<string> Foos instead of lots of properties?

score 1 · Answer 4 · answered Oct 06 '11 at 14:38

You should use reflection.

this.GetType().GetProperty("Foo" + i).SetValue(this, sortedCollection[element], null);

Two things though:

GetProperty's cost is not null. So if you're doing this a lot of times, you might want to store the result of GetProperty in some field and then use this field in your foreach.
If your properties are really named Something1, Something2, etc..., then you may have a design flaw you may want to correct before doing this (replace all you string members with one List).

score 1 · Answer 5 · answered Oct 06 '11 at 14:41

You need to use reflection (Type.GetProperty()) to get the property and set it's value.

Assuming that the properties are defined in class called MyClass:

foreach(var element in sortedCollection.Keys){
   if(element != null)
   // in this block I would like to assign the element to the properties above
   // ex:
   //foo?? = sortedCollection[element];
   // not sure how you are getting the index here, may be you need to use for loop
   PropertyInfo pi = typeof(MyClass).GetProperty("Foo" + index);

   // ?? need to be replaced by index.
   if (pi != null)
   {
       pi.SetValue(<object of MyClass>, sortedCollection[element], null);
   }
}

score 1 · Answer 6 · answered Oct 06 '11 at 14:43

void Main()
{
    var foo = new Foo();
    foo[1] = "Foo1";    
    //foo.Dump();
}

public class Foo
{
    public string Foo1 {set;get;}
    public string Foo2 {set;get;}
    public string Foo3 {set;get;}
    public string Foo4 {set;get;}
    public string Foo5 {set;get;}
    public string Foo6 {set;get;}
    public string Foo7 {set;get;}
    public string Foo8 {set;get;}
    public string Foo9 {set;get;}

    public string this[int index]
    {
        get
        {
            return getPropertyValue(index);
        }
        set
        {
            setPropertyValue(index, value);
        }
    }
    private void setPropertyValue(int i, string value)
    {
       var propi = this.GetType().GetProperty("Foo" + i);
       if (propi != null)
          propi.SetValue(this,value,null);
    }
    private string getPropertyValue(int i)
    {
        var propi = this.GetType().GetProperty("Foo" + i);
        if (propi != null)
            return (string)propi.GetValue(this, null);
        return null;
    }
}

score 1 · Answer 7 · answered Oct 06 '11 at 14:45

I would actually use reflection, or if this is called a lot, make a dynamic method and ILEmit to do it (much faster at runtime than reflection).

However just to suggest something different, you could change the class containing the Foo* properties to have each getter/setter read from an indexed list:

  public class FooOfDoom
  {
    public string[] Foos = new string[2];

    public string Foo1
    {
      set { Foos[0] = value; }
      get { return Foos[0]; }
    }

    public string Foo2
    {
      set { Foos[1] = value; }
      get { return Foos[1]; }
    }

  }

Then your class doesn't really change, as far as its contract with all the other code, since the properties are still there, but now you can assign right to Foos instead of through each individual property.

Again, in reality I would actually use a DynamicMethod if I was doing it myself.

score 1 · Answer 8 · answered Oct 06 '11 at 14:51

Personally, I disagree with most of the other posters here. I think the use of reflection should be limited to those situations where it is really called for (object inspection, certain GUI situations, etc). In this case, with just a little more typing, it is possible to write a strongly-typed program and still do what you want. I'll offer two alternatives. Both alternatives will offer the ability to access your properties by name as well as by index.

In the first alternative, I'll assume that we are allowed to change the definition of your properties. In the second alternative, I'll assume that those definitions must remain unchanged.

The first alternative moves the data to a separate array, adds helper methods to access the data by index, and alters the properties to use the helper methods:

private class Version1 {
  private readonly string[] underlyingData=new string[50];

  public string Foo1 { get { return ReadFoo(1); } set { SetFoo(1, value); } }
  public string Foo2 { get { return ReadFoo(2); } set { SetFoo(2, value); } }
  public string Foo3 { get { return ReadFoo(3); } set { SetFoo(3, value); } }
  //......
  public string Foo50 { get { return ReadFoo(50); } set { SetFoo(50, value); } }

  private string ReadFoo(int index) {
    return underlyingData[index-1]; //1-based indexing
  }

  private void SetFoo(int index, string value) {
    underlyingData[index-1]=value; //1-based indexing
  }
}

The second alternative leaves the property definitions unchanged, and two static arrays of delegates representing the reading and writing function of those properties.

private class Version2 {
  private static readonly Func<Version2, string>[] readers=new Func<Version2, string>[] {
    c => c.Foo1,
    c => c.Foo2,
    c => c.Foo3,
    //......
    c => c.Foo50,
  };

  private static readonly Action<Version2, string>[] writers=new Action<Version2, string>[] {
    (c,v) => c.Foo1=v,
    (c,v) => c.Foo2=v,
    (c,v) => c.Foo3=v,
    //......
    (c,v) => c.Foo50=v,
  };

  public string Foo1 { set; get; }
  public string Foo2 { set; get; }
  public string Foo3 { set; get; }
  //......
  public string Foo50 { set; get; }

  private string ReadFoo(int index) {
    return readers[index-1](this); //1-based indexing
  }

  private void SetFoo(int index, string value) {
    writers[index-1](this, value); //1-based indexing
  }
}

Assigning fields dynamically

8 Answers8