Números de versión flotante, decimal o doble

Question

Tengo un sistema de gestión de documentos donde los documentos pueden tener múltiples versiones. Cada versión se guarda y los usuarios pueden ver el historial de versiones.

Lo que me gustaría saber es: ¿Qué tipo de datos debo usar para los números de versión? Decimal, Flotador o Doble? Estoy usando .NET y C#.

Los números de versión comienzan en 0,1 y cada publicados la versión importante será redondeado al siguiente número entero. es decir 0,4 va a 1,0 y 1,3 va a 2,0 etc.

Cuando un números de versión impacta 0,9 y un menor versión se añade Me gustaría que el número para ir a 0,10 no 1.0, cuando lo agrego. Este es el mayor problema.

Cualquier sugerencia es apreciada.

Gracias.

Answer 1

System.Version

Esto ya almacena las diferentes partes, trata de presentar como una cadena (revisión y construir componentes son solo se usan en la pantalla si no son cero, por lo que su irrelevancia para su caso no importa) y (lo mejor de todo) ya lo entienden otros desarrolladores de .NET, y no generará confusión (si vi algún uso) de un número de versión que no era un System.Version Pasé algún tiempo tratando de averiguar por qué Version no era lo suficientemente bueno para el trabajo, en caso de que demostrara ser importante y escondiera una desagradable sorpresa. Si fuera lo suficientemente bueno para el trabajo, me molestaría que el desarrollador perdiera mi tiempo así).

Puede tratar con los medios que desea para incrementar fácilmente con métodos de extensión:

public static Version IncrementMajor(this Version ver) 
{ 
    return new Version(ver.Major + 1, 0); 
} 
public static Version IncrementMinor(this Version ver) 
{ 
    return new Version(ver.Major, ver.Minor + 1); 
} 

Answer 2

¿Qué tal dos enteros? ¿Uno para revisiones mayores y uno para revisiones menores?

Answer 3

Sugeriría dos enteros: uno mayor y uno menor. Incluso puede almacenar esto como major * 1000 + minor si quiere una variable.

Answer 4

Decimal debe ser el mejor de los anteriores, pero como otros han notado dos ints sería mejor.

dobles y los flotadores no almacena con precisión todos los valores decimales, que no quiere que su versión sea pronto 1,219999999999999999

Answer 5

Haga su propio tipo de datos para este

public struct VersionNumber : IComparable<ReleaseNumber> 
{ 
    public int MajorVersion{get;set;} 
    public int MinorVersion{get;set;} 

    public VersionNumber(int major, int minor) 
    { 
    MajorVersion = major; 
    MinorVersion = minor; 
    } 

    public override string ToString(){ 
    return major + '.' + minor; 
    } 

    public int CompareTo(VersionNumber other) { 
    int result; 
    result = MajorVersion.CompareTo(other.MajorVersion); 
    if (result != 0) { return result; } 
    return MinorVersion.CompareTo(other.MinorVersion); 
    } 
    public static bool operator <(VersionNumber left, VersionNumber right) { 
    return left.CompareTo(right) < 0; 
    } 
    public static bool operator <=(VersionNumber left, VersionNumber right) { 
    return left.CompareTo(right) <= 0; 
    } 
    public static bool operator >(VersionNumber left, VersionNumber right) { 
    return left.CompareTo(right) > 0; 
    } 
    public static bool operator >=(VersionNumber left, VersionNumber right) { 
    return left.CompareTo(right) >= 0; 
    } 
} 

También puede agregar un comparador para que pueda verificar dos números de versión para ver cuál es la versión más alta de dos números de versión, por ejemplo.

EDITAR

añadido la lógica comparador también por si acaso :)