Несколько методов одиночного назначения против нескольких методов с несколькими целями

Question

Я всегда думал, что методы и функции с явной подписью и 3-5 строк кода сделают код более понятным, но во многих случаях мне сказали, что я тоже многие функции/методы. По-видимому, легче перемещаться внутри класса, который имеет несколько методов. Эти люди говорят, что метод должен быть разделен только для повторного использования. Я лично считаю, что, когда метод длиннее, он имеет тенденцию становиться более длинным по сравнению с модификациями и что он будет возрастать по сложности. Даже пронзительный, он больше не будет тестироваться. Я читал эту тему, и я не передумал, но, похоже, я один, чтобы думать так. Я ошибаюсь?

Я взял этот код из MSDN:

private void CreatePO(string filename) 
    { 
     // Create an instance of the XmlSerializer class; 
     // specify the type of object to serialize. 
     XmlSerializer serializer = 
     new XmlSerializer(typeof(PurchaseOrder)); 
     TextWriter writer = new StreamWriter(filename); 
     PurchaseOrder po=new PurchaseOrder(); 

     // Create an address to ship and bill to. 
     Address billAddress = new Address(); 
     billAddress.Name = "Teresa Atkinson"; 
     billAddress.Line1 = "1 Main St."; 
     billAddress.City = "AnyTown"; 
     billAddress.State = "WA"; 
     billAddress.Zip = "00000"; 
     // Set ShipTo and BillTo to the same addressee. 
     po.ShipTo = billAddress; 
     po.OrderDate = System.DateTime.Now.ToLongDateString(); 

     // Create an OrderedItem object. 
     OrderedItem i1 = new OrderedItem(); 
     i1.ItemName = "Widget S"; 
     i1.Description = "Small widget"; 
     i1.UnitPrice = (decimal) 5.23; 
     i1.Quantity = 3; 
     i1.Calculate(); 

     // Insert the item into the array. 
     OrderedItem [] items = {i1}; 
     po.OrderedItems = items; 
     // Calculate the total cost. 
     decimal subTotal = new decimal(); 
     foreach(OrderedItem oi in items) 
     { 
     subTotal += oi.LineTotal; 
     } 
     po.SubTotal = subTotal; 
     po.ShipCost = (decimal) 12.51; 
     po.TotalCost = po.SubTotal + po.ShipCost; 
     // Serialize the purchase order, and close the TextWriter. 
     serializer.Serialize(writer, po); 
     writer.Close(); 
    } 

Я манипулируют, чтобы превратить его в этот код:

private void CreatePO(string filename) 
    { 
     Serialize(GetPurchaseOrder(), filename); 
    } 

    private PurchaseOrder GetPurchaseOrder() 
    { 
     return new PurchaseOrder() 
      { 

       ShipTo = GetBillAdress(), 
       OrderDate = System.DateTime.Now.ToLongDateString(), 
       OrderedItems = GetOrderedItems(), 
       ShipCost = (decimal)12.51 
      }; 
    } 

    //Will be inside of PurchaseOrder class 
    private decimal GetSubTotal(OrderedItem[] items) 
    { 
     return items.Sum(x => x.LineTotal); 
    } 

    private OrderedItem[] GetOrderedItems() 
    { 
     OrderedItem i1 = new OrderedItem() 
      { 
       ItemName = "Widget S", 
       Description = "Small widget", 
       UnitPrice = (decimal)5.23, 
       Quantity = 3, 
       Calculate() 
      }; 

     // Insert the item into the array. 
     return new OrderedItem[]{ i1 }; 
    } 

    private void Serialize<T>(T toSerialize, string filename) 
    { 
     using (var w = new StreamWriter(filename)) 
     { 
      var s = new XmlSerializer(typeof(T)); 

      s.Serialize(w, toSerialize); 
     }    
    } 

    private Adress GetBillAdress() 
    { 
     return new Address() 
      { 
       Name = "Teresa Atkinson", 
       Line1 = "1 Main St.", 
       City = "AnyTown", 
       State = "WA", 
       Zip = "00000" 
      }; 
    } 

Некоторые могут сказать, что большинство функций здесь будет использоваться только один раз. Но какова лучшая практика? Может ли этот способ расщепления кода замедлить выполнение? и сложность компиляции? Каковы реальные преимущества, отличные от читаемости?

Answer 1

Ну, на мой взгляд, вы правы. Но это мнение.

Для получения наилучших результатов о количестве и размере методов см this question

Но можно сделать это совершенно неправильно!

При расщеплении работы в меньших методах вы должны заботиться о том, чтобы не вводить нежелательные зависимости между этими методами.

Например, когда методы начинают полагаться на состояние, установленное другим методом, вместо того, чтобы передавать эту информацию в качестве параметра, мы вводим темные воды.

Так что это определенно зависит от того, как оно реализовано.

Для тестирования это не имеет большого значения, поскольку большинство этих небольших методов являются частными и могут быть проверены только через открытый интерфейс класса.

Это, конечно, не намерение самостоятельно протестировать каждый метод. Это сделало бы тест очень хрупким. Когда вы начинаете с проверенного большого метода и реорганизуете кучу меньших методов, тесты не должны обновляться, вы должны поддерживать 100% -ный охват.