Question

I have a Class X wich uses a Class Y. The X creates the Y, but X must create Y with THE SAME constructor method was used to create instance-Y passed to X.

• It is not a Clone, because I want a NEW object-Y not equals to values of instance-Y passed to X.
• It is not a instance because I do not want the SAME object-Y what is pased as instance-Y to X.

I would like to pass the “constructor method and parameters” of class Y to class X and, with this information, create the new Y-instance using the ctor-method-passed.

And I don’t want to devel all ‘Class Y’ constructor logic because, in this case both of them will be very highly coupled.

I have done a little spike to explain myself a bit better.

Thanks.

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            TheSon son1 = new TheSon();

            son1.TheValue = "Another Value";

            TheFather<TheSon> father1 = new TheFather<TheSon>(son1);
            Console.WriteLine("Result is {0}:", "Empty constructor".Equals(father1.MySon.TheValue));
            Console.WriteLine("\tbecause prop. must be: '{0}' and it is: '{1}'", "Empty constructor", father1.MySon.TheValue);

        }

        public class TheFather<T> where T: TheSon
        {
            public TheSon MySon { get; set; }

            public TheFather(T mySon) {
                // I would like to NOT use the same object but
                // use the constructor that was used to build the passed object-instance.
                // 
                // Or perhaps pass a concrete TheSon constructor to the 'TheFather'...
                this.MySon = (TheSon)mySon;
            }
        }

        public class TheSon 
        {
            public string TheValue { get; set; }

            public TheSon()
            {
                this.TheValue = "Empty constructor";
            }

            public TheSon(string value)
            {
                this.TheValue = value;
            }

            public TheSon(string value, int element)
            {
                this.TheValue = value + "-> " + Convert.ToString(element);
            }        
        }
    }
}

=========SOLUTION:
Adding this constructor to the TheFather class:

public TheFather(Func<T> sonFactory)
        {
            this.MySon = (T)sonFactory();
        }

And with this example:

static void Main(string[] args)
        {
            // Uncomment one of this to change behaviour....
            //Func<TheSon> factory = () => new TheSon();
            Func<TheSon> factory = () => new TheSon("AValue");
            //Func<TheSon> factory = () => new TheSon("AValue", 1);

            TheFather<TheSon> father1 = new TheFather<TheSon>(factory);
            Console.WriteLine("Result is {0}:", "AValue".Equals(father1.MySon.TheValue));
            Console.WriteLine("\tbecause prop. must be: '{0}' and it is: '{1}'", "AValue", father1.MySon.TheValue);
        }

Works like a charm…. 🙂

Thanks…

Answer 1

You can simply use a factory to create TheSon objects:

Func<TheSon> factory = () => new TheSon(); // creates one with default ctor

This way you can get a new object each time, but created in exactly the same way (this is not limited to a constructor; you can also include any additional code you want). Use it like this:

var oneSon = factory(); // creates one son
var secondSon = factory(); // creates another with the same constructor
var father = new TheFather(factory()); // ditto

Update: You can also change TheFather‘s constructor to accept a factory if you want to create TheSon inside TheFather. For example:

public TheFather(Func<T> sonFactory) {
    this.MySon = (TheSon)sonFactory();
}

and

var father = new TheFather(factory);