Include generic constraints joined by OR

[marioilitio]

Consider the following example:

public class NumericAttribute(Type editorType) : Attribute 
{
    Type _editorType = editorType;
    public object CreateEditor() => Activator.CreateInstance(_editorType);
    public object MinValue { get; set; }
    public object MaxValue { get; set; }
}

The following is ok to compiler but it is wrong

[Numeric(typeof(CheckBox), MinValue=2.5, MaxValue="Hello")]
public int Months { get; set; } 

Consider the possibility of using generics constraints with "or", like this:

public class NumericAttribute<T, TEditor> : Attribute 
    where T : double or int or DateTime
    where TEditor : IRangeEditor<T>, new()
{
    public TEditor CreateEditor() => new TEditor();
    public T MinValue { get; set; }
    public T MaxValue { get; set; }
}

public class NumericBox<T> : Control, IRangeEditor<T> where T : double or int { ... }
public class DateBox       : Control, IRangeEditor<DateTime> { ... }

Now the compiler can make some type-checks for us:

[Numeric<NumericBox, int>(MinValue=0, MaxValue=100)] // ok

[Numeric<DateBox, int>(MinValue=0, MaxValue=100)]    // wrong DateBox does not allow int for generic parameter T when trying to match IRangeEditor<int> on constrains DateBox: IRangeEditor<int>

[HaloFour]

Something like this would be much more easily managed by an analyzer that can determine if the attribute is applied correctly to the target field or property.

[huoyaoyuan]

Generic constraints are for enabling additional operations. and type are commonly used in constraints because the enabled operations are aggregated by each constraint.

[En3Tho]

I think NumericBox can be constrained by INumber<T>. It's a broad constraint that obviously includes more than just int and double but it seems like a good candidate

[bbarry]

Is not double or int just a way to specify a desired interface in an ad hoc manner?

[huoyaoyuan]

Whether AdHoc unions can work with generic is unclear now.