如何扩展课程的领域？

Question

Suppose I have a List of Person (which is a class). It contains about 20 field (Name, Surname, Age, DateOfBirthdate, and so on). So I got this list:

var listOfPersons= MyContext.Persons.Cast<Person>();

Now, I need to iterate through this List, and for each Person adding a new field (which it is not present in the class), called, let's say, CurrentDateTime .

I could create a new object, with the new field, and "copy & paste" values from Person to the new Class. Somethings like:

PersonNew newPerson = new PersonNew("Name", "Surname", "Age", "DateOfBirthdate", ... "CurrentDateTime");

But this is very bad if in the future I change the Person class. So, is there a strategy to "extending Person" with a new field? That takes the Person instance (whatever it is) and adds the new field?

Answer 1

You can create some static method that create PersonNew from Person using Automapper.

public class PersonNew : Person
{
    public static PersonNew CreateFromPerson(Person person, DateTime currentDateTime)
    {
        var newPerson = Mapper.Map<PersonNew>(person);
        newPerson.CurrentDateTime = currentDateTime;
    }
}

Answer 2

I think that the solution you described works fine. If you want to keep track of each person's birthday without extending the Person class, you might use a Dictionary object

var listOfPersons = MyContext.Perons.Cast<Person>();
Dictionary<Person, DateTime> birthdays = new Dictionary<Person, DateTime>    
foreach(Person person in listOfPersons)
{
    birthdays.Add(person, getBirthday(person); 
}

Answer 3

One solution is to make your class partial , and add your field in another partial definition of your class:

public partial class Person
{
    public string Name { get; set; }
    public string FirstName { get; set; }
    ...
}

...

public partial class Person
{
    public DateTime CurrentDateTime { get; set; }
}

...

var listOfPersons = MyContext.Persons.Cast<Person>();
foreach (var person in listOfPersons)
{
    person.CurrentDateTime = ....
}

Do note that you will use the same instance of your class.

Answer 4

First I would suggest using extension methods for projecting collections instead of iterating. Like that:

var newCollection = oldCollection.Select(entity => MakeNewType(entity))

Second, it's not completely clear what you mean by "extending Person" with a new field. Here are the couple of ways you can accomplish that.

1) Make another class with the new field and map it to the old one. This is a common scenario for asp.net mvc application where you map models to the appropriate viewmodels. Automapper is useful for these types of scenario (see Sławomir Rosiek anwser)

2) Take advantage of dlr in c# 4+. Yuo will lose the intellisense for dynamic objects, but they canned be passed around functions

var newPeople = people.Select(p =>
    {
        dynamic expando = new ExpandoObject();
        expando.Id = p.Id;
        expando.FirtName = p.FirtName;
        /* ... */
        expando.CurrentDateTime = DateTime.Now;
        return expando;
    });

3) Use Anonymous types. Anonymous types cannot be passed to another functions, so this approach is useful when you need to quickly project data inside a single method and calculate some result

var newPeople = people.Select(p => new 
    { 
        Id = p.Id, 
        FirtName = p.FirtName, 
        /* ... */ 
        CurrentDateTime = DateTime.Now 
    });

in both cases you can now access newly "created" property:

foreach(var p in newPeople)
{
    Console.WriteLine("CurrentDateTime: {0}", p.CurrentDateTime);
}

4) If you really need to create a fully featured .net class at runtime you can use Reflection.Emit . This scenario is typically used to create dynamic proxies - subclasses which implement some functionality only known at runtime. Entity framework does this.