ジェネリックメソッド複数（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);

それらがジェネリッククラスの一部である場合、それらはメソッドのジェネリックバージョンよりも優先されます。

ボッツの答えは100％正解です、ここに簡単な説明があります：

メソッド（ジェネリックかどうかにかかわらず）を記述し、メソッドが取るパラメーターの型を宣言するときは、コントラクトを定義します。

Type Tが行う方法を知っている一連のことを行う方法を知っているオブジェクトを私に提供した場合、「a」：宣言した型の戻り値、または「b」：を使用するある種の動作のいずれかを提供できます。そのタイプ。

（orを使用して）一度に複数のタイプを指定しようとした場合、またはコントラクトが曖昧になる複数のタイプの値を返すように取得しようとした場合：

縄跳びの方法を知っているオブジェクト、または15桁目のpiを計算する方法を知っているオブジェクトを受け取った場合、釣りに行くことができるオブジェクト、またはコンクリートを混ぜることができるオブジェクトを返します。

問題は、メソッドに入ったときに、それらがあなたにIJumpRopeかを与えたかどうかわからないということですPiFactory。さらに、先に進んでメソッドを使用する場合（魔法のようにコンパイルできると想定している場合）、Fisherまたはがあるかどうかは本当にわかりませんAbstractConcreteMixer。基本的にそれは全体をより混乱させます。

問題の解決策は、次の2つの可能性のうちの1つです。

1. 可能な変換、動作などをそれぞれ定義する複数のメソッドを定義します。それがボッツの答えです。プログラミングの世界では、これはメソッドのオーバーロードと呼ばれます。

2. メソッドに必要なすべてのことを実行する方法を知っている基本クラスまたはインターフェースを定義し、1つのメソッドがそのタイプのみを取得するようにします。これには、stringとExceptionを小さなクラスにまとめて、それらを実装にマッピングする方法を定義する必要がありますが、すべてが非常に明確で読みやすくなっています。今から4年後、あなたのコードを読んで、何が起こっているのか簡単に理解できました。

どちらを選択するかは、選択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
}

一方、継承関係のない2つの異なる型を使用する場合は、同じインターフェイスを実装する型を検討する必要があります。

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値の間違った型が含まれていますが、実行時エラーが発生します。

通常、これを使用して、メソッドが結果またはエラーを返すようにします。それは本当にそのスタイルコードをクリーンアップします。また、非常にまれに（まれに）これをメソッドのオーバーロードの代わりとして使用します。現実的には、これはそのような過負荷の非常に悪い代替品です。