Números de versión flotantes, decimales o dobles

Tengo un sistema de administració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 numbers de versión? Decimal, Flotador o Doble? Estoy usando .NET y C #.

Los numbers de versión comienzan en 0.1 y cada versión principal publicada se networkingondeará al siguiente número integer. es decir, 0.4 va a 1.0 y 1.3 va a 2.0, etc.

Cuando un número de versión llega a 0.9 y se agrega una versión menor, me gustaría que el número vaya a 0.10, no a 1.0 , cuando lo agregue. Este es el mayor problema.

Cualquier sugerencia es apreciada

Gracias.

System.Version

Esto ya almacena las diferentes partes, trata de presentarlo como una cadena (los componentes de revisión y compilation 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 es entendido por otros desarrolladores de .NET, y no dará lugar a confusión (si vi algún uso de un número de versión que no fuera un System.Version , pasaría un time tratando de averiguar por qué Version no era lo suficientemente bueno para el trabajo, en caso de que demostrara ser importante y ocultara una desagradable sorpresa. Si fuera lo suficientemente bueno para el trabajo, me molestaría que el desarrollador perdiera mi time así).

Puede tratar con los medios que desea para incrementarse fácilmente con los methods 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); } 

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

Crea tu propio tipo de datos para esto

 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 numbers de versión para ver cuál es la versión más alta de dos numbers de versión, por ejemplo.

EDITAR

Se agregó la lógica del comparador también como buena medida 🙂

Sugeriría dos integers: un mayor y un menor. Incluso puede almacenar esto como major * 1000 + minor si desea una variable.

El decimal debe ser el mejor de los anteriores, pero como otros han notado, dos integers serían mejores.

Dobles y flotantes no almacenan con precisión todos los valores decimales, no desea que su versión sea de repente 1.219999999999999999