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

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();
        }
    }
}

1. 我的抽象工厂模式实现是否正确？
2. 内部SimpleSquare.Paint：可以避免类型转换吗？ （并且我想将DrawLine 排除在ICanvas 接口之外）
3. 在SimpleComposedShape.Init 内部：我怎样才能调用InternalShape.Init，最好没有类型转换？ （并且我想将Init 排除在ShapeBase 类之外）

Answer 1

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

2 - SimpleSquare 转换为 SimpleCanvas 是完全合适的，因为它们都是同一个“家族”的一部分，由同一个具体工厂创建。回忆一下抽象工厂的定义（重点是我的）：

提供一个接口来创建相关或依赖的家庭 没有指定具体类的对象。

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

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

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

Answer 2

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

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

1. 将 IGraphicsFactory 重命名为 ICanvasFactory 并让它只创建具体的 ICanvas 实现。删除 CreateSquare 和其他方法，因为您不必通过工厂创建形状（只有通过具体的 ICanvas 实现来传递形状很重要）。

2. 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 */
   }
   

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

   这些原始类的功能将取决于您的ICanvas 的实际实现（它是绘制到位图还是打印到打印机等）。您还将拥有一些隐藏的、依赖于实现的数据（我将使用 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();
       }
   }
   

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

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

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