在C＃中从子类聚合属性的优雅方法是什么？

Question

I have a situation where I am mapping classes that have an inheritance hierarchy. I have a list of items that each class knows that it needs. For example:

public class PersonMapper
{
    private string[] attributes = new[] {"firstName", "lastName"};
}

public class UserMapper : PersonMapper
{
    private string[] attributes = new[] {"username"};
}

public class EmployeeMapper : PersonMapper
{
    private string[] attributes = new[] {"employeeId"};
}

I would like to make a method call that returns the aggregate of all of the super classes like this:

EmployeeMapper mapper = new EmployeeMapper();
string[] attributes = mapper.GetAttributes();
Assert.That(attributes, Has.Member("firstname"));

I can think of some solutions, but they seem overly complicated. I feel like there is an elegant solution to this that I am missing. Can anyone help?

Thanks in advance!

Answer 1

You can have a virtual method/property on the superclass called GetAttributes that returns the private array. Then, in each subclass, override it like so. First call the base GetAttribute method to get the base classes array, and the combine that with the subclasses array, and return the new array.

Code sample:

public class PersonMapper
    {
        private string[] attributes = new[] { "firstName", "lastName" };
        public virtual string[] GetAttributes()
        {
            return attributes;
        }
    }

 public class EmployeeMapper : PersonMapper
    {
        private string[] attributes = new[] { "employeeId" };
        public override string[] GetAttributes()
        {
            return base.GetAttributes().Union(this.attributes).ToArray();
        }
    }

Answer 2

I'd be tempted to develop a custom attribute that gets applied to each of the properties that I care to track and then use reflection to enumerate the properties with that attribute applied. You could use lazy loading so that the attribute list only gets populated once. I'd also probably make GetAttributes() a static (class) method.

public class MappedAttribute : Attribute
{
}

public class Person
{
    [Mapped]
    public string FirstName { get; set; }

    [Mapped]
    public string LastName { get; set; }

    public string DisplayName
    {
        get { return FirstName + " " + LastName; }
    }
}

public static class Mapper
{
    public static IList<string> Attributes( Type t )
    {
          List<string> attributes = new List<string>();

          foreach (PropertyInfo pInfo in t.GetProperties())
          {
              MappedAttribute attr = pInfo.GetCustomAttributes(typeof(MappedAttribute),false)
                                          .Cast<MappedAttribute>()
                                          .FirstOrDefault();
              if (attr != null)
              {
                  attributes.Add(pInfo.Name);
              }
          }

          return attributes;
    }
}

Answer 3

Without reflection, there is no way to do it in the current state. What you could do though is make a protected virtual method which allows each class to add their attributes to a list and aggregate that way.

public class PersonMapper {
  protected virtual void AggregateAttributes(List<string> list) {
    list.AddRange(attributes);
  }
  public List<string> GetAttributes() {
    List<string> list = new List<string>();
    AggregateAttributes(list);
    return list;
  }
}

public class UserMapper {
  protected override void AggergateAttributes(List<string> list) {
    base.AggregateAttributes(list);
    list.AddRange(attributes);
  }
}

public class EmployeeMapper {
  protected override void AggergateAttributes(List<string> list) {
    base.AggregateAttributes(list);
    list.AddRange(attributes);
  }
}

Answer 4

I would go for a simpler approach:

class Entity {
    public virtual IEnumerable<string> Attributes { get { yield return "Name"; } }
}

class Person : Entity {
    public override IEnumerable<string> Attributes {
        get {
            return new string[] { "FirstName", "LastName" }
                .Concat(base.Attributes);
        }
    }
}

class User : Person {
    public override IEnumerable<string> Attributes {
        get {
            return new string[] { "UserName" }
                .Concat(base.Attributes);
        }
    }
}

(PS These kinds of hierarchies rarely work out in single-inheritance languages.)

Answer 5

public class PersonMapper
{
    protected List<string> attributes =
        new List<string>() {"firstName", "lastName"};
    public string[] GetAttributes()
    {
        //defensive copy
        return attributes.ToArray();
    }
}

public class EmployeeMapper : PersonMapper
{
    public EmployeeMapper()
    {
        attributes.Add("employeeId");
    }
}