C# 分组分类类函数

想象一个如下的类。。这是提供给我的一门课。。我不能改变它的来源

public class MyClass
{
    object _Object { get; set; }

    public void FuncA1() { _Object = new object(); }
    public void FuncA2() { _Object = new List<object>(); }

    public int FuncB1() { _Object = 0; return 0; }
    public int FuncB2() { _Object = 123; return 123; }

    public string FuncC1() { _Object = null; return null; }
    public string FuncC2() { _Object = "Hello"; return "Hello"; }
}

对于这个场景，我能想到的唯一解决方案是像这样设计包装器：

public class MyWrapper
{
    MyClass _Instance { get; set; }
    public _Void Voids { get; private set; }
    public _Integer Integers { get; private set; }
    public _String Strings { get; private set; }

    public class _Void
    {
        MyWrapper _Parent { get; set; }

        public void FuncA1() { _Parent._Instance.FuncA1(); }
        public int FuncA2() { return _Parent._Instance.FuncA2(); }
    }
    public class _Integer
    {
        ...
    }
    public class _String
    {
        ...
    }

    public MyWrapper()
    {
        _Instance = new MyClass();
        Voids = new _Voids(this);
        Integers = new _Integer(this);
        Strings = new _String(this);
    }
}

此解决方案可行，但存在许多问题： -内部类被强制为公共类，这允许用户实例化它们。。 -我被迫在子类中维护父对象的引用

有更好的方法吗

编辑：最初发布的代码有点混乱，因为它将注意力从核心问题转移到了函数是否会导致异常的问题上，如果它们都在同一个对象上工作

注意：这不是实际代码。。我把这个例子拼凑在一起，以说明我正在努力做什么。。围绕对象创建一个包装器（我无法更改原始对象的代码），并将函数分组到类别中

最终编辑：遵循Juharr的建议。。以下是我为实现我的目标所做的。。为了他人的利益

public interface IVoid
{
    void FuncA1();
    void FuncA2();
}
public interface IInteger
{
    int FuncB1();
    int FuncB2();
}
public class MyWrapper
{
    public MyClass Instance { get; private set; }
    public IVoid Voids { get; private set; }
    public IInteger Integers { get; private set; }

    private abstract class MyBase
    {
        protected MyWrapper Parent { get; set; }
        protected MyClass Instance { get { return Parent.Instance; } }
        public MyBase(MyWrapper oParent) { Parent = oParent; }
    }
    private class MyVoid : MyBase, IVoid
    {
        public MyVoids (MyWrapper oParent) : base(oParent) { }
        public void FuncA1() { Instance.FuncA1(); }
        public void FuncA2() { Instance.FuncA2(); }
    }
    private class MyInteger : MyBase, IInteger
    {
        public MyInteger (MyWrapper oParent) : base(oParent) { }
        public int FuncB1() { return Instance.FuncB1(); }
        public int FuncB2() { return Instance.FuncB2(); }
    }

    public MyWrapper()
    {
        Instance = new MyClass();
        Voids = new MyVoid(this);
        Integers = new MyInteger(this);
    }
}

---

您可以编写公共接口。这样，您的内部类就不必是公共的。像这样

public interface IIntger
{
    void Set(int iValue);
    int Get();
}

public class MyWrapper
{
    MyClass _Instance { get; set; }
    public IInteger Integer { get; private set; }

    private class _Integer : IInteger
    {
        MyWrapper _Parent { get; set; }

        public void Set(int iValue) { _Parent._Instance.IntegerSet(iValue); }
        public int Get() { return _Parent._Instance.IntegerGet(); }
    }

    public MyWrapper()
    {
        _Instance = new MyClass();
        Integer = new _Integer(this);
    }
}

编辑：

要回答问题的第二部分，您需要对父类的引用或对正在包装的类的引用。所以你可以用这个来代替

public class MyWrapper
{
    public IInteger Integer { get; private set; }

    private class _Integer : IInteger
    {
        MyClass _Instance { get; set; }
        public _Integer(MyClass myClass) { _Instance = myClass; }
        public void Set(int iValue) { _Instance.IntegerSet(iValue); }
        public int Get() { return _Instance.IntegerGet(); }
    }

    public MyWrapper(MyClass instance)
    {
        Integer = new _Integer(instance);
    }
}

---

您想在同一个

MyClass

上混合

String

和

Int

内容，有什么特别的原因吗？如果您存储了一个字符串，如果您试图点击<代码>整数/ set > <代码>或<代码> MathSqrt /ABS函数。您应该真正考虑使用属性而不是GET和SET方法。@克里斯…这只是一个例子。。我刚刚拼凑了一个类来说明有一个单一的对象，它上面有大量的函数。。我并不是将对象强制转换为整数或字符串。。我写它只是为了证明我需要对函数进行分组。。就这些。。我想我会编辑这个问题来更改确切的伪函数调用..hmmmmm。。干得好！我一点也没想到。。这确实解决了允许内部类保持私有的问题。。然而，还有一个问题仍然存在。。对于每个内部类，我必须存储对父类（或需要使用的父类对象）的引用。。有没有一种方法可以避免这种情况（不使类成为静态的）。。如果你能在你的答案中包括这一点（无论是肯定还是否定），我会接受你的答案。。谢谢..作为对您第二次编辑的回应。。这就是我所担心的。。需要在每个子私有类中明确存储引用=s无论如何。。谢谢你，伙计……）

public class MyWrapper
{
    public IInteger Integer { get; private set; }

    private class _Integer : IInteger
    {
        MyClass _Instance { get; set; }
        public _Integer(MyClass myClass) { _Instance = myClass; }
        public void Set(int iValue) { _Instance.IntegerSet(iValue); }
        public int Get() { return _Instance.IntegerGet(); }
    }

    public MyWrapper(MyClass instance)
    {
        Integer = new _Integer(instance);
    }
}