Initialise one object from another where they share a common interface c#

Question

I want to pass in an instance of an interface to an object and initialise all the values of this object to those of the object passed in where both objects implement the same interface? Are there any good shortcuts in this particular case where they share an interface. It seems to me there must be... I just can't recall ...

EDIT: After John's feedback, the question is better expressed as - How do I pass in an instance of an interface to an object's constructor and initialise all the values of this object to those of the interface instance passed in?

Most deep copying solutions (including my own previous solutions) return an object - which is not going to work in a constructor, or rely upon creating a new instance (which is not going to work with an interface as the source and destination).

I want to pass in both source and destination and have properties of the source copied to the destination where they are both interfaces. Is there an existing solution for this. Or do I revisit my own code and try to adapt it - my previous own solution from 2009 (with minor bug corrected in the answers) SetValue on PropertyInfo instance error "Object does not match target type" c# AND svics answer in transfering one object properties values to another one suffice for the simple cases where all properties are just values.

e.g.

    public interface ISomething
    {
        ...
    }

    public class A : ISomething
    {

        public A(ISomething input)
        {

            // what goes here??
        }
    }

Answer 1

I'm not really sure I fully understand your restrictions, but for most object copying work I use AutoMapper, which greatly helps with the grunt work of copying objects. It means a different approach than copying properties in constructors, but maybe useful. Here's some example code:

public interface ISomething {
    string MyProperty { get; set; }
    int AnotherProperty { get; set; }

    B ClassProperty { get; set; }
}

public class A : ISomething {
    public string MyProperty { get; set; }
    public int AnotherProperty { get; set; }
    public B ClassProperty { get; set; }
}

public class B {
    public string BProperty_1 { get; set; }
    public int BProperty_2 { get; set; }
}

class Program {
    static void Main(string[] args) {

        // Configure the mapping
        Mapper.Initialize(cfg => cfg.CreateMap<ISomething, ISomething>());

        // Initialize first instance
        var firstA = new A {
            MyProperty = "Test",
            AnotherProperty = 21,

            ClassProperty = new B {
                BProperty_1 = "B String",
                BProperty_2 = 555
            }
        };

        // Initialize second instance and perform the mapping
        var secondA = Mapper.Map<ISomething>(firstA);

Here, all the properties in firstA are copied over to secondA, including the properties in ClassProperty.

The mapping configuration is performed once on startup, and uses recursion and reflection to build the mapping model. It can then be used anywhere in your code. If new properties are added to the interface, the mapping configuration stays the same.

Answer 2

Simply set all the properties of the interface in the constructor:

public class A : ISomething
{
    public A(ISomething input)
    {
        A.MyProperty = input.MyProperty;
        A.AnotherProperty = somethingNotFromTheInterface
    }
}

This is called a copy-constructor. Wheather this actually creates a deep or a shallow copy of your existing instance depends on if it contains references to other reference-types. In this case you´d have to re-create all those instances also:

    public A(ISomething input)
    {
        A.MyProperty = new MyType(input.MyProperty);
        A.AnotherProperty = somethingNotFromTheInterface
    }

Which itself assumes you hacve a copy-constructor for the type of MyProperty also.

This can become some huge task when your interface is quite big. You may consider looping all the interfaces properties with reflection in this case, or even better rethink if your interface is actually serving a single purpose and not doing too much.