web-dev-qa-db-fra.com

Opérations décimales et mathématiques

J'ai une conversion simple d'un decimal en C #. Cela ressemble à ceci:

private decimal BaseValue
{
    get; set;
}

public decimal ConvertedValue 
{
    get
    {
        return BaseValue * (365 / 360);
    }
}

Cependant, cela ne fonctionne pas. Je suppose que C # traite les nombres de la fraction sous forme d’entiers. Je peux donc faire comme ceci à la place (ce qui fonctionne):

public decimal ConvertedValue 
{
    get
    {
        return BaseValue * (decimal)((double)365 / (double)360);
    }
}

Maintenant, cela semble un peu exagéré, mais je peux vivre avec ça. Ma question principale est la suivante:

Pourquoi Visual Studio m'avertit-il que 'la distribution est redondante' pour la distribution (double)? Et si je supprime la distribution (double), la distribution (decimal) devient redondante. Et si je supprime cela, je suis de retour à la solution, qui ne fonctionne pas. Aidez-moi...?

c#castingdecimaloperands
18
Noceo

La distribution decimal est redondante, car le compilateur sait que vous voulez renvoyer une decimal.

Un des deux conversions double est redondant, car lorsque vous convertissez l'une des ints en double, il est clair que vous utilisez l'opérateur de division double au lieu de division entière.

Mais il devrait suffire d’utiliser le suffixe littéral decimalm: 

return BaseValue * (365m / 360);

Encore une fois, une m est suffisante pour déduire l'opérateur correct.

Mais hé, BaseValue est déjà decimal et la parenthèse n’a pas de sens (si vous ne voulez pas une division entière) ... cela devrait fonctionner aussi:

return BaseValue * 365 / 360;
8
René Vogt

Il existe des suffixes pour certains types de nombres, par exemple:

 // Use long suffix.
 long l1 = 10000L;

 // Use double suffix.
 double d1 = 123.764D;

 // Use float suffix.
 float f1 = 100.50F;

 // Use unsigned suffix.
 uint u1 = 1000U;

 // Use decimal suffix.
 decimal m2 = 4000.1234M;

 // Use unsigned suffix and long suffix.
 ulong u2 = 10002000300040005000UL;

Les suffixes spécifient les types de nombre. Ils indiquent au compilateur C # qu’un littéral intégral tel que 1000 est considéré comme un certain type de nombre, par exemple un long (1000L). Nous examinons comment vous pouvez ajouter des suffixes numériques aux nombres. 

Dans ton cas:

public decimal ConvertedValue 
{
    get
    {
        return BaseValue * (365 / 360M);
    }
}

Et aussi sa plus claire lorsque vous utilisez un suffixe majuscule:

Suffixes minuscules. Vous pouvez également spécifier des suffixes minuscules, tels que u, l, ul, f, d et m. Mais il est plus facile de les confondre avec les chiffres. La lettre 'l' est parfois considérée comme le chiffre 1. 

4
SeM

vous pouvez simplement ajouter un suffixe m à l'un des nombres pour le rendre décimal:

return BaseValue * (365 / 360m);
4
sofsntp

utilisez le suffixe m:

return 365m/360 * BaseValue;
4
Zumoka

Dans votre exemple, vous pouvez simplement laisser les crochets:

return BaseValue*365/360;
2
Damien Flury

Vous n'avez besoin que de l'un des doubles lancers. Alors 

return BaseValue * (decimal)(365/(double)360);

fonctionnera bien.

Une fois que l'on est un double, le compilateur sait le traiter comme une division non entière.

Alternativement 

return (BaseValue*365)/360;

marchera.

ou même 

return BaseValue*365/360;

puisque la multiplication est de priorité supérieure à la division.

2
Yair Halberstadt

Vous pouvez simplement utiliser littéraux décimaux , en utilisant le suffixem:

public decimal ConvertedValue 
{
    get
    {
        return BaseValue * (365m/360);
    }
}

La seconde distribution est redondante, car C # en déduit que le premier nombre (365) de votre expression ((double)365 / (double)360) est une double. Donc, afin de calculer la division, il convertira implicitement le deuxième élément en un double également. Donc, peu importe si vous écrivez (double) en tant que deuxième élément:

csharp> (double) 365/350        
1.04285714285714                
csharp> (double) 365/ (double) 350
1.04285714285714

Néanmoins, il est tout à fait inutile de lancer les doublages puis les décimales. En utilisant un littéral décimal dans votre expression, l'autre nombre sera également un nombre décimal. Nous restons donc dans le monde decimal.

2
Willem Van Onsem

Un double divisé par un double est (bien sûr) un double. Donc, le résultat est redondant.

Il serait plus court si vous spécifiez simplement les nombres en décimales:

 return BaseValue * (365m /360);
0
Amy

L'un des (doubles) transts est redondant, mais pas les deux . Si l'un des arguments d'une opération est double, l'autre argument est automatiquement converti en double . Pouvez-vous écrire l'un des arguments sous forme de nombre réel constante, par exemple, 365,0?

0
Gem Taylor