blocks|key|139927|text|就我个人而言，我只会使用if语句，因为我觉得这是最明确的意图：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|139928|decimal+amount+=+500m;
bool+negate+=+true;

//+...

if+(negate)
++++amount+*=+-1;|code-block|syntax|javascript|139929|这真的不是任何额外的输入(它实际上更短！)，在我看来更清楚。|139930|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Personally, I would just use an if statement, since I feel that it's the most clear in terms of intent:

<pre><code>decimal amount = 500m;
bool negate = true;

// ...

if (negate)
 amount *= -1;
</code></pre>

This is really not any extra typing (it's actually shorter!), and more clear in my opinion.

blocks|key|1815887|text|public+static+decimal+Negate(this+decimal+value,+bool+isNegate){
++++if(isNegate)+return+value+*+-1;
++++return+value;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1815888|在decimal上生成扩展方法。易于使用。|unstyled|1815889|像amount.Negate(negate)一样调用|offset|length|style|CODE|1815890|entityMap^0|0|0|1|L|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>public static decimal Negate(this decimal value, bool isNegate){
 if(isNegate) return value * -1;
 return value;
}
</code></pre>

Make extension method on decimal. Easy to use.

call like <code>amount.Negate(negate)</code>

blocks|key|3430597|text|如果您的negate标志基于某个数值，那么您可以使用Math.Sign，这是我能想到的最“数学”的方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3430598|double+negationValue+=+-45.0;
amount+*=+Math.Sign(negationValue);|code-block|syntax|javascript|3430599|或者在布尔型情况下(不是很优雅)：|3430600|amount+*=+Math.Sign(0.5+-+Convert.ToByte(negate));|3430601|entityMap^0|4|6|Q|9|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

If your <code>negate</code> flag is based on some numeric value you can use <code>Math.Sign</code>, that's the most "mathematical" way I can think of.

<pre><code>double negationValue = -45.0;
amount *= Math.Sign(negationValue);
</code></pre>

or in boolean case just (not really elegant):

<pre><code>amount *= Math.Sign(0.5 - Convert.ToByte(negate));
</code></pre>

blocks|key|1815943|text|amount+*=+Math.Pow(-1,+Convert.ToInt32(negate))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1815944|这是基于这样的假设:在C#中对布尔值进行类型转换将在false上产生0，而在true上产生1。然而，我不认为这是优雅的，因为它是一种混淆。|unstyled|1815945|编辑:转换为整型|1815946|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>amount *= Math.Pow(-1, Convert.ToInt32(negate))
</code></pre>

This is under the assumption that typecasting a boolean in C# will yield a 0 on false, and a 1 for true. I however don't think this is elegant as it is an obfuscation.

edit: converted to an int

blocks|key|3430660|text|使用十进制一元求反运算符(就像你已经在做的那样)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3430661|using+System;

class+Program
{
++++static+void+Main()
++++{
++++++++bool+negate+=+true;
++++++++decimal+test+=+500M;
++++++++Console.WriteLine(negate+==+true+?+-test+:+test);
++++}
}|code-block|syntax|javascript|3430662|输出：|3430663|-500|3430664|坦率地说，这比以那种奇怪的方式乘以-1要清楚得多，也好得多。|3430665|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Use the decimal unary negation operator (as you are sort of already doing):

<pre><code>using System;

class Program
{
 static void Main()
 {
 bool negate = true;
 decimal test = 500M;
 Console.WriteLine(negate == true ? -test : test);
 }
}
</code></pre>

Output:

<pre><code>-500
</code></pre>

Frankly, this is much clearer and better than multiplying by -1 in that strange way.

blocks|key|3430709|text|又一次穿越数学奇才的机会？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3430710|如何调整现有的解决方案，使其更具可读性，但仍然使用语句?true:false快捷方式？|3430711|您的解决方案是：|3430712|amount+*=+(negate+?+-1+:+1);|code-block|syntax|javascript|3430713|也许将其重构为|3430714|amount+=+(negate+?+amount*-1+:+amount);|3430715|为了给你的代码增加更多的可读性，你可以创建一个可重用的类来为你处理这些事情：|3430716|public+static+class+MathHelpers()
{
++//+Negates+the+result+if+shouldNegate+is+true,+otherwise+returns+the+same+result
++public+static+decimal+Negate(decimal+value,+bool+shouldNegate)
++{
++++//+In+this+black-box+solution+you+can+use+"fancier"+shortcuts
++++return+value+*=+negate+?+-1+:+1;
++}
}|3430717|在您的其他代码中，您现在可以使用一个可读性非常好的函数...|3430718|decimal+amount+=+500m;
bool+negate+=+true;
amount+=+MathHelper.Negate(amount,+negate);|3430719|总而言之，尽管我同意优雅和可读性存在于同一辆车中，而不是不同的车：|3430720|if+(condition)
++output+*=+-1;|3430721|的可读性比|3430722|value+*=+condition+?+-1+:+1;|3430723|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|19|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1B|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|H|7|1F|8|@]|9|@]|A|$I|J]]|$1|W|3|X|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|H|7|1H|8|@]|9|@]|A|$I|J]]|$1|10|3|11|5|6|7|1I|8|@]|9|@]|A|$]]|$1|12|3|13|5|H|7|1J|8|@]|9|@]|A|$I|J]]|$1|14|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|15|$]]

