Ràng buộc kiểu nhiều phương thức chung (OR)

Đọc điều này , tôi đã học được rằng có thể cho phép một phương thức chấp nhận các tham số của nhiều loại bằng cách biến nó thành một phương thức chung. Trong ví dụ này, đoạn mã sau được sử dụng với ràng buộc kiểu để đảm bảo "U" là một IEnumerable<T>.

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

Tôi đã tìm thấy một số mã cho phép thêm nhiều ràng buộc kiểu, chẳng hạn như:

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

Tuy nhiên, mã này dường như bắt buộc argphải là cả một loại ParentClass và ChildClass . Những gì tôi muốn làm là nói rằng arg có thể là một loại ParentClass hoặc ChildClass theo cách sau:

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

Sự giúp đỡ của bạn được đánh giá cao như mọi khi!

Đó là không thể. Tuy nhiên, bạn có thể xác định tình trạng quá tải cho các loại cụ thể:

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

Nếu chúng là một phần của lớp chung, chúng sẽ được ưu tiên hơn phiên bản chung của phương thức.

Botz trả lời đúng 100%, đây là một lời giải thích ngắn:

Khi bạn đang viết một phương thức (chung chung hoặc không) và khai báo các loại tham số mà phương thức đưa bạn đang xác định hợp đồng:

Nếu bạn đưa cho tôi một đối tượng biết cách thực hiện tập hợp những thứ mà Loại T biết cách thực hiện, tôi có thể cung cấp 'a': giá trị trả về của loại tôi khai báo hoặc 'b': một số loại hành vi sử dụng kiểu đó

Nếu bạn thử và cung cấp cho nó nhiều loại cùng một lúc (bằng cách có hoặc) hoặc cố gắng lấy nó để trả về một giá trị có thể nhiều hơn một loại mà hợp đồng trở nên mờ nhạt:

Nếu bạn đưa cho tôi một vật thể biết nhảy dây hoặc biết cách tính số pi đến chữ số thứ 15, tôi sẽ trả lại một vật có thể đi câu cá hoặc có thể trộn bê tông.

Vấn đề là khi bạn tham gia vào phương pháp, bạn không biết họ đã cho bạn một IJumpRopehay a PiFactory. Hơn nữa, khi bạn tiếp tục và sử dụng phương pháp (giả sử rằng bạn đã nhận được nó để biên dịch một cách kỳ diệu), bạn không thực sự chắc chắn nếu bạn có một Fisherhoặc một AbstractConcreteMixer. Về cơ bản nó làm cho toàn bộ cách khó hiểu hơn.

Giải pháp cho vấn đề của bạn là một trong hai khả năng:

1. Xác định nhiều hơn một phương thức xác định từng chuyển đổi, hành vi hoặc bất cứ điều gì có thể. Đó là câu trả lời của Botz. Trong thế giới lập trình, điều này được gọi là Quá tải phương thức.

2. Xác định một lớp cơ sở hoặc giao diện biết cách thực hiện tất cả những thứ bạn cần cho phương thức và có một phương thức chỉ lấy kiểu đó. Điều này có thể liên quan đến việc gói một stringvà Exceptiontrong một lớp nhỏ để xác định cách bạn lên kế hoạch ánh xạ chúng đến việc thực hiện, nhưng sau đó mọi thứ đều rất rõ ràng và dễ đọc. Tôi có thể đến, bốn năm kể từ bây giờ và đọc mã của bạn và dễ dàng hiểu những gì đang xảy ra.

Việc bạn chọn tùy thuộc vào mức độ phức tạp của lựa chọn 1 và 2 và mức độ mở rộng của nó.

Vì vậy, đối với tình huống cụ thể của bạn, tôi sẽ tưởng tượng bạn chỉ cần rút ra một tin nhắn hoặc một cái gì đó từ ngoại lệ:

public interface IHasMessage
{
    string GetMessage();
}

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

Bây giờ tất cả những gì bạn cần là các phương thức biến đổi a stringvà Exceptionthành IHasMessage. Rất dễ.

Nếu ChildClass có nghĩa là nó có nguồn gốc từ ParentClass, bạn có thể chỉ cần viết như sau để chấp nhận cả ParentClass và ChildClass;

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

Mặt khác, nếu bạn muốn sử dụng hai loại khác nhau không có mối quan hệ thừa kế giữa chúng, bạn nên xem xét các loại thực hiện cùng một giao diện;

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;
    }
}

sau đó bạn có thể viết hàm chung của bạn như;

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

Vẫn như câu hỏi này, tôi vẫn nhận được những đánh giá ngẫu nhiên về lời giải thích của tôi ở trên. Lời giải thích vẫn hoàn toàn ổn, nhưng tôi sẽ trả lời lần thứ hai với một loại phục vụ tốt cho tôi thay thế cho các loại kết hợp (câu trả lời được đánh máy mạnh cho câu hỏi không được C # hỗ trợ trực tiếp ).

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");
            }
        }
    }
}

Lớp trên đại diện cho một loại có thể là TP hoặc TA. Bạn có thể sử dụng nó như vậy (các loại tham khảo câu trả lời ban đầu của tôi):

// ...
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());

Ghi chú quan trọng:

• Bạn sẽ gặp lỗi thời gian chạy nếu bạn không kiểm tra IsPrimary trước.
• Bạn có thể kiểm tra bất kỳ IsNeither IsPrimaryhoặcIsAlternate .
• Bạn có thể truy cập giá trị thông qua PrimaryvàAlternate
• Có các bộ chuyển đổi ngầm định giữa TP / TA và Either để cho phép bạn chuyển các giá trị hoặc Eitherbất kỳ nơi nào mà người ta mong đợi. Nếu bạn làm vượt qua một Eithernơi mà một TAhoặc TPdự kiến, nhưng Eitherchứa các loại sai của giá trị mà bạn sẽ nhận được một lỗi thời gian chạy.

Tôi thường sử dụng điều này trong đó tôi muốn một phương thức trả về kết quả hoặc lỗi. Nó thực sự làm sạch mã phong cách đó. Tôi cũng rất thỉnh thoảng ( hiếm khi ) sử dụng điều này như một sự thay thế cho quá tải phương thức. Thực tế đây là một sự thay thế rất kém cho sự quá tải như vậy.