C#

Type type = typeof(T);
var prop = type.GetProperty("Name");
prop.SetValue(entity, "TheName", null); 

public interface IEntity
{
    string SomeProperty { get; set; }
    string Caption { get; set; }
}

public class Entity1 : IEntity
{
    public string SomeProperty { get; set; }
    public string Name { get; set; }
}
public class Entity2 : IEntity
{
    public string SomeProperty { get; set; }
    public string Caption { get; set; }
}

public partial class Form1<T> : Form where T : IEntity, new()
{
    T entity;

    public Form1()
    {
        InitializeComponent();
        entity = new T();
    }
}

public partial class Form1<T> : Form 
{
    T DataItem;
    Type type = typeof(T);

    public Form1()
    {
        InitializeComponent();

        var DistrictId = 10;
        DataItem = (T)Activator.CreateInstance(typeof(T), DistrictId);

        setProperty<string>("Name", "The Name");
        setProperty<bool>("LinkedToBilling", true);
        setProperty<DateTime>("BillingStartDate", new DateTime(2012, 01, 15));
    }

    private void setProperty<T>(string PropertyName, T Value)
    {
        var prop = DataItem.GetType().GetProperty(PropertyName);

        if (prop != null)
        {
            type.GetProperty(PropertyName).SetValue(DataItem, Value, null);
        }
    }
}

setProperty<string>("Name", "The Name");
setProperty<bool>("LinkedToBilling", true);
setProperty<DateTime>("BillingStartDate", new DateTime(2012, 01, 15));

setProperty<string>("Name", "The Name");
setProperty<bool>("LinkedToBiling", true);
setProperty<DateTime>("BillingStartDate", new DateTime(2012, 01, 15));

Ennis Ray Lynch, Jr. wrote:

doesn't give a compiler error.

public class Wrapper{
    private Object mObject;
    public string Name{
        get{
            string result = null;
            if(mObject is SomeTypeIRecognize){
                result = ((SomeTypeIRecognize)mObject).Name;
            }
            return result;
            
        }
    }

    public Wrapper(object o){mObject = o;}

}

public interface IX { ... } 
public class X0 : IX { ... }
public class X1 : IX { ... }

public class MyForm
{
  private IX x ;
  public MyForm ( IX X ) { ... }
}

IX x = new X0 ( ... ) ;
MyForm f = new MyForm ( x ) ;

public class Entity1
{
    public string SomeProperty { get; set; }
    public string Name { get; set; }
}
public class Entity2
{
    public string SomeProperty { get; set; }
    public string Name { get; set; }
}

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

Kevin Marois wrote:

so the guy who wrote them decided to duplicate the forms instead of making one form that works for both. So I'm refactoring them.

Kevin Marois wrote:

What is the right way to work with this object?

jschell wrote:

 
Obviously a good decision by that person because they are in fact
different.
 
The fact that there seem to be common components between
them is NOT sufficient reason to assume that they are the same. As an example
the fact that Word and Visual Studio both allow me to type text doesn't mean
that those two code bases should be merged.

jschell wrote:

The right way is to re-assess the decision to combine them in the first place.
Nothing you have posted here suggests that they should be combined. And in fact
what has been posted would suggest that they should NOT be combined.

Kevin Marois wrote:

This is an entirely stupid argument.

Kevin Marois wrote:

You're saying it's ok to have 2 entirely duplicate forms and their code becuase the data they work with is different

Kevin Marois wrote:

There is NO good reason to have 2 identical forms.

public interface IEntity
{
    string SomeProperty { get; set; }
}

public interface IAnotherInterface
{
    string Name { get; set; }
}

public class Entity1 : IEntity, IAnotherInterface
{
    public string SomeProperty { get; set; }
    public string Name { get; set; }
}

public partial class Form1<T> : Form
   where T : IEntity

void SetSomeProperties()
{
    (entity as IEntity).SomeProperty = "foo";
    if (entity is IAnotherInterface)
    {
        (entity as IAnotherInterface).Name = "bar";
    }
}