Bob Amca'nın Temiz Kod ilkelerine uyması durumunda ifadeler zincirini nasıl düzenlerim?

Bob Amca'nın temiz kod önerilerini takip etmeye ve özellikle yöntemleri kısa tutmaya çalışıyorum.

Ancak kendimi bu mantığı kısaltamıyor buluyorum:

if (checkCondition()) {addAlert(1);}
else if (checkCondition2()) {addAlert(2);}
else if (checkCondition3()) {addAlert(3);}
else if (checkCondition4()) {addAlert(4);}

Kabloları çıkaramıyorum ve bu yüzden her şeyi daha küçük parçalara ayıracağım, "başkası" nda "başkası" nın performansa yardımcı olması durumunda - bu koşulların değerlendirilmesinin pahalı olması ve aşağıdaki koşulların değerlendirilmesinden kaçınabilmem durumunda ilk olanlardan birine neden olması doğrudur, onlardan kaçınmak istiyorum.

Anlamsal olarak konuşsam bile, bir önceki koşulun yerine getirilip getirilmediğini bir sonraki durumu değerlendirmek iş açısından mantıklı gelmiyor.

düzenleme: Bu soru, eğer başka (varsa) işlemek için Zarif yolların olası bir kopyası olarak tanımlandı .

Bunun farklı bir soru olduğuna inanıyorum (bu soruların cevaplarını karşılaştırarak da bunu görebilirsiniz).

