Una forma de escribir grandes literales en C #

Tengo un método como este:

Prefix GetPrefix(decimal value) { if(value > 11000000000000000000) return Prefix.CosmicBig; if(value > 1000000000000000) return Prefix.ReallyBig; if(value > 3000000000000) return Prefix.Big; if(value > 50000000) return Prefix.Okay; if(value > 750000) return Prefix.MostlyNormal; if(value > 750000) return Prefix.SoSo; if(value > 750) return Prefix.Small; return Prefix.MiserablySmall; } 

Los valores exactos no son importantes. Lo que importa es que a veces se cambian (los prefijos se usan para dibujar y algunas áreas de texto cambian de tamaño en el desarrollo). Estoy buscando una forma de escribir estos literales de una manera que sea fácil de leer para un humano que la cambie, sin tener que contar todos los ceros. Un separador estaría bien. Pensé en escribir 11 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 , pero eso es apenas más manejable. Usar Math.Pow() hace un poco mejor, pero no me siento cómodo usando estos cálculos para definir constantes.

Puede introducir métodos de extensión para int :

 750.Thousand(); 5.Million(); 100.Billion(); 

La implementación de estos métodos es simple:

 public static int Thousand(this int value) { return value * 1000; } public static int Million(this int value) { return value.Thousand() * 1000; } // etc. 

Asegúrese de devolver el tipo de datos apropiado para los métodos para números más grandes:

 public static long Billion(this int value) { return value.Million() * 1000; } 

Desafortunadamente, tendrá que escribir esos métodos para cada tipo de punto flotante o integral que quiera admitir.

Tener un conjunto completo de tales métodos de extensión le permitiría express sus números grandes de manera relativamente natural, incluso cuando no es solo todos los ceros al final:

 100.Billion() + 30.Thousand() + 300 // == 100,000,030,300 

Si desea obtener fantasía, incluso podría pensar en anidarlos:

 100.Billion(30.Thousand(300)) 

Pero creo que perdería algo de expresividad, porque la gente se preguntaría qué significa el parámetro.

Aún así, la implementación se vería así:

 public static long Billion(this int value, long add) { return value.Million() * 1000 + add; } 

El uso de estos métodos de extensión tiene un pequeño inconveniente: sus números ya no son constantes de tiempo de comstackción. Se calculan en tiempo de ejecución. En la gran mayoría de los casos, esto no debería ser un problema.

En lugar de 11000000000000000000 puede usar 11e18 . Usa m para indicar que es un decimal, entonces 11e18m .