0

我正在使用类似于此的接口和类结构的系统中工作：

interface ILw                // a lightweight interface definition

class Medium : ILw

class FullA : Medium         // full class definitions
class FullB : Medium

class LwA : ILw              // lightweight class definitions
class LwB : ILw

在系统中，我遇到的对象可能是完整的或轻量级的，因此具有需要ILw接口的功能。我在这个设计中遇到的问题是，需要在对象的完整版本和轻量版本之间共享的数据和方法比ILw中定义的要多。所以我发现自己需要做这样的事情：

if (myvar is FullA)
{
   (myvar as FullA).MyFunction()
} 
else
{
   (myvar as LwA).MyFunction()
}

其中MyFunction()在每个FullA和LwA中分别实现，并且可以在相同的数据结构上工作。我想消除这种代码重复。

以我的 C++ 背景，这似乎是多重继承的典型案例；即，为两者都需要的数据和方法定义一个类SharedA并将其添加到FullA和LwA的父列表中。但我需要一些指导来帮助在 C# 和接口世界中思考这个问题。是否有公认的模式来解决这个问题？

谢谢你。

更新：

在迄今为止收到的评论的帮助下，我已经能够通过 1) 一个需要聚合共享数据的中间接口和 2) 一个用于处理这些数据的方法的扩展类来重构一个更好的设计。理想情况下，这些（数据和方法）将被连接到同一个结构中。我觉得 mate-in-1 在董事会上，我只是看不到它。

public interface ILwBase { }

class Medium : ILwBase { }

public class LwDataA
{
    static private int _count = 0;
    public int id;
    public LwDataA() { id = ++_count; }
}

public interface ILwA : ILwBase 
{
   LwDataA ExtData { get; }
}

public static class ExtLwA
{
   public static void MyFunction(this ILwA o) 
   {
      Console.WriteLine("id = " + o.ExtData.id); 
   }
}

class LwA : ILwA
{
   private LwDataA _extData = new LwDataA();
   public LwDataA ExtData { get { return (_extData); } }
}

class FullA : Medium, ILwA
{
   private LwDataA _extData = new LwDataA();
   public LwDataA ExtData { get { return (_extData); } }
}

class Program
{
   static void Main()
   {
      ILwA a1 = new FullA();
      ILwA a2 = new LwA();

      a1.MyFunction();
      a2.MyFunction();
   }
}

这允许我在 LwA 和 FullA 之间只需要两行重复代码。它消除了通过聚合属性调用（我之前的编辑）或在聚合周围实现包装器的需要。

希望这能澄清我想要实现的目标。这是最好的解决方案吗？

4

2 回答 2

2

在我们的评论交流之后，您现在的问题与原始帖子不同。你不能直接拥有多重继承会给你的东西。但是有多种方法可以让您非常接近。

MyFunction()变体 1：欺骗需要将其作为扩展方法接收的特殊类。要做到这一点，您需要一个“差异化器”；在我的示例中是 ILwA 接口。请注意，它必须定义另一个共性，而不是MyFunction(). 一个getter（或一个setter）就可以了。这里的限制是 MyFunction 无权访问私有成员。

//instead of the lightweight interface (but use interface if it makes more sense)
abstract class LwBase 

abstract class HwBase : LwBase

public interface IADiff { int APropTrick { get; } }

// lightweight class definitions
class LwA : LwBase, IADiff
class LwB : LwBase

// full class definitions
class FullA : HwBase, IADiff
class FullB : HwBase

public static class AExtensions
{
    public static void MyFunction(this IADiff o)
    {
        // impl.
    }
}

变体 2：使用提供实现MyFunction()和“重定向”的通用类：

abstract class LwBase 

abstract class HwBase : LwBase

public interface IADiff { int MyFunction(); }

public class AConcr : IADiff //implemenst Myfunction()

// lightweight class definitions
class LwA : LwBase, IADiff
{
    private AConcr a = new AConcr();

    public int MyFunction() { return a.MyFunction(); }
}
class LwB : LwBase

// full class definitions
class FullA : HwBase, IADiff
{
    private AConcr a = new AConcr();

    public int MyFunction() { return a.MyFunction(); }
}
class FullB : HwBase

变体 3：我在研究您的问题时偶然发现了这篇文章。我不能很快说这是否是一个可行的选择，但它确实提供了一些想法。

学分：我从这个 SO 线程大量借用，并使用这个不错的网站作为参考。

于 2013-05-09T02:12:02.713 回答
1

要共享实现，您可以让它们都继承自abstract：

interface ILwBase                // a lightweight interface definition
interface ILwA : ILwBase
interface ILwB : ILwBase

class Intermediate : ILwBase

abstract class AbstractA : ILwA {
  void MyFunction() {...}
}

class LwA : AbstractA, Intermediate
class LwB : Intermediate 

class FullA : AbstractA
class FullB : ILwB

阅读有关抽象类的更多信息（在 MSDN 上）

于 2013-05-09T02:17:50.790 回答