C#/.NET - 运算符 AS 性能/方法

如何解决C#/.NET - 运算符 AS 性能/方法

我正在开发一个电子商务类的应用程序。

实体是：

• Product 与 List<Expense> Expenses
• Expense 带有 Description 道具，指的是包装、运输、管理费用等。

我需要至少有两种类型的费用：

1. 相对费用（百分比金额，根据产品价格计算）和
2. 绝对费用（数量）

我尝试做的是有一个

• abstract class Expense 带道具：Id、Description。
• class RelativeExpense : Expense with AmountInPercentage props 和
• class AbsoluteExpense : Expense 带有 Amount 道具。

为了计算费用，我有一个 GetTotalExpenseAmount(Product p) 方法：

public decimal GetTotalExpenseAmount(Product p)

{
  decimal totalExpenses = 0;
  foreach (var expense in p.Expenses)
  {
       if(expense.GetType() == typeof(RelativeExpense))
       {
           totalExpenses += p.BasePrice * (expense as RelativeExpense).AmountInPercentage / 100;
       }
       else if(expense.GetType() == typeof(AbsoluteExpense))
       {
          totalExpenses += (expense as AbsoluteExpense).Amount;
       }
                
  }

    return totalExpenses;
}

我的问题是，这是一个好习惯吗？我问的原因是因为 AS 操作员正在进行转换，我知道这在性能方面可能会很昂贵。另外，我将有一个 Logger 将打印出单个产品的所有扩展，因此将再次使用带有 foreach 运算符的 as。

有没有其他方法可以实现我想要的，但具有更好/更清晰的代码和性能？也许不同的建模？任何想法我应该如何解决这个问题？

解决方法

为什么强制转换在性能方面会很昂贵？我不这么认为。

但是，您可以在此处使用 is 运算符，它也可以跳过空值：

foreach (var expense in p.Expenses)
{
   if(expense is RelativeExpense relativeExpense)
   {
       totalExpenses += p.BasePrice * relativeExpense.AmountInPercentage / 100;
   }
   else if(expense is AbsoluteExpense absoluteExpense)
   {
      totalExpenses += absoluteExpense.Amount;
   }         
}

,

您可以使用 OOO 多态性。所以 C# 虚拟/抽象方法。

public decimal GetTotalExpenseAmount(Product p)
{
  decimal totalExpenses = 0;
  foreach (var expense in p.Expenses)
  {
       totalExpenses += expense.GetPrice();
  }
  return totalExpenses;
}

public class Product {
    public string Name;
    public List<Expense> Expenses;
}

public abstract class Expense {
    public string Id;
    public string Description;
    
    public abstract int GetPrice();
}

public class RelativeExpense : Expense {
    public int AmountInPercentage;
    public int BasePrice;
    
    public override int GetPrice() {
        return BasePrice * AmountInPercentage / 100;
    }
}

public class AbsoluteExpense : Expense { 
    public int Amount;
    
    public override int GetPrice() {
        return Amount;
    }
}

一个警告，我将 BasePrice 移动到 RelativeExpense 类。

,

我建议使用具有 IsRelative 属性的单个类：

class Expense 
{
    (...)
    public bool IsRelative {get;}
    public decimal AmountInPercentage {get;}
    public decimal Amount {get;
}
(...)
foreach (var expense in p.Expenses)
{
    if(expense.IsRelative)
    {
        totalExpenses += p.BasePrice * expense.AmountInPercentage / 100;
    }
    else
    {
        totalExpenses += (expense as AbsoluteExpense).Amount;
    }            
}

甚至

class Expense 
{
    (...)
    public bool IsRelative {get;}
    public decimal Amount {get;}
}

(...)

foreach (var expense in p.Expenses)
{
    if(expense.IsRelative)
    {
        totalExpenses += p.BasePrice * expense.Amount / 100;
    }
    else
    {
        totalExpenses += expense.Amount;
    }            
}