嵌套类和接口

Question

（如果有人想帮助解决这个问题，我真的很难为这个问题想出一个好的标题......）

所以我在设计某些东西时遇到了问题。本质上，我有一个 A 类，它由 B 类型的对象数组组成。我只希望 A 类的接口被公开，并且希望 B 类对任何用户基本上都是隐藏的。我希望能够对类型 B 及其数据执行操作，但只能通过类 A 的接口/方法调用 B 实例的方法。棘手的部分是我想创建一个对成员执行操作的方法类型 B，但我想实现一个接口，然后有一个实现该接口的类，因为我希望我的用户能够创建他们自己的此方法的实现。我正在考虑做类似的事情：

public class A 
{
    B[] arr;
    C c;

    public A(C c) 
    { 
        arr = new B[100];
        this.c = c;
    }


    public void method1() 
    {
        var b = new B();
        b.someMethodofb(c);    // pass c to the method of b
    }

    private class B 
    {
        someMethodOfb(C c) 
        {
        }
    }
}

public class C : Interface1 
{
    public void method(B b) 
    {    
        //interface method we have implemented
    }
}

我将 B 类设为私有，因为我只希望 A 类公开可用，因此 B 类发生的任何事情都通过 A 类发生，这也是我将 B 嵌套在 A 中的原因。但是由于 B 类是私有的，我会能够将它用作我的 C 类方法的参数吗？ Interface1实现的方法会影响B如何执行someMethodOfb的内部实现，这就是为什么我认为我需要将它传入才能保持B类的隐藏性质。有没有更好的方法让我设计这个并能够实现我在​​第一段中设定的目标？

Answer 1

我建议您为 B 的公共已知端添加另一个接口，让 B 实现该接口并让 C 的方法使用该接口。

public interface IC {
    void method(IB b);
}

public interface IB {
    int Priority { get; set; }
    int Urgency { get; set; }
}

public class A {
    B[] arr;
    IC c;

    public A(C c) {
        arr = new B[100];
        this.c = c;
    }


    public void method1() {
        var r = (new Random()).Next(100);
        arr[r].someMethodOfB(c);    // pass c to the method of b
    }

    private class B : IB {
        public int Priority { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public int Urgency { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }

        internal void someMethodOfB(IC aC) {
            aC.method(this);
            throw new NotImplementedException();
        }
    }
}

public class C : IC { // user implements
    public void method(IB b) {
        if (b.Priority > 10 || b.Urgency > 10)
            ; // do something with BI using b
        throw new NotImplementedException();
    }
}

现在类的用户需要知道IC，这样他们才能创建C，他们需要知道IB，这样他们才能在C中编写方法的主体，但他们不需要了解所有B 或访问B。

Answer 2

让我们用具体的例子:)

假设我们有三个类：Customer、Order 和 OrderProcessor。 Customer 和 Order 是分别代表一个客户和一个订单的实体，而 OrderProcessor 将处理一个订单：

public interface IOrderProcessor
{
    void ProcessOrder(IOrder order);
}

public interface IOrder
{
    void FinalizeSelf(IOrderProcessor oProc);
    int CustomerId {get; set;}
}

public class Customer
{
    List<IOrder> _orders;
    IOrderProcessor _oProc;
    int _id;

    public Customer(IOrderProcessor oProc, int CustId)
    {
        _oProc = oProc;
        _orders = new List<IOrder>();
        _id = CustId;
    }

    public void CreateNewOrder()
    {
        IOrder _order = new Order() { CustomerId = _id };
        _order.FinalizeSelf(_oProc);
        _orders.Add(_order);
    }

    private class Order : IOrder
    {
        public int CustomerId {get; set;}
        public void FinalizeSelf(IOrderProcessor oProcessor)
        {
            oProcessor.ProcessOrder(this);
        }
    }
}
public class ConcreteProcessor : IOrderProcessor
{
    public void ProcessOrder(IOrder order)
    {
        //Do something
    }
}