Загальне обмеження типу множинних (АБО) типів

Читаючи це , я дізнався, що можна дозволити методу приймати параметри декількох типів, зробивши його загальним методом. У прикладі наступний код використовується з обмеженням типу, щоб переконатися, що "U" є an 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 . Що я хочу зробити, це сказати, що аргумент може бути типом 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": певну поведінку, яка використовує цього типу.

Якщо ви спробуєте надати йому декілька типів одночасно (маючи або) або намагаєтесь отримати його, щоб повернути значення, яке може бути більше одного типу, контракт стає нечітким:

Якщо ви дасте мені предмет, який вміє стрибати на мотузці або знає, як обчислити пі до 15-ї цифри, я поверну або предмет, який може піти на риболовлю, або, можливо, змішати бетон.

Проблема полягає в тому, що, потрапляючи в метод, ви не маєте уявлення, чи дали вам це IJumpRopeчи то PiFactory. Крім того, коли ви йдете вперед і використовуєте метод (якщо припустити, що ви отримали магічну компіляцію), ви не впевнені, чи є у вас Fisherабо AbstractConcreteMixer. В основному це робить всю річ більш заплутаною.

Рішення вашої проблеми - одна з двох можливостей:

1. Визначте більше одного методу, який визначає кожну можливу трансформацію, поведінку чи будь-яку іншу. Ось відповідь Боца. У світі програмування це називається методом перевантаження.

2. Визначте базовий клас або інтерфейс, який вміє робити всі необхідні для методу речі, а один метод має саме цей тип. Це може включати в себе завершення stringі Exceptionв невеликому класі, щоб визначити, як ви плануєте зіставити їх для реалізації, але тоді все дуже зрозуміло і легко читати. Я міг би прийти через чотири роки і прочитати ваш код і легко зрозуміти, що відбувається.

Який ви обираєте, залежить від того, наскільки складним буде вибір 1 і 2, і наскільки він повинен бути розширеним.

Тож для вашої конкретної ситуації я думаю, що ви просто витягуєте повідомлення або щось із винятку:

public interface IHasMessage
{
    string GetMessage();
}

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

Тепер все, що вам потрібно, - це методи, які перетворюють A stringі 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 містить неправильний тип значення , ви отримаєте повідомлення про помилку виконання.

Зазвичай я використовую це там, де хочу, щоб метод повернув результат або помилку. Це дійсно очищає код стилю. Я також дуже часто ( рідко ) використовую це як заміну методу перевантажень. Реально це дуже погана заміна такого перевантаження.