C# Can'；我不知道如何用下面的方法计算非复利税和混合税？

下面的类只有一个方法返回某个百分比的除数，因此如果我将其传递5，它将返回0.05

public class Adjustment
{
    public decimal Amount {get;set;}
    public bool IsCompounded {get;set;}
    public bool Add{get;set;}

    public decimal Calculate(decimal amount)
    {
        return (amount / 100.0M);
    }
 }

我的主要方法定义如下：

void Main()
{

    Adjustment a1 = new Adjustment {Amount = 10.0M, IsCompounded = false, Add = true};
    Adjustment a2 = new Adjustment {Amount = 7.0M, IsCompounded = false, Add = true};


    List<Adjustment> adjustments = new List<Adjustment>();
    adjustments.Add(a1);
    adjustments.Add(a2);

    decimal value = 0.0M;
    decimal total = 100.0M;

    foreach(Adjustment a in adjustments)
    {
        if(a.IsCompounded)
        {
            value = (1 + a.Calculate(a.Amount));

            if(a.Add)
                 total *= value;
            else
                total /= value;
        }
        else if(!a.IsCompounded)
        {
             value += a.Calculate(a.Amount);

             if(a.Add)
                 total *= value;
         else
                 total /= value;
        }
    }

    Console.WriteLine(total);
}

void Main（）
{
调整a1=新调整{Amount=10.0M，IsCompounded=false，Add=true}；
调整a2=新调整{Amount=7.0M，IsCompounded=false，Add=true}；
列表调整=新列表（）；
增加（a1）；
增加（a2）；
十进制值=0.0M；
小数总数=100.0M；
foreach（调整中的调整a）
{
如果（a.是复合的）
{
值=（1+a.计算（a.金额））；
如果（a.Add）
总*=价值；
其他的
总/=价值；
}
如果（！a.IsCompounded），则为else
{
值+=a.计算（a.金额）；
如果（a.Add）
总*=价值；
其他的
总/=价值；
}
}
控制台写入线（总计）；
}

在上面的主要方法中，我以100作为总数开始，如果所有的税都是复合的，那么效果很好，我得到117.7，如果我得到117.7，去掉税，我得到100。对于非复合型，我只需要在最后加1，然后除以总数，但我不知道怎么做。目前，当我循环时，我只是添加除数，例如0.1+0.07=0.17。在循环之外，我需要加上1，得到1.17，然后乘以或除以总数，分别增加或减少税收。然后是复合调整和非复合调整的问题，这变得更加复杂。在这种情况下，我需要执行以下操作：

例如，假设我有3种税，10、7和3。10和7是复合的，3是非复合的，因此公式为：

