Question

我知道这可能不需要重构。我只是开始尝试使用重构，但我尝试使用这行代码失败了。我试图在VS2013中使用提取方法。唉。我在其他11个实例中使用了这一行的右侧。

Balance = Enumerable.Repeat(0.0, MonthsToRun).ToList();

Balance是double，MonthsToRun是int。

按要求：

for (int i = 0, chunksCnt = Chunks.Count; i < chunksCnt; i++)
    {
    if (Chunks[i].BeginDate < BeginDate) BeginDate = Chunks[i].BeginDate;
    MonthsToRun = Math.Max(MonthsToRun, Utils.MonthDifference(BeginDate, Chunks[i].BeginDate) + Chunks[i].Balance.Count);
    }

    Balance = Enumerable.Repeat(0.0, MonthsToRun).ToList();
    Default = Enumerable.Repeat(0.0, MonthsToRun).ToList();
    Loss = Enumerable.Repeat(0.0, MonthsToRun).ToList();
    Prepay = Enumerable.Repeat(0.0, MonthsToRun).ToList();
    Principal = Enumerable.Repeat(0.0, MonthsToRun).ToList();
    Interest = Enumerable.Repeat(0.0, MonthsToRun).ToList();

    for (int i = 0, chunksCnt = Chunks.Count; i < chunksCnt; i++)
        {
        offset = Utils.MonthDifference(BeginDate, Chunks[i].BeginDate);

        for (int j = offset, balanceCnt = Chunks[i].Balance.Count; j < (balanceCnt + offset); j++)
            {
            Balance[j] += Chunks[i].Balance[j - offset];
            Default[j] += Chunks[i].Default[j - offset];
            Loss[j] += Chunks[i].Loss[j - offset];
            Prepay[j] += Chunks[i].Prepay[j - offset];
            Principal[j] += Chunks[i].Principal[j - offset];
            Interest[j] += Chunks[i].Interest[j - offset];
            }

            if (Settings.runBacktesting)
                {
                foreach (KeyValuePair<Tuple<int, int, DateTime>, double> item in Chunks[i].TransProbChunk)
                {
                Utils.upsertDict(TransProbAgg, item.Key, item.Value);
                //Create From Status - Month Totals Dictionary to create transition rates
                Tuple<int, DateTime> key = new Tuple<int, DateTime>(item.Key.Item1, item.Key.Item3);
                Utils.upsertDict(fromMonthTotals, key, item.Value);
                }
           }
      }

Answer 1

我个人觉得不需要重构那条线。重构通常是因为可读性/理解或性能。这条线看起来很可读。

如果你因为重复而试图重构，那么你会重构以下因为＆＃39; = 0;＆＃39;重复？

int x1 = 0;
int x2 = 0;
int x3 = 0;
int x4 = 0;
int x5 = 0;
int x6 = 0;
int x7 = 0;

在这个愚蠢的情况下，你可以将它全部放在一行，但在实际代码中，它将变得不可读。

你能做的是做一个＆＃34;零＆＃34;变量：

    private void Zero<T>(int size, ref List<T> l1, ref List<T> l2, ref List<T> l3)
    {
        T[] zeroes = Enumerable.Repeat(default(T), size).ToArray();
        l1 = new List<T>(zeroes);
        l2 = new List<T>(zeroes);
        l3 = new List<T>(zeroes);
    }

并称之为：

Zero(MonthsToRun, ref Balance, ref Default, ref Loss, ...);

如果你因为性能而试图这样做，那么某种缓存可以帮助你......

public static class Sizer<T>
{
    static Dictionary<int, T[]> _cache = new Dictionary<int, T[]>();

    public static void Init(ref List<T> list, int size)
    {
        T[] ret;

        if (!_cache.TryGetValue(size, out ret))
        {
            ret = Enumerable.Repeat(default(T), size).ToArray();
            _cache[size] = ret;
        }

        list = ret.ToList();
    }
}

尽管我不认为你可以用它取得很多成就......

以下讲述上述课程（我不太关心优化）加速是大约6倍：

        Random r;
        const int repeatCount = 1000000;
        List<int> list = null;

        r = new Random(0);
        var start = DateTime.Now.Ticks;
        for (int i = 0; i < repeatCount; i++)
        {
            list = Enumerable.Repeat(0, r.Next(5,150)).ToList();
        }
        var end = DateTime.Now.Ticks;
        var t1 = end - start;

        r = new Random(0);
        start = DateTime.Now.Ticks;
        for (int i = 0; i < repeatCount; i++)
        {
            Sizer<int>.Init(ref list, r.Next(5, 150)); // fill the list with default values for the type
        }
        end = DateTime.Now.Ticks;
        var t2 = end - start;
        var speedup = (double)t1 / t2;

Answer 2

正如其他人所说，你的行动结果是一份双打。如果你有11行，你使用Enumerable.Repeat至少有一个参数，每行不同，那么编写一个函数（可能是内联函数）是有意义的，但我会这样做，因为它很简单，很容易了解。

如果您需要让我们在11个地方说出n个零的列表，那么创建一个数组并在您需要的地方使用它。

var zeroes = Enumberable.Repeat(0.0 ,MonthsToRun).ToArray();
//or even:
//var zeroes = new double[MonthsToRun];
...
var myList1 = new List<double>(zeroes);
...
var myList2 = new List<double>(zeroes);

用作快捷方式的内联函数：

Func<double, int, List<double>> rv = (val, count) => { return Enumerable.Repeat(val, count).ToList(); };
...
var myList1 = rv(0.0, MonthsToRun);
...

此外，如果您使用资金，则使用decimal：

decimal vs double! - Which one should I use and when?

我如何在C＃中重构这行代码？

2 个答案: