C# Genéricos: cómo usar x.MaxValue/x.MinValue (int, float, double) en una clase genérica

Question

Estoy usando el WPF Extended Toolkit (http://wpftoolkit.codeplex.com/).

Tiene un buen control NumericUpDown que me gustaría usar, pero internamente usa dobles, lo que significa que usa double.MinValue y double.MaxValue.

Me gustaría usar el mismo control, pero necesito una versión genérica - para las entradas que necesita usar int.MaxValue/MinValue, para flotantes float.MaxValue/MinValue, etc. (Creo que se entiende la idea :))

Así que pensé en copiar el NumericUpDown a un GNumericUpDown, donde T por supuesto sería el Tipo ... Pero esto no funciona, porque un Tipo genérico no tiene MinValue/MaxValue. Y normalmente usaría la cláusula 'where' para especificar un tipo base, pero esto no funciona como afaik, no existe una interfaz común que defina 'MinValue' y 'MaxValue'.

¿Hay una manera de resolver esto con los genéricos, o lo que realmente necesita para copiar/pegar/& búsqueda reemplazan el NumericUpDown original para cada tipo?

Answer 1

El PO hizo este comentario en otra respuesta:

quiero utilizar estos controles en mi XAML. Mi idea era crear una versión genérica , y luego crear clases vacías como NumericUpDownInt: GNumericUpDown {} ¿Sería el camino a seguir, o hay una manera mejor/más limpio a su conocimiento

Si vas a ir por ese camino, a continuación, sólo tiene que pasar el mínimo y el máximo directa:

class abstract GenericNumericUpDown<T> 
{ 
    public GenericNumericUpDown(T min, T max) { ... } 
} 

class NumericUpDownInt : GenericNumericUpDown<int> 
{ 
    public NumericUpDownInt() : base(int.MinValue, int.MaxValue) { ... } 
} 

class NumericUpDownFloat : GenericNumericUpDown<float> 
{ 
    public NumericUpDownFloat() : base(float.MinValue, float.MaxValue) { ... } 
} 

class NumericUpDownDouble : GenericNumericUpDown<double> 
{ 
    public NumericUpDownDouble() : base(double.MinValue, double.MaxValue) { ... } 
} 

Answer 2

Bueno, considerando que se puede conseguir en el tipo en tiempo de ejecución, que podría confiar en el hecho de que todos los tipos numéricos en .NET tienen MinValue y MaxValue campos, y leerlos con la reflexión. No sería terriblemente agradable, pero es bastante fácil de hacer:

using System; 
using System.Reflection; 

// Use constraints which at least make it *slightly* hard to use 
// with the wrong types... 
public class NumericUpDown<T> where T : struct, 
    IComparable<T>, IEquatable<T>, IConvertible 
{ 
    public static readonly T MaxValue = ReadStaticField("MaxValue"); 
    public static readonly T MinValue = ReadStaticField("MinValue"); 

    private static T ReadStaticField(string name) 
    { 
     FieldInfo field = typeof(T).GetField(name, 
      BindingFlags.Public | BindingFlags.Static); 
     if (field == null) 
     { 
      // There's no TypeArgumentException, unfortunately. You might want 
      // to create one :) 
      throw new InvalidOperationException 
       ("Invalid type argument for NumericUpDown<T>: " + 
       typeof(T).Name); 
     } 
     return (T) field.GetValue(null); 
    } 
} 

class Test 
{ 
    static void Main() 
    { 
     Console.WriteLine(NumericUpDown<int>.MaxValue); 
     Console.WriteLine(NumericUpDown<float>.MinValue); 
    } 
} 

Tenga en cuenta que si se utiliza esta otra de un tipo inadecuado, he tratado de forzar un error en tiempo de compilación lo mejor que pueda ... pero no será infalible. Si logra encontrar una estructura con todas las interfaces correctas, pero sin los campos MinValue y MaxValue, cualquier intento de utilizar el NumericUpDown con ese tipo provocará una excepción.

Answer 3

debe obtener el código fuente más reciente para el Kit de herramientas de WPF extendido. El control actualizado NumericUpDown le permite especificar qué tipo de datos usar en el editor. El siguiente código especifica el uso de un Int32 como tipo de datos en lugar del doble predeterminado. Como puede ver, esto se hace estableciendo la propiedad ValueType en el control NumericUpDown.

<extToolkit:NumericUpDown Grid.Row="1" Value="{Binding Age}" Increment="1" Minimum="18" Maximum="65" ValueType="{x:Type sys:Int32}" /> 

Answer 4

ya que esto es también útil en escenarios de prueba:

Es posible utilizar métodos de extensión, de manera que en C# 6 (introducción nameof) se podría escribir:

public static class TypeExtension 
{ 
    public static T MinValue<T>(this Type self) 
    { 
     return (T)self.GetField(nameof(MinValue)).GetRawConstantValue(); 
    } 

    public static T MaxValue<T>(this Type self) 
    { 
     return (T)self.GetField(nameof(MaxValue)).GetRawConstantValue(); 
    } 

} 

e invocar a través cierta sintaxis fea:

var intMinValue = typeof(int).MinValue<int>(); 

que en su método genérico wo ULD ser

var typeMinValue = typeof(T).MinValue<T>(); 

Nota, que no estoy seguro de que todos los tipos primitivos declaran sus valores Min/Max como constantes. Use GetValue en su lugar.