什麼是避免這種重複代碼的最佳方式

我有以下幾種方法：什麼是避免這種重複代碼的最佳方式

public int CountProperty1 
    { 
     get 
     { 
      int count = 0; 
      foreach (var row in Data) 
      { 
       count = count + row.Property1; 
      } 
      return count ; 
     } 
    } 

    public int CountProperty2 
    { 
     get 
     { 
      int count = 0; 
      foreach (var row in Data) 
      { 
       count = count + row.Property2; 
      } 
      return count ; 
     } 
    }

什麼是爲了避免重複，這裏和共享的代碼量可能

來源

2011-07-29 leora

您可以使用LINQ嗎？ – oleksii

值得一提的是，您的實現是Sum（）而不是Count（）？ –

如何用最好的方式LINQ和Sum擴展方法？

public int CountProperty1 
{ 
    get { return Data.Sum(r => r.Property1); } 
}

如果這不是一個選項，你可以重構出邏輯到自己和方法：

public int CountProperty1 
{ 
    get 
    { 
     return CountProperty(r => r.Property1); 
    } 
} 

public int CountProperty2 
{ 
    get 
    { 
     return CountProperty(r => r.Property2); 
    } 
} 

private int CountProperty(Func<Row,int> countSelector) 
{ 
    int count = 0; 
    foreach (var row in Data) 
    { 
     count = count + countSelector(row); 
    } 
    return count ; 
}

備註最後一個例子：我做了「行」類型，如從你的例子中看不出來。用適當的類型替代。

來源

2011-07-29 10:14:52 driis

這具有減少代碼的優點，因此重複不是一個問題。 –

快速計數，您會發現重構後的代碼與原始代碼具有完全相同的行數，更復雜且執行速度更慢。這不是重構好處的好例子！（不包括Data.Sum（）優秀的推薦） –

@Steve，我也贊成Sum（）解決方案，我只是想提供一個例子，說明它如何以更一般的術語來重構這樣的問題 - 也，他的代碼庫中的兩個示例屬性可能不止兩個看起來相同。 – driis

不要打擾。

您可以縮短代碼，但如果您嘗試重構它以消除重複，則只會使代碼更復雜。

將您的重構工作集中在更復雜和值得的案例上。人生太短...

幾個字節的磁盤空間是極其便宜的，複製/粘貼是開發人員最好的朋友。另外，如果我們正在對它進行純化，請考慮重構的運行時間開銷。

來源

2011-07-29 10:16:39

我強烈反對。雖然你的觀點在某些情況下可能是有效的，但這是非常明顯的代碼重複，可以很容易地分解給一個簡單的幫助者，它肯定值得對付重複。 – driis

我的觀點是，代碼重複時很重要。你的CountProperty方法是更復雜的一個數量級，只有少數幾行代碼。簡單性和冗長性之間的折衷並不總是直截了當的。 –

@Steve - 我同意你100％ - 但是，我會補充說，這些應該是方法而不是屬性。 –

-2

給它說的輸入參數，其參數

public int CountProperty (int whichProperty) 
    { 
     get 
     { 
      int count = 0; 
      foreach (var row in Data) 
      { 
       if(whichProperty = 1) 
        count = count + row.Property1; 
       if(whichProperty = 2) 
        count = count + row.Property2; 
      } 
      return count ; 
     } 
    }

來源

2011-07-29 10:17:36

似乎更像你是移動問題，而不是解決它...不是我的投票，雖然 – musefan

-2

public int CountProperty1 
{ 
    get 
    { 
     return GetCount(row.Property1); 
    } 
} 

public int CountProperty2 
{ 
    get 
    { 
     return GetCount(row.Property2); 
    } 
} 

private int GetCount(object property) 
{ 
    int count = 0; 
    foreach (var row in Data) 
    { 
     if(property == row.Property1) 
     { 
      count = count + row.Property1; 
     } 
     else if (property == row.Property2) 
     { 
      count = count + row.Property2; 
     } 
    } 
    return count ; 
}

在i的簽名時所使用的對象的pribvate方法

- 直到我有需要的屬性的類型的更好knowelege

來源

2011-07-29 10:21:00

可能不是你正在尋找的答案，但這不一定是重複。有時候會有一種誤解，如果兩個不同的函數看起來是一樣的，那麼它們應該被重構以去除重複。在我的愚見中，這是錯誤的。

這只是重複，如果他們是真正的複製和identicial或近乎相同的概念。因爲它是重複的（至少應該刪除重複），它不僅僅是它們碰巧使用相同的代碼，而是出於同樣的原因使用相同的代碼。

這可能只是因爲你發佈的樣本，但它很簡單。儘管這兩個屬性的實現是相同的，但必須有一些有效的商業原因，即您擁有這兩個屬性，否則最簡單的答案就是一起刪除第二個屬性。然而，如果你真的有兩個屬性，而且他們看起來現在看起來一樣，那並不意味着他們在未來的功能性上不會出現分歧（這是可以的）。

這個想法是儘量減少複雜性和維護成本。只有當你的代碼有意義並且模型是現實的時候，你才能做到這一點，但是如果通過將看起來相似的事情彙集在一起，引入了錯誤的比較，那麼就不能這樣做。

http://mooneyblog.mmdbsolutions.com/index.php/2010/07/30/reusable-code-is-bad/

來源

2011-07-29 10:24:55

我不會理會的屬性個人，只是直接調用超出使用LINQ

myObject.Data.Sum(x=>x.Property1)

來源

2011-07-29 10:27:40

這正是，你應該用Data.Sum（x => x.Property1）替換CountProperty1 屬性的每個調用。 –

這是相當乾淨。如果我知道行的類型，我會傾向於把PropertyN（）放到它的類中，而不是在這裏，但缺乏這方面的知識：

public int CountPropertyN(int n) 
{ 
    int count = 0; 
    foreach (var row in Data) 
    { 
     count = count + PropertyN(row, n) 
    } 
    return count ; 
} 

private int PropertyN(var row, int n) 
{ 
    if (n == 1) return row.Property1; 
    else return row.Property2; 
}

來源

2011-07-29 14:15:34

什麼是避免這種重複代碼的最佳方式

回答

相關問題