ข้อ จำกัด ประเภทหลายวิธีทั่วไป (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% นี่คือคำอธิบายสั้น ๆ :

เมื่อคุณเขียนเมธอด (ทั่วไปหรือไม่) และประกาศประเภทของพารามิเตอร์ที่เมธอดใช้คุณกำลังกำหนดสัญญา:

ถ้าคุณให้วัตถุที่รู้วิธีทำชุดของสิ่งที่ Type T รู้วิธีทำฉันสามารถส่ง 'a': ค่าส่งคืนของประเภทที่ฉันประกาศหรือ 'b': พฤติกรรมบางอย่างที่ใช้ ประเภทนั้น.

หากคุณลองและให้มากกว่าหนึ่งประเภทในแต่ละครั้ง (โดยมีหรือ) หรือพยายามให้มันส่งคืนค่าที่อาจมีมากกว่าหนึ่งประเภทที่สัญญาจะคลุมเครือ:

ถ้าคุณให้วัตถุที่รู้วิธีกระโดดเชือกหรือรู้วิธีคำนวณค่า pi เป็นหลัก 15 ฉันจะส่งคืนวัตถุที่ตกปลาได้หรืออาจจะผสมคอนกรีต

ปัญหาคือเมื่อคุณเข้าสู่วิธีการที่คุณไม่รู้ว่าพวกเขาให้IJumpRopeหรือPiFactory. นอกจากนี้เมื่อคุณดำเนินการต่อและใช้วิธีการ (สมมติว่าคุณได้รับมันมาเพื่อรวบรวมอย่างน่าอัศจรรย์) คุณไม่แน่ใจจริงๆว่าคุณมีFisherหรือAbstractConcreteMixer. โดยพื้นฐานแล้วมันทำให้ทุกอย่างสับสนมากขึ้น

วิธีแก้ปัญหาของคุณเป็นหนึ่งในสองความเป็นไปได้:

1. กำหนดวิธีการมากกว่าหนึ่งวิธีที่กำหนดการเปลี่ยนแปลงพฤติกรรมหรืออะไรก็ตามที่เป็นไปได้ นั่นคือคำตอบของ Botz ในโลกของการเขียนโปรแกรมสิ่งนี้เรียกว่า Overloading the method

2. กำหนดคลาสพื้นฐานหรืออินเทอร์เฟซที่รู้วิธีทำทุกสิ่งที่คุณต้องการสำหรับเมธอดและมีวิธีการเดียวที่ใช้เพียงประเภทนั้น สิ่งนี้อาจเกี่ยวข้องกับการรวม a stringและExceptionในชั้นเรียนขนาดเล็กเพื่อกำหนดวิธีที่คุณวางแผนในการทำแผนที่กับการนำไปใช้งาน แต่แล้วทุกอย่างก็ชัดเจนและอ่านง่ายมาก ฉันจะมาสี่ปีจากนี้และอ่านรหัสของคุณและเข้าใจสิ่งที่เกิดขึ้นได้อย่างง่ายดาย

สิ่งที่คุณเลือกขึ้นอยู่กับว่าตัวเลือกที่ 1 และ 2 จะซับซ้อนเพียงใดและต้องขยายได้อย่างไร

ดังนั้นสำหรับสถานการณ์เฉพาะของคุณฉันจะจินตนาการว่าคุณแค่ดึงข้อความหรือบางอย่างออกจากข้อยกเว้น:

public interface IHasMessage
{
    string GetMessage();
}

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

ตอนนี้สิ่งที่คุณต้องมีคือวิธีการที่เปลี่ยน a stringและa 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 IsPrimaryIsAlternate
• คุณสามารถเข้าถึงค่าผ่านPrimaryและAlternate
• มีตัวแปลงโดยนัยระหว่าง TP / TA และอย่างใดอย่างหนึ่งเพื่อให้คุณส่งผ่านค่าหรือที่Eitherใดก็ได้ที่คาดหวัง ถ้าคุณทำผ่านEitherที่TAหรือTPคาดว่า แต่Eitherมีผิดประเภทของค่าที่คุณจะได้รับข้อผิดพลาด runtime

ฉันมักจะใช้สิ่งนี้ในที่ที่ฉันต้องการวิธีการส่งคืนผลลัพธ์หรือข้อผิดพลาด มันทำความสะอาดโค้ดสไตล์นั้นจริงๆ ฉันยังเป็นครั้งคราว ( ไม่ค่อย ) ใช้นี้แทน overloads วิธีการ ตามความเป็นจริงนี่เป็นการทดแทนที่แย่มากสำหรับการโอเวอร์โหลด