C# al@RuneFS听起来像是另一个问题。@RuneFS：你说得对，我只想在父类中充分使用子类对象的功能，并且只公开它的某些选定方法。我已经对问题进行了编辑，以使其更加清晰。@Jodrell我相信这对你来说听起来像是一个不同的问题，因为你的答案确实符合我阅读

---

al@RuneFS听起来像是另一个问题。@RuneFS：你说得对，我只想在父类中充分使用子类对象的功能，并且只公开它的某些选定方法。我已经对问题进行了编辑，以使其更加清晰。@Jodrell我相信这对你来说听起来像是一个不同的问题，因为你的答案确实符合我阅读问题的方式。然而，在这个问题上，除了随意的名字之外，没有人支持is-a关系。继承经常被滥用。只有在建立了is-a关系时才应该使用它。在这种情况下没有。@RuneFS和

MyBaseClass

的所有成员都是公开的。撇开语义不谈，这是最突出的一点。不管怎样，我的答案现在涵盖了问题的两个方面。我把它标记为一个答案，因为它最接近我想要实现的目标。不幸的是，看看代码，我认为在父类中为子类中的每个方法使用一个方法没有那么复杂，应该比在新的“通用”方法中检查参数类型更快。如果我错了，请纠正我。如果有很多方法要传递接收到的参数，那么它应该会更快，但更麻烦。@WRonX，如果有几个方法具有相同的签名，但仅在名称上不同，会发生什么情况？让我们为这段代码默哀一分钟。究竟为什么要传递一个对象数组（大小未知），检查它的大小，转换所有项，然后将调用分派给适当的方法？写几行可读的代码（甚至看似冗余的代码）真的会比使用这个怪物更容易吗？您可以使用如此漂亮的强类型语言，您正在将它变成PHP的一个更丑陋的兄弟。你们真丢脸，伙计们。“你真可耻！”皮奥特贾斯蒂娜，绝对是。这将在生产代码中造成很多混乱。但是OP似乎想要它，所以。。。

class MyChildClass
{
    public void myMethod(int i)
        { /* do something with i */ }
    public void myMethod(int a, string b)
        { /* get i from a and b and call: */ myMethod(i); }
    public void myMethod(string c, string d)
        { /* get i from c and d and call: */ myMethod(i); }
}

class MyBaseClass
{
    private MyChildClass myObject = new myChildClass(); // or similar
    public void myMethod(int i) 
        { myObject.myMethod(i);    }
    public void myMethod(int a, string b) 
        { myObject.myMethod(a, b); }
    public void myMethod(string c, string s) 
        { myObject.myMethod(c, d); }
}

public void myMethod(unknownListOfArgumentsOfDifferentTypes args)
    { myObject.myMethod(args); }

class MyChildClass : MyBaseClass
{
}

class SemiGenericFacade<T> where T : new()
{
    private readonly t = new T();

    public void CallVoidOnT(string name, params object[] parameters)
    {
        var paramTypes = parameters.Select(p => typeof(p))

        var match = typeof(T).GetMethodBySig(typeof(void), paramTypes)
            .Single(mi => mi.Name == name);

        match.Invoke(this.t, parameters);
    }
}

public static class Extensions
{
    public static MethodInfo GetMethodByNameThenSig(
        this Type type,
        string name, 
        Type returnType, 
        params Type[] parameterTypes)
    {
        return type.GetMethods().Where((m) =>
        {
            if (m.Name != name)
            {
                return false;
            }

            if (m.ReturnType != returnType)
            {
                return false;
            }

            var parameters = m.GetParameters();
            if ((parameterTypes == null || parameterTypes.Length == 0))
            {
                return parameters.Length == 0;
            }

            if (parameters.Length != parameterTypes.Length)
            {
                return false;
            }

            for (int i = 0; i < parameterTypes.Length; i++)
            {
                if (parameters[i].ParameterType != parameterTypes[i])
                {
                    return false;
                }
            }

            return true;
        }).Single();
    }
}

class GenericFacade<T> where T : new()
{
    private readonly t = new T();

    public void CallOnInternal(string name, params object[] parameters)
    {
        var paramTypes = parameters.Select(p => typeof(p))

        var match = typeof(T).GetMethodByNameThenSig(
            name,
            typeof(void),
            paramTypes);

        match.Invoke(this.t, parameters);
    }

    public TResult CallOnInternal<TResult>(string name, params object[] parameters)
    {
        var paramTypes = parameters.Select(p => typeof(p))

        var match = typeof(T).GetMethodByNameThenSig(
            name,
            typeof(TResult),
            paramTypes);

        return (TResult)match.Invoke(this.t, parameters);
    }
}

public static void Main()
{
    UnknownArgumentsMethod1(1, 2, 3, "foo");
}

public static void UnknownArgumentsMethod1(params object[] list)
{
    UnknownArgumentsMethod2(list);
}

public static void UnknownArgumentsMethod2(params object[] list)
{
    foreach (object o in list)
    {
        if (o.GetType() == typeof(int))
        {
            Console.WriteLine("This is an integer: " + (int)o);
        }
        else if (o.GetType() == typeof(string))
        {
            Console.WriteLine("This is a string: " + (string)o);
        }
    }
}

class MyBaseClass: MyChildClass
{
}

public class BaseClass
{
    public  IChildClass ChildClassInstance = new ChildClass();
}

public class ChildClass : IChildClass
{
    public void myMethod(int i)
    { /* do something with i */ }
    public void myMethod(int a, string b)
    { /* get i from a and b and call: */ myMethod(i); }
    public void myMethod(string c, string d)
    { /* get i from c and d and call: */ myMethod(i); }
}

public interface IChildClass
{
    void myMethod(int i);
    void myMethod(int a, string b);
}

BaseClass test = new BaseClass();
test.ChildClassInstance.myMethod(1);
test.ChildClassInstance.myMethod(1,"test");