Another shot across the math wizards?

How about adjusting your existing solution to be slightly more readable, but still make use of the statement?true:false shortcut?

Your solution was:

<pre><code>amount *= (negate ? -1 : 1);
</code></pre>

Maybe refactor that to

<pre><code>amount = (negate ? amount*-1 : amount);
</code></pre>

To add even more readability to your code, you might make a reusable class that handles that kind of stuff for you:

<pre><code>public static class MathHelpers()
{
 // Negates the result if shouldNegate is true, otherwise returns the same result
 public static decimal Negate(decimal value, bool shouldNegate)
 {
 // In this black-box solution you can use "fancier" shortcuts
 return value *= negate ? -1 : 1;
 }
}
</code></pre>

And in your other code, you now have a very readable function to use...

<pre><code>decimal amount = 500m;
bool negate = true;
amount = MathHelper.Negate(amount, negate);
</code></pre>

All in all, though I agree that elegance and readability live in the same cart, not different ones:

<pre><code>if (condition)
 output *= -1;
</code></pre>

is more readable than 

<pre><code>value *= condition ? -1 : 1;
</code></pre>

blocks|key|3430746|text|这已经存在了，因为Framework+1.1：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3430747|System.Decimal.Negate方法|3430748|public+static+decimal+Negate(+++++decimal+d+)|offset|length|3430749|示例用法：|3430750|decimal+amount+=+500m;
bool+negate+=+true;

if(negate)
++++amount+=+decimal.Negate(amount);
//+amount+now+holds+-500
//+Use+amount|code-block|syntax|javascript|3430751|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.decimal.negate%2528v=vs.110%2529.aspx^0|0|0|0|19|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$F|Z|G|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

This already exists, since Framework 1.1:

System.Decimal.Negate method

<a href="http://msdn.microsoft.com/en-us/library/system.decimal.negate%28v=vs.110%29.aspx" rel="nofollow">public static decimal Negate(
 decimal d
)</a>

Sample Usage:

<pre><code>decimal amount = 500m;
bool negate = true;

if(negate)
 amount = decimal.Negate(amount);
// amount now holds -500
// Use amount
</code></pre>

I have a decimal variable that I would like to negate if a boolean variable is true. Can anyone think of a more elegant way to do it than this:

<pre><code>decimal amount = 500m;
bool negate = true;

amount *= (negate ? -1 : 1);
</code></pre>

I'm thinking something along the lines of bitwise operators or a strictly mathematical implementation.

Elegant way to negate a numeric value based on a boolean value

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个十进制变量，如果布尔变量为真，我想将其求反。有没有人能想到比这更优雅的方式呢：decimal amount = 500m;bool negate = true;amount *= (negate ? -1 : 1);我在考虑一些类似于按位运算符或严格数学实现的东西。

问根据布尔值对数值求反的一种优雅方法
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问根据布尔值对数值求反的一种优雅方法EN