c# - 抽象工厂模式——具体产品之间的依赖关系

Question

请阅读下面的代码，问题在最后。

using System;
using System.Collections.Generic;

namespace Graphics
{
    public interface IGraphicsFactory
    {
        ICanvas CreateCanvas();
        Square CreateSquare();
        ComposedShape CreateComposedShape();
    }

    public class SimpleGraphicsFactory : IGraphicsFactory
    {
        public Square CreateSquare()
        {
            return new SimpleImpl.SimpleSquare();
        }

        public ComposedShape CreateComposedShape()
        {
            return new SimpleImpl.SimpleComposedShape();
        }

        public ICanvas CreateCanvas()
        {
            return new SimpleImpl.SimpleCanvas();
        }
    }

    public interface ICanvas
    {
        void AddShape(ShapeBase shape);
        void Render();
    }

    public abstract class ShapeBase
    {
        public abstract void Paint(ICanvas canvas);
    }

    public abstract class Square : ShapeBase
    {
        public int size;
    }

    public abstract class ComposedShape : ShapeBase
    {
        public int size;
        public ShapeBase InternalShape1 { get; set; }
        public ShapeBase InternalShape2 { get; set; }
    }
}


namespace Graphics.SimpleImpl
{
    internal class SimpleSquare : Graphics.Square
    {
        public void Init()
        {
            // do something really important
        }

        public override void Paint(ICanvas canvas)
        {
            Init();

            //?? how to avoid the type cast? (and I want to keep the DrawLine out of the ICanvas interface)
            SimpleCanvas scanvas = (canvas as SimpleCanvas);
            scanvas.DrawLine();
            scanvas.DrawLine();
            scanvas.DrawLine();
            scanvas.DrawLine();
        }
    }

    internal class SimpleComposedShape : Graphics.ComposedShape
    {
        public void Init()
        {
            //?? how can I call `InternalShape1.Init', preferably without type casts? (and I want to keep `Init` out of the `ShapeBase` class)
            // this.InternalShape1.Init();
            // this.InternalShape2.Init();
        }

        public override void Paint(ICanvas canvas)
        {
            Init();
            // TODO: draw the thing
        }
    }

    internal class SimpleCanvas : Graphics.ICanvas
    {
        List<ShapeBase> shapes = new List<ShapeBase>();

        public void AddShape(ShapeBase shape)
        {
            shapes.Add(shape);
        }

        public void Render()
        {
            foreach (ShapeBase s in shapes)
            {
                s.Paint(this);
            }
        }


        public void DrawLine()
        {
        }
    }
}


namespace Test
{
    using Graphics;
    class TestSimpleGraphics
    {
        static void Test1()
        {
            IGraphicsFactory fact = new SimpleGraphicsFactory();
            ICanvas canvas = fact.CreateCanvas();

            Square sq1 = fact.CreateSquare();
            Square sq2 = fact.CreateSquare();
            ComposedShape cs = fact.CreateComposedShape();
            cs.InternalShape1 = sq1;
            cs.InternalShape2 = sq2;

            canvas.AddShape(cs);
            canvas.Paint();
        }
    }
}

我的抽象工厂模式实现正确吗？
内部SimpleSquare.Paint：可以避免类型转换吗？（我想保持界面DrawLine之外）ICanvas
内部SimpleComposedShape.Init：我怎样才能调用InternalShape.Init，最好没有类型转换？（我想Init不ShapeBase上课）

score 1 · Accepted Answer

1 - 我认为您SimpleGraphicsFactory确实是抽象工厂的一个很好的例子。

SimpleSquare2 -强制转换是完全合适的，SimpleCanvas因为它们都是同一个“家庭”的一部分，由同一个混凝土工厂创建。回忆一下抽象工厂的定义（重点是我的）：

提供用于创建相关或依赖 对象系列的接口，而无需指定它们的具体类。

这种设计模式的含义是它创建的类可以假设/要求它们与来自同一家族的类一起使用。

使用 .NET 世界中的另一个示例，System.Data命名空间以类似的方式起作用。命名空间中的对象System.Data.Sql不能与 System.Data.Oracle 中的对象一起使用。您不能在预期的SqlParameter地方传递 a。OracleParameter您选择家庭并留在家庭中。

3 - 我不知道你想做什么，你需要评论细节，我会修改我的答案来解决。我希望 aComposedShape有一种方法Add(Shape s)可以让调用者将多个形状添加到复合（容器）中。但也许我误解了。

score 0 · Accepted Answer

如果我的意图正确，那么您正在尝试模仿System.Drawing.Graphics类的功能（或 HTML <canvas>，例如）。

如果这是正确的，我会给出以下建议：

重命名IGraphicsFactory为ICanvasFactory并让它只创建具体的ICanvas实现。删除 theCreateSquare和其他方法，因为您不必通过工厂创建形状（重要的是您的 Shapes 传递了一个具体的ICanvas实现）。
该ICanvas界面代表一个可以绘制原始形状（线条、圆形、填充区域等）的画布。这意味着您应该公开允许调用者创建这些原语的公共方法。Graphics还提供了各种转换功能，但现在这可能有点矫枉过正：
```
interface ICanvas
{
     void Clear();
     void DrawLine(Point from, Point to, Pen pen);
     void DrawCircle(Point center, Double radius, Pen pen);
     void Paint();
     /* and stuff like that */
}
```

ACanvas不应包含的列表Shapes，而应包含原语列表。例如，当您调用该ICanvas.DrawLine(...)方法时，它应该创建一个Line原语的实例并将其存储在内部列表中。

这些原始类的功能将取决于您的实际实现ICanvas（它是绘制到位图还是打印机等）。您还将拥有一些隐藏的、依赖于实现的数据（我将使用 a byte[]，假装它存储某种 8 位位图）：

class BitmapCanvas : ICanvas
{
    private readonly byte[] _bitmapData;
    private readonly List<IBitmapShape> _primitives;

    public BitmapCanvas(int width, int height)
    {
        _bitmapData = new byte[width * height];
        _primitives = new List<IPrimitiveShape>();
    }

    public void DrawLine(...) 
    {
        // different implementations will handle this part differently.
        _primitives.Add(new BitmapLine(_bitmapData, from, to, pen));
    }

    public void Paint()
    {
        Clear(_bitmapData);
        foreach (var shape in _primitives)
            shape.Draw();
    }
}

然后具体的原始类将处理这个内部逻辑：

class BitmapLine : IBitmapShape
{
    public void Draw()
    {
        // write to the underlying byte array
    }
}

由于ICanvas实现不会绘制实际形状，因此您不需要ShapeBase该类。但是，您将需要一个用于绘制图形基元的模拟类（上面调用过IBitmapShape）。

c# - 抽象工厂模式——具体产品之间的依赖关系

2 回答 2

Related

Reference