100*（1+（（1+0.10）*（1+0.07）−1)+((1+0.03)−1） ）简化为100*（（1+0.10）*（（1+0.07）+0.03）=120.70

---

我不知道如何实现上述要求。

如果我正确理解您的要求，我认为您只需要在反复调整时保留单独的复合和非复合分数，并在最后将其合并

decimal total = 100.0M;

decimal compounded = 1.0M;
decimal nonCompounded = 0.0M;
foreach(Adjustment a in adjustments)
{
    if(a.IsCompounded)
    {
        decimal value = (1.0m + a.Calculate(a.Amount));

        if (a.Add)
            compounded *= value;
        else
            compounded /= value;
    }
    else
    {
        decimal value = a.Calculate(a.Amount);

        if (a.Add)
            nonCompounded += value;
        else
            nonCompounded -= value;
    }
}

if (nonCompounded >= 0)
{
  total *= (compounded + nonCompounded);
}
else
{
  total *= (compounded / (1.0m - nonCompounded));
}

您是否只将

a.Amount

传递到

a.Calculate

？然后您可以从对象读取金额，例如

public decimal Calculate()
{
    return (Amount / 100.0M);
}

或者你可以把它变成一个属性get，例如

public decimal AmountFraction
{
    get
    {
        return (Amount / 100.0M);
    }
}

然后将其读取为

decimalvalue=a.AmountFraction；

，即作为属性而不是函数调用

---

编辑：根据注释修改组合行以删除非复合分数。

如果我正确理解您的要求，我认为您只需在反复调整时保留单独的复合分数和非复合分数，并在最后将其组合即可

decimal total = 100.0M;

decimal compounded = 1.0M;
decimal nonCompounded = 0.0M;
foreach(Adjustment a in adjustments)
{
    if(a.IsCompounded)
    {
        decimal value = (1.0m + a.Calculate(a.Amount));

        if (a.Add)
            compounded *= value;
        else
            compounded /= value;
    }
    else
    {
        decimal value = a.Calculate(a.Amount);

        if (a.Add)
            nonCompounded += value;
        else
            nonCompounded -= value;
    }
}

if (nonCompounded >= 0)
{
  total *= (compounded + nonCompounded);
}
else
{
  total *= (compounded / (1.0m - nonCompounded));
}

您是否只将

a.Amount

传递到

a.Calculate

？然后您可以从对象读取金额，例如

public decimal Calculate()
{
    return (Amount / 100.0M);
}

或者你可以把它变成一个属性get，例如

public decimal AmountFraction
{
    get
    {
        return (Amount / 100.0M);
    }
}

然后将其读取为

decimalvalue=a.AmountFraction；

，即作为属性而不是函数调用

编辑：根据注释修改组合行以删除非复合分数。

尝试以下操作：

public class Adjustment
{
    public decimal Amount {get;set;}
    public bool IsCompounded {get;set;}
    public bool Add{get;set;}

    public decimal Calculate()
    {
        if(IsCompounded)
            return 1 + Amount / 100.0M;
        else
            return Amount / 100.0M;
    }
 }

void Main()
{
    List<Adjustment> adjustments = new List<Adjustment>();
    adjustments.Add(new Adjustment() {Amount = 10.0M, IsCompounded = false, Add = true});
    adjustments.Add(new Adjustment() {Amount = 7.0M, IsCompounded = false, Add = true};);

    decimal value = 0.0M;
    decimal total = 100.0M;

    foreach(Adjustment a in adjustments)
    {
        value = a.Calculate();

        if(a.IsCompound)
        {
            if(a.Add)
                 total *= value;
             else
                 total /= value;
        }
        else
        {
            if(a.Add)
                 total += value; //should be a sum for nom-compounded
             else
                 total -= value;
        }
    }

    Console.WriteLine(total);
}

公共类调整
{
公共十进制数{get；set；}
公共布尔是复合的{get；set；}
公共bool Add{get；set；}
公共十进制计算（）
{
如果（是复合的）
返回1+金额/100.0M；
其他的
返还金额/100.0M；
}
}
void Main（）
{
列表调整=新列表（）；
Add（新调整（）{Amount=10.0M，IsCompounded=false，Add=true}）；
添加（新调整（）{Amount=7.0M，IsCompounded=false，Add=true}；）；
十进制值=0.0M；
小数总数=100.0M；
foreach（调整中的调整a）
{
值=a.计算（）；
如果（a.IsCompound）
{
如果（a.Add）
总*=价值；
其他的
总/=价值；
}
其他的
{
如果（a.Add）
total+=value；//应该是nom的和
其他的
总数-=价值；
}
}
控制台写入线（总计）；
}

试试这个：

public class Adjustment
{
    public decimal Amount {get;set;}
    public bool IsCompounded {get;set;}
    public bool Add{get;set;}

    public decimal Calculate()
    {
        if(IsCompounded)
            return 1 + Amount / 100.0M;
        else
            return Amount / 100.0M;
    }
 }

void Main()
{
    List<Adjustment> adjustments = new List<Adjustment>();
    adjustments.Add(new Adjustment() {Amount = 10.0M, IsCompounded = false, Add = true});
    adjustments.Add(new Adjustment() {Amount = 7.0M, IsCompounded = false, Add = true};);

    decimal value = 0.0M;
    decimal total = 100.0M;

    foreach(Adjustment a in adjustments)
    {
        value = a.Calculate();

        if(a.IsCompound)
        {
            if(a.Add)
                 total *= value;
             else
                 total /= value;
        }
        else
        {
            if(a.Add)
                 total += value; //should be a sum for nom-compounded
             else
                 total -= value;
        }
    }

    Console.WriteLine(total);
}

公共类调整
{
公共十进制数{get；set；}
公共布尔是复合的{get；set；}
公共bool Add{get；set；}
公共十进制计算（）
{
如果（是复合的）
返回1+金额/100.0M；
其他的
返还金额/100.0M；
}
}
void Main（）
{
列表调整=新列表（）；
Add（新调整（）{Amount=10.0M，IsCompounded=false，Add=true}）；
添加（新调整（）{Amount=7.0M，IsCompounded=false，Add=true}；）；
十进制值=0.0M；
小数总数=100.0M；
foreach（调整中的调整a）
{
值=a.计算（）；
如果（a.IsCompound）
{
如果（a.Add）
总*=价值；
其他的
总/=价值；
}
其他的
{
如果（a.Add）
total+=value；//应该是nom的和
其他的
总数-=价值；
}
}
控制台写入线（总计）；
}

到目前为止，我只是传入了一个.Amount。您语句的第二部分让我有点困惑：您当时从对象中读取了Amount，然后可能将其作为属性get返回。好的，希望这更有意义！我想我明白了，所以我应该将属性AmountFraction放在我的调整类中，对吗？我将测试我很好奇，调用a.AmountFraction是否更快，我不这么认为，因为它调用的是同一个代码。是的，这就是我的意思。但是它不会