C# 是否可以通过方法名约束类型？

例如，类型

AA

、

BB

和

CC

都有一个方法

Close（）

。它们不实现任何类型的接口，其中包含

void Close（）

。是否可以基于具有名为

Close

的方法的类型执行类型约束

public static void CloseThis<T>(this T openObject) where T : Closeable
{
    openObject.Close();
}

publicstaticvoidclosethis（这个T openObject），其中T:Closeable
{
openObject.Close（）；
}

您可以执行以下操作：

class Abc
{
    public void Close()
    { }
}

interface IClosable
{
    void Close();
}

class AbcClosable : Abc, IClosable
{ }

class GenClosable<T> where T : IClosable
{ }

---

您可以这样做：

class Abc
{
    public void Close()
    { }
}

interface IClosable
{
    void Close();
}

class AbcClosable : Abc, IClosable
{ }

class GenClosable<T> where T : IClosable
{ }

---

您可以使用反射来测试对象是否有close方法，然后在存在时调用它

    static void CloseIfClosable(object o)
    {
        Type oType = o.GetType();
        MethodInfo closeMethod = oType.GetMethod("Close");
        if (closeMethod != null)
        {
            closeMethod.Invoke(o, new object[] { });
        }
    }

---

一般来说，您希望避免反射，但如果您被迫使用无法控制的麻烦类型，这可能是最佳选择

您可以使用反射来测试对象是否有close方法，如果存在，则调用它

    static void CloseIfClosable(object o)
    {
        Type oType = o.GetType();
        MethodInfo closeMethod = oType.GetMethod("Close");
        if (closeMethod != null)
        {
            closeMethod.Invoke(o, new object[] { });
        }
    }

---

一般来说，您希望避免反射，但如果您被迫使用无法控制的麻烦类型，这可能是最佳选择

对我来说，解决方案应该基于聚合而不是继承。为什么？“它们是我无法编辑的类型”。我认为，因为这种类型属于另一个开发人员|公司|等，继承增加了耦合，所以解决方案应该基于聚合

请注意，

AA

、

BB

或

CC

中的任何一个都可以

密封

或

密封

public sealed class Aa
{
    public void Close()
    {
    }
}

public interface IClosable
{
    void Close();
}

internal class AbcClosable : IClosable
{
    private readonly Aa _aa;

    public AbcClosable(Aa aa)
    {
        _aa = aa;
    }

    public void Close()
    {
        _aa.Close();
    }
}

public static class CloseableExtensions
{
    public static void CloseThis<T>(this T value)
        where T : IClosable
    {
        value.Close();
    }
}

公共密封等级Aa
{
公众假期结束（）
{
}
}
公共接口可关闭
{
无效关闭（）；
}
内部类AbcClosable:IClosable
{
私人只读Aa_Aa；
公共AbcClosable（Aa）
{
_aa=aa；
}
公众假期结束（）
{
_aa.Close（）；
}
}
公共静态类CloseableExtensions
{
公共静态无效关闭此（此T值）
其中T:IClosable
{
value.Close（）；
}
}

对我来说，解决方案应该基于聚合而不是继承。为什么？“它们是我无法编辑的类型”。我认为，因为这种类型属于另一个开发人员|公司|等，继承增加了耦合，所以解决方案应该基于聚合

请注意，

AA

、

BB

或

CC

中的任何一个都可以

密封

或

密封

public sealed class Aa
{
    public void Close()
    {
    }
}

public interface IClosable
{
    void Close();
}

internal class AbcClosable : IClosable
{
    private readonly Aa _aa;

    public AbcClosable(Aa aa)
    {
        _aa = aa;
    }

    public void Close()
    {
        _aa.Close();
    }
}

public static class CloseableExtensions
{
    public static void CloseThis<T>(this T value)
        where T : IClosable
    {
        value.Close();
    }
}

公共密封等级Aa
{
公众假期结束（）
{
}
}
公共接口可关闭
{
无效关闭（）；
}
内部类AbcClosable:IClosable
{
私人只读Aa_Aa；
公共AbcClosable（Aa）
{
_aa=aa；
}
公众假期结束（）
{
_aa.Close（）；
}
}
公共静态类CloseableExtensions
{
公共静态无效关闭此（此T值）
其中T:IClosable
{
value.Close（）；
}
}

…仅当它们实现接口时。有什么东西阻止你这么做吗？它们是我无法编辑的类型。如果可以的话，我无法包装类、实现closeable或扩展…只有在它们实现接口的情况下。有什么东西阻止你这么做吗？它们是我无法编辑的类型。如果可以的话，可以包装类、实现closeable或扩展