具有兩種可能類型的通用屬性

Question

我正在嘗試創建一個公共屬性，該屬性可以是long或Guid。泛型有可能嗎？例如像

public virtual T where T: long or Gui Id { get; set; } 

Answer 1

是否有可能與仿製藥？

這是不可能的，但你可以通過使用implicit operator同時支持long和Guid，示例代碼解決：

internal class YourId 
{ 
    public long LongId { get; private set; } 
    public Guid GuidId { get; private set; } 

    public YourId(long longValue) 
    { 
     LongId = longValue; 
    } 

    public YourId(Guid guidValue) 
    { 
     GuidId = guidValue; 
    } 

    public static implicit operator long(YourId yourId) 
    { 
     return yourId.LongId; 
    } 

    public static implicit operator YourId(long value) 
    { 
     return new YourId(value); 
    } 

     public static implicit operator Guid(YourId yourId) 
    { 
     return yourId.GuidId; 
    } 

    public static implicit operator YourId(Guid value) 
    { 
     return new YourId(value); 
    } 
} 

現在你可以使用：

YourId id1 = Guid.NewGuid(); 
YourId id2 = long.MaxValue; 

Answer 2

不，這是不可能的。如果你只有兩種可能的類型，那麼只需要寫兩次類，把儘可能多的通用代碼放在一個通用的基類中？

Answer 3

不，這是不可能的。沒有這樣的限制。這是list of possible constraints。

Answer 4

不，這是不可能的，你必須選擇一個相同的父類，或者你應該編寫你自己的可以存儲兩者的類的實現。

喜歡的東西：

class LongOrGuid 
{ 
    private Guid _guid; 
    private long _long; 
    private bool _isGuid = true; 

    public LongOrGuid(Guid g) 
    { 
      _guid = g; 
      _isGuid = true; 
    } 

    public LongOrGuid(long l) 
    { 
      _long = l; 
      _isGuid = false; 
    } 

    public long Long 
    { 
      get 
      { 
       if(_isGuid) 
       { 
        throw new NotSupportedException("This is a guid"); 
       } 
       return _long; 
      } 
    } 

    public Guid Guid 
    { 
      get 
      { 
       if(!_isGuid) 
       { 
        throw new NotSupportedException("This is a long"); 
       } 
       return _guid; 
      } 
    } 

    public bool IsGuid 
    { 
      get 
      { 
       return _isGuid; 
      } 
    } 
} 

Answer 5

一財產不能像那樣通用。也許你可以使該類包含通用屬性？

您不能限制爲long或Guid。你可以說：

class ClassContainingYourProperty<T> where T : struct, IFormattable, IComparable<T>, IEquatable<T> 
{ 
    static ClassContainingYourProperty() // do type check in static constructor 
    { 
    var t = typeof(T); 
    if (t != typeof(long) && t != typeof(Guid)) 
     throw new NotSupportedException("T cannot be " + t); 
    } 

    public virtual T YourProperty { get; set; } 
}