通用方法多重（OR）类型约束

读完这篇文章后，我了解到可以通过使方法成为通用方法来允许方法接受多种类型的参数。在示例中，以下代码与类型约束一起使用，以确保“ U”为IEnumerable<T>。

public T DoSomething<U, T>(U arg) where U : IEnumerable<T>
{
    return arg.First();
}

我发现了更多允许添加多个类型约束的代码，例如：

public void test<T>(string a, T arg) where T: ParentClass, ChildClass 
{
    //do something
}

但是，此代码似乎强制执行，arg必须同时是ParentClass 和 类型ChildClass。我想做的是说arg可以是ParentClass 或 ChildClass的以下类型：

public void test<T>(string a, T arg) where T: string OR Exception
{
//do something
}

一如既往地感谢您的帮助！

这是不可能的。但是，您可以为特定类型定义重载：

public void test(string a, string arg);
public void test(string a, Exception arg);

如果它们是泛型类的一部分，则它们将比该方法的泛型版本更可取。

Botz的回答是100％正确的，这是一个简短的解释：

在编写方法（泛型或非泛型）并声明该方法采用的参数类型时，您正在定义合同：

如果您给我一个知道如何执行类型T所知道的事情的对象，那么我可以传递“ a”：我声明的类型的返回值，或者“ b”：某种使用这种类型。

如果您一次尝试给它一个以上的类型（通过使用or），或者试图使其返回一个可能不止一种类型的值，则契约变得模糊：

如果您给我一个知道如何跳绳或知道如何将pi计算到第15位的对象，我将返回一个可以钓鱼的对象，也可以将其与混凝土混合。

问题是，当您进入方法时，您不知道他们是否给了您an IJumpRope或a PiFactory。此外，当您继续使用该方法（假设已经对其进行了神奇的编译）时，您实际上不确定是否具有a Fisher或an AbstractConcreteMixer。基本上，这会使整个过程更加混乱。

解决问题的方法是两种可能性之一：

1. 定义多个定义每种可能的转换，行为或任何其他方法的方法。那是博茨的答案。在编程世界中，这称为“重载方法”。

2. 定义一个基类或接口，该基类或接口知道如何执行该方法所需的所有操作，并使一个方法仅采用该类型。这可能需要在一个小类中包装一个string和Exception，以定义如何计划将它们映射到实现，但是随后所有内容都非常清晰易读。从现在起四年后，我可能会来阅读您的代码并轻松了解发生了什么。

您选择哪种取决于选项1和2的复杂程度以及所需的可扩展性。

因此，对于您的特定情况，我将想象您只是从异常中提取消息或其他内容：

public interface IHasMessage
{
    string GetMessage();
}

public void test(string a, IHasMessage arg)
{
    //Use message
}

现在，您所需要的只是将a string和an Exception转换为IHasMessage的方法。好简单。

如果ChildClass表示它是从ParentClass派生的，则可以编写以下代码以接受ParentClass和ChildClass；

public void test<T>(string a, T arg) where T: ParentClass 
{
    //do something
}

另一方面，如果要使用两个不同的类型且它们之间没有继承关系，则应考虑实现相同接口的类型。

public interface ICommonInterface
{
    string SomeCommonProperty { get; set; }
}

public class AA : ICommonInterface
{
    public string SomeCommonProperty
    {
        get;set;
    }
}

public class BB : ICommonInterface
{
    public string SomeCommonProperty
    {
        get;
        set;
    }
}

然后您可以将通用函数编写为：

public void Test<T>(string a, T arg) where T : ICommonInterface
{
    //do something
}

就像这个问题一样古老，我仍然对上面的解释有随意的投票。解释仍然很完美，但是我将第二次回答一个类型，该类型可以很好地替代联合类型（对这种强类型的回答，C＃不直接支持该问题） ）。

using System;
using System.Diagnostics;

namespace Union {
    [DebuggerDisplay("{currType}: {ToString()}")]
    public struct Either<TP, TA> {
        enum CurrType {
            Neither = 0,
            Primary,
            Alternate,
        }
        private readonly CurrType currType;
        private readonly TP primary;
        private readonly TA alternate;

        public bool IsNeither => currType == CurrType.Primary;
        public bool IsPrimary => currType == CurrType.Primary;
        public bool IsAlternate => currType == CurrType.Alternate;

        public static implicit operator Either<TP, TA>(TP val) => new Either<TP, TA>(val);

        public static implicit operator Either<TP, TA>(TA val) => new Either<TP, TA>(val);

        public static implicit operator TP(Either<TP, TA> @this) => @this.Primary;

        public static implicit operator TA(Either<TP, TA> @this) => @this.Alternate;

        public override string ToString() {
            string description = IsNeither ? "" :
                $": {(IsPrimary ? typeof(TP).Name : typeof(TA).Name)}";
            return $"{currType.ToString("")}{description}";
        }

        public Either(TP val) {
            currType = CurrType.Primary;
            primary = val;
            alternate = default(TA);
        }

        public Either(TA val) {
            currType = CurrType.Alternate;
            alternate = val;
            primary = default(TP);
        }

        public TP Primary {
            get {
                Validate(CurrType.Primary);
                return primary;
            }
        }

        public TA Alternate {
            get {
                Validate(CurrType.Alternate);
                return alternate;
            }
        }

        private void Validate(CurrType desiredType) {
            if (desiredType != currType) {
                throw new InvalidOperationException($"Attempting to get {desiredType} when {currType} is set");
            }
        }
    }
}

上述类代表一种类型，可以是任一 TP 或 TA。您可以这样使用它（这些类型指的是我的原始答案）：

// ...
public static Either<FishingBot, ConcreteMixer> DemoFunc(Either<JumpRope, PiCalculator> arg) {
  if (arg.IsPrimary) {
    return new FishingBot(arg.Primary);
  }
  return new ConcreteMixer(arg.Secondary);
}

// elsewhere:

var fishBotOrConcreteMixer = DemoFunc(new JumpRope());
var fishBotOrConcreteMixer = DemoFunc(new PiCalculator());

重要笔记：

• 如果不检查就会出现运行时错误 IsPrimary。
• 您可以检查IsNeither IsPrimary或IsAlternate。
• 您可以通过访问值 Primary和Alternate
• TP / TA和Either之间有隐式转换器，使您可以传递值或Either期望传递值的任何位置。如果确实传递了期望Either的TA或TP，但Either包含错误的值类型，则会出现运行时错误。

我通常在需要方法返回结果或错误的地方使用此方法。它确实清除了该样式代码。我也偶尔（很少）用它代替方法重载。实际上，这是对这种过载的非常差的替代。