Copy object to object (with Automapper ?)

Question

I have a class:

public class Person {
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

I have two instances of Person (person1 and person2). I'd like copy the contents of person2 to person1. I'd like to make this copy in one instruction and not property by property:

person1.LastName = person2.LastName;

In the doc, I see copy an object to another object but the type is different. How can I copy the object when the type is the same ?

Answer 1

Why do you want to use Automapper for this? A simple clone would do the job for you.

Read more here: Deep cloning objects

Answer 2

As I understand the question, OP does not want to clone person2 into a new instance of Person, but is asking for how to copy the contents of person2 into an already existing instance (person1) of Person. There is an overload of AutoMapper's Mapper.Map method that does this for you:

Mapper.CreateMap<Person, Person>();
Mapper.Map<Person, Person>(person2, person1);
//This copies member content from person2 into the _existing_ person1 instance.

Note 1: @alexl's answer creates a new instance of Person. If you have other references to the instance that person1 points to, these will not get the (presumably) desired data update if you redirect the person1 variable to a new instance.

Note 2: You need to be aware of that the (recursive) copying depth depends on what mappings AutoMapper knows about at the moment of mapping!
If a member of the Person class is of say the class Brain and you additionally have done Mapper.CreateMap<Brain, Brain>(); before the copy data Mapper.Map<Person, Person>(person2, person1); call, then person1 will keep its current Brain instance but this Brain will receive the member values of person2's Brain instance. That is you have a deep copy.
But if AutoMapper does not have a Brain-Brain mapping before copying, then person1's Brain member will reference the same Brain instance as the one person2 references. That is you will get a shallow copy.
This applies recursively to all members, so you better make sure AutoMapper has mappings for member classes that you want to deep copy, and doesn't have mappings for member classes that you want to shallow copy.

An alternative to using AutoMapper would be to use an approach using reflection. (Note that the code in the link does a shallow copy!)

_{"Support for filling an existing object, instead of AutoMapper creating the destination object itself" was added in AutoMapper version 0.2.}

Answer 3

Since you asked With Automapper? can I suggest you don't use AutoMapper?

Instead use MemberwiseClone() in a Clone method, e.g.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public Person Clone()
    {
        return (Person) MemberwiseClone();
    }
}

UPDATE

Its important to note this does not acheive the original posters desire to copy person1 into person2

However, (and as @Jimmy Bogard points out) using MemberwiseClone() is preferred if you just need to make a copy (clone) of the object.

For instance, if you are doing this:

//I need a copy of person1 please! I'll make a new person object 
//and automapper everything into it!
var person2 = new Person2();
Mapper.Map<Person, Person>(person1, person2)

then really you should/could use

//oh wait, i can just use this!
var person2 = person1.Clone()

Answer 4

Mapper.CreateMap<Person, Person>();

// Perform mapping

var person1 = Mapper.Map<Person, Person>(person2);

Hope this helps.