Annidare gli oggetti senza passare gli argomenti?

Istintivamente, mi sento come se il Polimorfismo del runtime potesse fare molto.

public abstract class RenderObject
{
    public void Render()
    {
        // Baseline render implementation goes here.
    }
}

public class BarkingHorse : RenderObject
{
    public override void Render()
    {
        // Custom logic to render a Barking Horse, and/or call base.Render()
        // or simply omit the override.
    }
}

Per chiamarlo:

RenderObject obj = new BarkingHorse();
obj.Render();  // Renders a Barking Horse.  "Woof whinney."

Render () può andare nella classe base. Non hai bisogno dell'Onnipotente per farlo funzionare.

Se hai problemi a gestire le trame, dai uno sguardo al modello Flyweight.

Supponendo che la classe Onnipotente sia necessaria e che TellDeviceContextAboutTexture abbia bisogno di / dovrebbe esserci lì, piuttosto che nelle classi RenderObject, suggerirei di esporre un'interfaccia da quella a RenderObjects.

public interface IRenderingContext // Almighty implements this
{ 
    void WithTexture(Action renderingAction);
}

// Inside Almighty
public void Render(RenderObject obj) 
{
    obj.Render(this);
}

public void WithTexture(Action renderingAction)
{
    TellDeviceContextAboutTexture();
    renderingAction();
    TellDeviceContextTextureIsGone();
}

// Inside BarkingHorse
public void Render(IRenderingContext context)
{
    context.WithTexture(() => 
    {
        // Do rendering
    });

    if(ShowCullingBird)
        cullingBird.Render(context); // Does not call WithTexture
}

Se questo è sempre basato su ImageFile, potrebbe essere parte del metodo RenderObject.Render di base.

Metterei tutta la logica per far camminare l'albero degli oggetti (che può essere fatto in modo ricorsivo) nella classe base, e offrire un altro metodo interno per rendere solo l'oggetto stesso. Quindi, in altre parole, c'è

1. Un metodo pubblico ( Render ) per il rendering dell'oggetto (chiamando RenderInternal ) e chiamando Render su tutti i bambini, che a loro volta chiameranno il proprio chilren.

2. Un metodo protetto ( RenderInternal ) che uno sviluppatore deve eseguire l'override per implementare la logica di rendering per quel particolare tipo.

Ad esempio:

abstract class RenderObject
{
    public string Name { get; set; }

    public List<RenderObject> Children { get; private set; } 

    protected readonly IDeviceContext _context;

    public RenderObject(IDeviceContext context)
    {
        _context = context;
        Children = new List<RenderObject>();
    }

    public void Render()
    {
        this.RenderInternal();
        foreach (var o in Children) o.Render();
    }

    protected abstract void RenderInternal();
}

Quindi avrei una classe derivata separata per comportamento . Non per animale-- non sarebbe mai in scala. Hai solo bisogno di una classe se c'è qualcosa sul comportamento che dipende da esso o se sono necessari campi diversi (ad esempio ImageFile non è necessario in un oggetto strutturato). In questo caso, puoi avere ImageRenderObject e TexturedRenderObject .

Le implementazioni sono brevi perché la maggior parte della logica è ancora nella classe base. Tutto ciò che devi fare è implementare RenderInternal .

class ImageRenderObject : RenderObject
{
    public string ImageFile { get; set; }

    public ImageRenderObject(IDeviceContext context) : base(context) {}

    protected override void RenderInternal()
    {
        Console.WriteLine("ImageRenderObject '{0}' is rendering an image of {1}", this.Name, this.ImageFile);
    }
}

class TexturedRenderObject : RenderObject
{
    public TexturedRenderObject(IDeviceContext context) : base(context) {}

    protected override void RenderInternal ()
    {
        _context.StartTexture();
        Console.WriteLine("TexturedRenderObject is rendering {0}", this.Name);
        _context.EndTexture();
    }
}

Ora noterai che ho aggiunto un campo _context . Questo può essere compilato dall'iniezione del costruttore e dalla classe factory:

class RenderObjectFactory
{
    protected readonly IDeviceContext _context;

    public RenderObjectFactory(IDeviceContext context)
    {
        _context = context;
    }

    public T Create<T>(string name) where T : RenderObject
    {
        return Create<T>(name, Enumerable.Empty<RenderObject>());
    }

    public T Create<T>(string name, string imageFile) where T : ImageRenderObject
    {
        var instance = Create<T>(name, Enumerable.Empty<RenderObject>());
        instance.ImageFile = imageFile;
        return instance;
    }

    public T Create<T>(string name, IEnumerable<RenderObject> children) where T : RenderObject
    {
        var type = typeof(T);
        var instance = (T)Activator.CreateInstance(type, new[] {_context} );
        instance.Children.AddRange(children);
        instance.Name = name;
        return instance;
    }
}

Per i test, ho creato un contesto fittizio:

interface IDeviceContext
{
    void StartTexture();
    void EndTexture();
    void Paint(string o);
}

class DeviceContext : IDeviceContext
{
    public void StartTexture()
    {
        Console.WriteLine("Starting texture on device context.");
    }

    public void EndTexture()
    {
        Console.WriteLine("Ending texture on device context.");
    }

    public void Paint(string s) 
    {
        Console.WriteLine("Drawing {0}", s);
    }
}

Ora le tue chiamate sono molto più semplici. Ecco come lo chiameresti dal livello più alto. Nota che qui stiamo costruendo DeviceContext e factory con la parola chiave new , ma nella tua applicazione potresti volerli costruire nel Composizione Root .

public static void Main()
{
    var factory = new RenderObjectFactory(new DeviceContext());
    var divingWeasel = factory.Create<ImageRenderObject>("DivingWeasel", "DivingWeasel.png");
    var cullingBird = factory.Create<ImageRenderObject>("CullingBird", "CullingBird.png");
    var barkingHorse = factory.Create<TexturedRenderObject>("BarkingHorse", new RenderObject[] {divingWeasel, cullingBird} );
    var almighty = new Almighty();
    almighty.Render(barkingHorse);
}

In questo modo soddisfiamo i tuoi requisiti:

1. Non devi passare argomenti
2. La classe onnipotente non ha bisogno di sapere nulla dell'oggetto che sta rendendo
3. Ogni classe ha una propria implementazione specifica del comportamento, ad es. impostando le trame su o meno
4. La separazione dei dubbi è migliorata
5. La soluzione viene ridimensionata senza ulteriore codifica se vengono aggiunti nuovi animali con gli stessi comportamenti dei vecchi animali.

Output:

Starting texture on device context.
TexturedRenderObject is rendering BarkingHorse
Ending texture on device context.
ImageRenderObject 'DivingWeasel' is rendering an image of DivingWeasel.png
ImageRenderObject 'CullingBird' is rendering an image of CullingBird.png

Ecco l'esempio su DotNetFiddle: Link