Réglage de la précision décimale, .net

Question

Ces lignes en C #

 decimal a = 2m;
decimal b = 2.0m;
decimal c = 2.00000000m;
decimal d = 2.000000000000000000000000000m;

Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(c);
Console.WriteLine(d);
 

Génère cette sortie:

 2
2.0
2.00000000
2.000000000000000000000000000
 

Je peux donc voir que la création d'une variable décimale à partir d'un littéral me permet de contrôler la précision.

• Puis-je ajuster la précision des variables décimales sans utiliser de littéraux?
• Comment créer b de a? Comment puis-je créer b à partir de c?

Answer 1

La préservation des zéros à la fin, comme cela a été introduit dans .NET 1.1 pour plus stricte conformité avec la spécification ECMA CLI.

Il y a quelques infos sur ce sur MSDN, par exemple ici.

Vous pouvez régler la précision comme suit:

• Les mathématiques.Tour (ou Plafond, Plancher, etc) pour diminuer la précision (b c)

• Multiplier par 1.000... (avec le nombre de décimales que vous souhaitez) pour augmenter la précision - par exemple, multiplier par 1,0 M pour obtenir b à partir d'un.

Answer 2

Vous êtes juste de voir des représentations différentes des mêmes données. La précision d'un decimal sera réduit à être aussi grand qu'il doit être (dans la raison).

D' System.Decimal:

Un nombre décimal est une virgule flottante valeur qui se compose d'un signe, d'un valeur numérique où chaque chiffre dans le la valeur varie de 0 à 9, et un facteur d'échelle qui indique la la position de la virgule flottante qui sépare l'intégrale et fractions de la valeur numérique.

La représentation binaire d'un nombre Décimal la valeur se compose d'un 1 bit de signe, un 96 bits nombre entier, et une mise à l'échelle le facteur utilisé pour diviser les 96 bits entier et de spécifier quelle partie de est une fraction décimale. La mise à l'échelle le facteur est implicitement le nombre 10, porté à un exposant compris entre 0 28. Par conséquent, le binaire représentation d'une valeur Décimale est de la forme, ((-2⁹⁶ à 2⁹⁶) / 10^{(0 à 28)}), où -2⁹⁶-1 est égal à MinValue et 2⁹⁶-1 est égal à MaxValue.

Le facteur d'échelle est également de préserver tout des zéros à la fin dans un nombre Décimal. Les zéros de fin n'affectent pas la la valeur d'un nombre Décimal en l'arithmétique ou les opérations de comparaison. Cependant, les zéros de fin peut être révélé par la méthode ToString si un approprié chaîne de format est appliqué.

Answer 3

Qu'en est-il de Math.Round (décimal d, int décimales) ?

Answer 4

J'ai découvert que je pouvais "altérer" l'échelle en la multipliant ou en la divisant par un 1 fantaisie.

 decimal a = 2m;
decimal c = 2.00000000m;
decimal PreciseOne = 1.000000000000000000000000000000m;
  //add maximum trailing zeros to a
decimal x = a * PreciseOne;
  //remove all trailing zeros from c
decimal y = c / PreciseOne;
 

Je peux fabriquer un 1 suffisamment précis pour modifier les facteurs d'échelle en fonction des tailles connues.

 decimal scaleFactorBase = 1.0m;
decimal scaleFactor = 1m;
int scaleFactorSize = 3;

for (int i = 0; i < scaleFactorSize; i++)
{
  scaleFactor *= scaleFactorBase;
}

decimal z = a * scaleFactor;
 

Answer 5

Il est tentant de confondre decimal dans SQL Server avec decimal dans .NET; ils sont tout à fait différents.

Un Serveur SQL decimal est un point fixe nombre dont la précision et l'échelle sont fixées lors de la colonne ou de la variable est définie.

Un .NET decimal est un nombre à virgule flottante comme float et double (la différence étant que, decimal précisément conserve chiffres après la virgule alors qu' float et double précisément de préserver les chiffres binaires). En essayant de contrôler la précision d'un .NET decimal est inutile, puisque tous les calculs doivent produire les mêmes résultats, indépendamment de la présence ou de l'absence de remplissage de zéros.