Riferimenti simili a se stessi in due classi

Che cos'è Link ? Se hai una classe base Base con A : Base e B : Base , devi sapere che a.Link è di tipo A e b.Link è di tipo B ?

In caso contrario, è facile come:

public abstract class Base
{
    public Base Link { get; set; }
}

Se, d'altra parte, hai bisogno di preservare il tipo di Link , allora che dire dei generici?

public class Common<T>
{
    public T Link { get; set; }
}

che può essere usato in questo modo:

public static void Main()
{
    var number = new Common<int>
    {
        Link = 27,
    };

    var text = new Common<string>
    {
        Link = "Hello World",
    };

    // This is impossible, because of the mismatch between types.
    ////var wrong = new Common<float>
    ////{
    ////    Link = "I'm not a float.",
    ////};

    Console.WriteLine(number.Link);
    Console.WriteLine(text.Link);   
}

1. Refactoring: metodo locale

Specificare sia il tipo generico che il collegamento è fastidioso, specialmente se devi cambiare molto il tipo. In alcuni casi, potresti anche erroneamente specificare il tipo sbagliato: una classe genitore o una classe che supporta la conversione del tipo implicito, risultante in bug difficili da trovare.

Per evitare ciò, puoi creare un metodo che inizializza una nuova istanza della classe Common<T> in base al link:

public static void Main()
{
    var number = CreateCommon(27);
    var text = CreateCommon("Hello World");

    Console.WriteLine(number.Link);
    Console.WriteLine(text.Link);
}

private static Common<T> CreateCommon<T>(T link)
{
    return new Common<T>
    {
        Link = link,
    };
}

public class Common<T>
{
    public T Link { get; set; }
}

2. Refactoring: factory pattern

Il primo refactoring è sufficiente se si utilizza la classe Common in un metodo. Se lo stai utilizzando in più classi, finirai per duplicare il codice (ad esempio copia-incolla il metodo CreateCommon ) o refactoring del codice precedente in uno che utilizza una factory:

public static void Main()
{
    var number = Common.Factory.Create(27);
    var text = Common.Factory.Create("Hello World");

    Console.WriteLine(number.Link);
    Console.WriteLine(text.Link);
}

public class Common<T> : Common
{
    public Common()
    {
        // Do something here.
    }

    public Common(T link)
        : this()
    {
        this.Link = link;
    }

    public T Link { get; set; }
}

public class Common
{
    public static CommonFactory Factory
    {
        get
        {
            return new CommonFactory();
        }
    }
}

public class CommonFactory
{
    public Common<T> Create<T>(T link)
    {
        return new Common<T>(link);
    }
}

public abstract class Wrapper {
    private A theA;
    private B theB;
    // these are private on purpose.

    // add properties and methods for A and B stuff that you
    // want to expose. Make sure the names look like they're
    // all from one coherent class.
    // make them 'protected' as needed for use by only the subclasses.

    // do not give a default constructor so you force subclasses
    // to build correctly
    public Wrapper (A a, B b) {
        // check for null!

        theA = a;
        theB = b;
    }
}