• Sorum şu ki, ilk kabul koşulunu hızla bitirmek için kontrol ediyor .
• Bağlantılı soru, bir şeyler yapmak için kabul etmek için tüm koşullara sahip olmaya çalışıyor . (bu sorunun cevabında daha iyi görülmesi: https://softwareengineering.stackexchange.com/a/122625/96955 )

İdeal olarak, uyarı kodunu / numarasını kendi yöntemine almak için mantığınızı çıkarmanız gerektiğini düşünüyorum. Yani mevcut kodunuz tamamen azaldı

{
    addAlert(GetConditionCode());
}

ve GetConditionCode () koşullarını kontrol etmek için mantığı içine alır. Belki bir Enum kullanmak sihirli bir sayıdan daha iyidir.

private AlertCode GetConditionCode() {
    if (CheckCondition1()) return AlertCode.OnFire;
    if (CheckCondition2()) return AlertCode.PlagueOfBees;
    if (CheckCondition3()) return AlertCode.Godzilla;
    if (CheckCondition4()) return AlertCode.ZombieSharkNado;
    return AlertCode.None;
}

Önemli ölçüm, mutlak boyut değil, kodun karmaşıklığıdır. Farklı koşulların gerçekten sadece tek işlevli çağrılar olduğunu varsayarsak, eylemler gösterdiklerinizden daha karmaşık değil gibi, kodda yanlış bir şey olmadığını söyleyebilirim. Zaten olabildiğince basit.

Daha da “basitleştirmek” için yapılan herhangi bir girişim aslında işleri karmaşık hale getirecektir.

Elbette, elseanahtar kelimeyi returnbaşkalarının önerdiği şekilde değiştirebilirsiniz, ancak bu sadece bir stil meselesidir, karmaşıklıktaki herhangi bir değişiklik değildir.

kenara:

Genel tavsiyem, hiçbir zaman temiz kod kuralları için dini olmadı: İnternette gördüğünüz kodlama tavsiyelerinin çoğu, uygun bir bağlamda uygulanırsa iyidir, ancak aynı tavsiyeyi her yerde radikal olarak uygulamak, IOCCC . İşin püf noktası daima insanların kodunuzla ilgili kolayca akıllarına neden olacak bir dengeyi yakalamaktır.

Çok büyük metotlar kullanın, berbatsınız. Çok küçük fonksiyonlar kullanın, ve berbatsınız. Üçlü ifadelerden kaçının ve mahvolursunuz. Her yerde üçlü ifadeler kullanın ve işin biter. Tek satırlık işlevler gerektiren yerler ve 50 satırlık işlevler için yerler (evet, varlar!) Olduğunu fark edin. Yerlerde olduğunu fark etmesi için çağrı if()yerler vardır tabloların ve bu bunun için çağrı ?:operatörü. Emrinde olan tam cephaneliği kullanın ve daima bulabileceğiniz en uygun aracı kullanmayı deneyin. Ve unutma, bu tavsiye konusunda bile dindar olma.

Bunun herhangi bir durum için uygun değilse, ovadan 'daha iyi' olup olmadığı tartışmalıdır. Ama eğer istediğiniz bir şey denemek için başka bu bunu yapmanın yaygın bir yoludur.

Koşullarınızı nesnelere koyun ve bu nesneleri bir listeye yerleştirin.

foreach(var condition in Conditions.OrderBy(i=>i.OrderToRunIn))
{
    if(condition.EvaluatesToTrue())
    {
        addAlert(condition.Alert);
        break;
    }
}

Durumda birden fazla eylem gerekiyorsa, bazı çılgın özyineleme yapabilirsiniz

void RunConditionalAction(ConditionalActionSet conditions)
{
    foreach(var condition in conditions.OrderBy(i=>i.OrderToRunIn))
    {
        if(condition.EvaluatesToTrue())
        {
            RunConditionalAction(condition);
            break;
        }
    }
}

Açıkçası evet. Bu sadece mantığınıza uygun bir düzeniniz varsa işe yarar. Süper bir genel özyinelemeli koşullu eylem yapmaya çalışırsanız, nesnenin kurulumu orijinal if ifadesi kadar karmaşık olacaktır. Kendi yeni dilinizi / çerçevenizi icat edeceksiniz.

Ama örnek yapar bir model var

Bu model için yaygın bir kullanım durumu doğrulama olacaktır. Onun yerine :

bool IsValid()
{
    if(condition1 == false)
    {
        throw new ValidationException("condition1 is wrong!");
    }
    elseif(condition2 == false)
    {
    ....

}

Oluyor

[MustHaveCondition1]
[MustHaveCondition2]
public myObject()
{
    [MustMatchRegExCondition("xyz")]
    public string myProperty {get;set;}
    public bool IsValid()
    {
        conditions = getConditionsFromReflection()
        //loop through conditions
    }
}

return;Bir koşul başarılı olduktan sonra kullanmayı düşünün , tüm elses kaydeder . Bu return addAlert(1)yöntemin bir geri dönüş değeri varsa, doğrudan bile mümkün olabilir .

Bu gibi yapıları bazen daha temiz görüyorum:

switch(true) {
    case cond1(): 
        statement1; break;
    case cond2():
        statement2; break;
    case cond3():
        statement3; break;
    // .. etc
}

Sağ aralıklı üçlü de temiz bir alternatif olabilir:

cond1() ? statement1 :
cond2() ? statement2 :
cond3() ? statement3 : (null);

Sanırım ayrıca koşul ve işlev içeren bir çift içeren bir dizi oluşturmayı deneyebilir ve ilk koşul karşılanıncaya kadar yinelemelisiniz - ki gördüğüm gibi Ewan'ın ilk cevabına eşit olacaktır.

@ Ewan'ın cevabının bir çeşidi olarak, aşağıdaki gibi koşullara sahip bir zincir ("düz liste" yerine) oluşturabilirsiniz:

abstract class Condition {
  private static final  Condition LAST = new Condition(){
     public void alertOrPropagate(DisplayInterface display){
        // do nothing;
     }
  }
  private Condition next = Last;

  public Condition setNext(Condition next){
    this.next = next;
    return this; // fluent API
  }

  public void alertOrPropagate(DisplayInterface display){
     if(isConditionMeet()){
         display.alert(getMessage());
     } else {
       next.alertOrPropagate(display);
     }
  }
  protected abstract boolean isConditionMeet();
  protected abstract String getMessage();  
}

Bu şekilde koşullarınızı tanımlanmış bir sırayla uygulayabilirsiniz ve altyapı (gösterilen soyut sınıf), ilk karşılaşma sonrasında kalan kontrolleri atlar.

Koşulları uygulayan döngüde "atlamayı" uygulamanız gereken "düz liste" yaklaşımına göre üstün olduğu yer burasıdır.

Siz sadece koşul zincirini kurdunuz:

Condition c1 = new Condition1().setNext(
  new Condition2().setNext(
   new Condition3()
 )
);

Değerlendirmeye basit bir çağrı ile başlayın:

c1.alertOrPropagate(display);

Her şeyden önce, orijinal kod IMO korkunç değil. Oldukça anlaşılabilir ve doğal olarak kötü bir şey yok.

Öyleyse, beğenmediyseniz, @ Ewan'ın bir liste kullanma fikrini geliştirmek, ancak biraz doğal olmayan foreach breakmodelini kaldırmak :

public class conditions
{
    private List<Condition> cList;
    private int position;

    public Condition Head
    {
        get { return cList[position];}
    }

    public bool Next()
    {
        return (position++ < cList.Count);
    }
}


while not conditions.head.check() {
  conditions.next()
}
conditions.head.alert()

Şimdi bunu kendi tercih ettiğiniz dile göre uyarlayın, listedeki her öğeyi bir nesne, bir tuple, ne olursa olsun ve iyisiniz.

EDIT: düşündüğüm kadar açık değil gibi görünüyor, bu yüzden daha fazla açıklamama izin verin. conditionssıralı bir sıralı listedir; headaraştırılmakta olan elemandır - başlangıçta listenin ilk elemanıdır ve her seferinde next()buna aşağıdaki ad verilir; check()ve alert()vardır checkConditionX()ve addAlert(X)OP.

Soru bazı özellikleri eksik. Eğer şartlar:

• değişebilir veya
• uygulamanın veya sistemin diğer bölümlerinde tekrarlanan veya
• belirli durumlarda değiştirilmiş (farklı yapılar, testler, konuşlandırmalar gibi)

ya da içeriğin addAlertdaha karmaşık olması durumunda, c # 'ya göre daha iyi bir çözüm olabilir:

//in some central spot
IEnumerable<Tuple<Func<bool>, int>> Conditions = new ... {
  Tuple.Create(CheckCondition1, 1),
  Tuple.Create(CheckCondition2, 2),
  ...
}

//at the original place
var matchingCondition = Conditions.Where(c=>c.Item1()).FirstOrDefault();
if(matchingCondition != null) 
  addAlert(matchingCondition.Item2)

Tuples c # <8'de çok güzel değil, uyum için seçilmiş.

Bu yöntemin avantajları, yukarıdaki seçeneklerden hiçbiri geçerli olmasa bile, yapının statik olarak yazılmış olması. Kazara, yani bir, eksik tarafından berbat edemezsin else.

Çok şeyiniz olduğu durumlarda Siklomatik karmaşıklığı azaltmanın en iyi yolu , anahtar değeri (eğer ifade değeri veya bir değeri) ve sonra bir değer / işlev sonucunu saklamak için if->then statementsbir sözlük veya liste kullanmak (dile bağlı) kullanmaktır.

Örneğin, (C #) yerine:

if (i > 10) { return "Two"; }
else if (i > 8) { return "Four" }
else if (i > 4) { return "Eight" }
return "Ten";  //etc etc say anything after 3 or 4 values

Basitçe yapabilirim

var results = new Dictionary<int, string>
{
  { 10, "Two" },
  { 8, "Four"},
  { 4, "Eight"},
  { 0, "Ten"},
}

foreach(var key in results.Keys)
{
  if (i > results[key]) return results.Values[key];
}

Daha modern dilleri kullanıyorsanız daha fazla mantık daha sonra basitçe de değerleri (c #) saklayabilirsiniz . Bu gerçekten sadece satır içi işlevlerdir, ancak mantığın satır satırına koymak için mantıklı olmasının yanı sıra diğer işlevlere de işaret edebilirsiniz.

var results = new Dictionary<Func<int, bool>, Func<int, string>>
{
  { (i) => return i > 10; ,
    (i) => return i.ToString() },
  // etc
};

foreach(var key in results.Keys)
{ 
  if (key(i)) return results.Values[key](i);
}

Bob Amca'nın temiz kod önerilerini takip etmeye ve özellikle yöntemleri kısa tutmaya çalışıyorum.

Ancak kendimi bu mantığı kısaltamıyor buluyorum:

if (checkCondition()) {addAlert(1);}
else if (checkCondition2()) {addAlert(2);}
else if (checkCondition3()) {addAlert(3);}
else if (checkCondition4()) {addAlert(4);}

Kodunuz zaten çok kısa, ancak mantığın kendisi değiştirilmemelidir. İlk bakışta kendinizi dört çağrı ile tekrarlıyormuşsunuz gibi görünüyor checkCondition()ve yalnızca kodu dikkatlice tekrar okuduktan sonra her birinin farklı olduğu anlaşılıyor. Doğru formatlama ve fonksiyon isimleri eklemelisiniz, örneğin:

if (is_an_apple()) {
  addAlert(1);
}
else if (is_a_banana()) {
  addAlert(2);
}
else if (is_a_cat()) {
  addAlert(3);
}
else if (is_a_dog()) {
  addAlert(4);
}

Kodunuz her şeyden önce okunabilir olmalıdır. Bob Amca'nın kitaplarından birkaçını okuyarak, sürekli olarak karşı karşıya kalmaya çalıştığı mesajın bu olduğuna inanıyorum.

Tüm fonksiyonların aynı bileşen içinde gerçekleştirildiğini varsayalım, akıştaki çoklu dallardan kurtulmak için fonksiyonların bir miktar kalmasını sağlayabilirsiniz.

EG: checkCondition1()olacaktı evaluateCondition1()önceki koşul karşılandığında olsaydı hangi o-kontrol edin; öyleyse, o zaman alınacak değeri önbelleğe alır getConditionNumber().

checkCondition2()evaluateCondition2()önceki koşulların karşılanıp karşılanmadığını kontrol edeceği hale gelir . Önceki koşul yerine getirilmediyse, durum senaryosunu 2 kontrol eder ve alınacak değeri önbelleğe alır getConditionNumber(). Ve bunun gibi.

clearConditions();
evaluateCondition1();
evaluateCondition2();
evaluateCondition3();
evaluateCondition4();
if (anyCondition()) { addAlert(getConditionNumber()); }

DÜZENLE:

İşte bu yaklaşımın çalışması için pahalı koşulların kontrolünün nasıl yapılması gerektiği.

bool evaluateCondition34() {
    if (!anyCondition() && A && B && C) {
        conditionNumber = 5693;
        return true;
    }
    return false;
}

...

bool evaluateCondition76() {
    if (!anyCondition() && !B && C && D) {
        conditionNumber = 7658;
        return true;
    }
    return false;
}

Bu nedenle, yapılacak çok fazla pahalı kontrol varsa ve bu koddaki şeyler özel kalırsa, bu yaklaşım kontrollerin yapılmasına yardımcı olur, gerekirse kontrollerin sırasını değiştirmeyi sağlar.

clearConditions();
evaluateCondition10();
evaluateCondition9();
evaluateCondition8();
evaluateCondition7();
...
evaluateCondition34();
...
evaluateCondition76();

if (anyCondition()) { addAlert(getConditionNumber()); }

Bu cevap sadece diğer cevaplardan bazı alternatif öneriler sunar ve sadece 4 kod satırı göz önüne alırsak, muhtemelen orijinal koddan daha iyi olmayacaktır. Her ne kadar, bahsettiğim senaryo göz önüne alındığında , bu korkunç bir yaklaşım olmasa da (ve diğerlerinin söylediği gibi bakımı daha da zorlaştırmasa da) (çok fazla kontrol, sadece halka açık olan ana fonksiyon, tüm fonksiyonlar aynı sınıfın uygulama ayrıntılarıdır).

İkiden fazla “başka” cümlesi, kodun okuyucusunu ilgilenen birini bulmak için tüm zincir boyunca ilerlemeye zorlar. Şunlar gibi bir yöntem kullanın: void AlertUponCondition (Koşul koşulu) {anahtar (koşul) {durum Condition.Con1: ... break; durum Condition.Con2: ... sonu; etc ...} "Koşul" uygun bir numaradır. Gerekirse, bir bool veya değer döndürün. Buna şöyle ad verin: AlertOnCondition (GetCondition ());

Gerçekten daha kolay olamaz, VE birkaç vakayı aştığınızda if-else zincirinden daha hızlı.

Özel durumunuz için konuşamam, çünkü kod belirli değildir, ancak ...

Bunun gibi bir kod genellikle eksik bir OO modeli için bir koku. Her biri kendi uyarıcı türüyle ilişkilendirilmiş dört tür şeyiniz var, ancak bu varlıkları tanımak ve her biri için bir sınıf örneği oluşturmak yerine, onları bir şey olarak kabul ediyor ve daha sonra telafi etmeye çalışıyorsunuz. devam etmek için neyle uğraştığınızı bilmeniz gerekir.

Polimorfizm size daha uygun olabilir.

Eğer öyleyse uzun veya karmaşık if-then yapıları içeren uzun yöntemlerden şüphelenmeyin. Genellikle orada bazı sanal yöntemlerle bir sınıf ağacı istersiniz.