Büyük bir boole ifadesi, aynı yöntemden yordama yöntemlerine ayrılandan daha okunabilir mi? [kapalı]

Anlaması daha kolay, büyük bir boole ifadesi (oldukça karmaşık) ya da aynı ifadeyi yordama yöntemlerine (okumak için fazladan fazla kod) ayrıştırmak nedir?

Seçenek 1, büyük boole ifadesi:

    private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal)
    {

        return propVal.PropertyId == context.Definition.Id
            && !repo.ParentId.HasValue || repo.ParentId == propVal.ParentId
            && ((propVal.SecondaryFilter.HasValue && context.SecondaryFilter.HasValue && propVal.SecondaryFilter.Value == context.SecondaryFilter) || (!context.SecondaryFilter.HasValue && !propVal.SecondaryFilter.HasValue));
    }

Seçenek 2, Koşulları yordama yöntemlerine ayrılır:

    private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal)
    {
        return MatchesDefinitionId(context, propVal)
            && MatchesParentId(propVal)
            && (MatchedSecondaryFilter(context, propVal) || HasNoSecondaryFilter(context, propVal));
    }

    private static bool HasNoSecondaryFilter(CurrentSearchContext context, TValToMatch propVal)
    {
        return (!context.No.HasValue && !propVal.SecondaryFilter.HasValue);
    }

    private static bool MatchedSecondaryFilter(CurrentSearchContext context, TValToMatch propVal)
    {
        return (propVal.SecondaryFilter.HasValue && context.No.HasValue && propVal.SecondaryFilter.Value == context.No);
    }

    private bool MatchesParentId(TValToMatch propVal)
    {
        return (!repo.ParentId.HasValue || repo.ParentId == propVal.ParentId);
    }

    private static bool MatchesDefinitionId(CurrentSearchContext context, TValToMatch propVal)
    {
        return propVal.PropertyId == context.Definition.Id;
    }

İkinci yaklaşımı tercih ediyorum, çünkü yöntem adlarını yorum olarak görüyorum, ancak problemli olduğunu biliyorum çünkü kodun ne yaptığını anlamak için tüm yöntemleri okumak zorundasınız, bu nedenle kodun amacını ortadan kaldırıyor.

Anlaması daha kolay olan ne

İkinci yaklaşım. Bunu anlamak sadece kolay değil, aynı zamanda yazmak, test etmek, yeniden düzenlemek ve genişletmek de daha kolay. Her istenen koşul güvenli bir şekilde ayrı ayrı çözülebilir ve kendi yöntemiyle ele alınabilir.

bu sorunlu çünkü kodu anlamak için tüm yöntemleri okumak zorundasınız.

Yöntemlerin uygun şekilde adlandırılması sorun değil. Aslında, yöntem adının koşulun amacını tanımladığı şekliyle anlaşılması daha kolay olacaktır.
Bir seyirci if MatchesDefinitionId()için daha açıklayıcıif (propVal.PropertyId == context.Definition.Id)

[Şahsen ilk yaklaşım gözlerimi acıtıyor.]

Bu, yüklem işlevlerinin kullanılabileceği tek yerse, boolbunun yerine yerel değişkenleri de kullanabilirsiniz :

private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal)
{
    bool matchesDefinitionId = (propVal.PropertyId == context.Definition.Id);
    bool matchesParentId = (!repo.ParentId.HasValue || repo.ParentId == propVal.ParentId);
    bool matchesSecondaryFilter = (propVal.SecondaryFilter.HasValue && context.No.HasValue && propVal.SecondaryFilter.Value == context.No);
    bool hasNoSecondaryFilter = (!context.No.HasValue && !propVal.SecondaryFilter.HasValue);

    return matchesDefinitionId
        && matchesParentId
        && matchesSecondaryFilter || hasNoSecondaryFilter;
}

Bunlar ayrıca daha fazla parçalanabilir ve daha okunabilir hale getirmek için yeniden sıralanabilir, örneğin;

bool hasSecondaryFilter = propVal.SecondaryFilter.HasValue;

ve ardından tüm örneklerini değiştirme propVal.SecondaryFilter.HasValue. O zaman hemen ortaya çıkan bir şey, hasNoSecondaryFiltermantıksal VE ihmal edilen HasValueözellikler üzerinde mantıksal ve ihmal edilenler matchesSecondaryFilterüzerinde mantıksal kullanır HasValue- yani tam tersi değildir.

Genel olarak, ikincisi tercih edilir.

Bu çağrı sitesini daha yeniden kullanılabilir hale getirir. DRY'yi destekler (yani ölçütler değiştiğinde değiştirilecek daha az yeriniz olur ve daha güvenilir bir şekilde yapabilirsiniz). Ve çoğu zaman bu alt kriterler, bunu yapmanıza izin veren, başka bir yerde bağımsız olarak yeniden kullanılacak şeylerdir.

Oh, ve bu, üniteyi test etmeyi çok daha kolaylaştırıyor ve doğru yaptığınızdan emin olmanızı sağlıyor.

Bu iki seçenek arasındaysa, ikincisi daha iyidir. Ancak bunlar sadece seçenek değil! Tek işlevi çoklu ifs'e bölmeye ne dersiniz? Ek testlerden kaçınmak için fonksiyondan çıkmanın yollarını test edin, kabaca tek bir hat testinde "kısa devre" öykünür.

Bunu okumak daha kolaydır (örneğiniz için mantığı iki kez kontrol etmeniz gerekebilir, ancak kavram doğrudur):

private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal)
{
    if( propVal.PropertyId != context.Definition.Id ) return false;

    if( repo.ParentId.HasValue || repo.ParentId != propVal.ParentId ) return false;

    if( propVal.SecondaryFilter.HasValue && 
        context.SecondaryFilter.HasValue && 
        propVal.SecondaryFilter.Value == context.SecondaryFilter ) return true;

    if( !context.SecondaryFilter.HasValue && 
        !propVal.SecondaryFilter.HasValue) return true;

    return false;   
}

Seçenek 2'yi daha çok seviyorum, ancak bir yapısal değişiklik önerebilirim. Koşullu son satırındaki iki kontrolü tek bir aramada birleştirin.

private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal)
{
    return MatchesDefinitionId(context, propVal)
        && MatchesParentId(propVal)
        && MatchesSecondaryFilterIfPresent(context, propVal);
}

private static bool MatchesSecondaryFilterIfPresent(CurrentSearchContext context, 
                                                    TValToMatch propVal)
{
    return MatchedSecondaryFilter(context, propVal) 
               || HasNoSecondaryFilter(context, propVal);
}

Bunu önerme sebebim, iki kontrolün tek bir işlevsel ünite olması ve parantezin koşullu bir şekilde iç içe geçmesidir: Hem kodu başlangıçta yazma açısından hem de okuyan kişinin bakış açısından. Bu, özellikle, ifadenin alt öğelerinin aynı modeli izlememesi durumunda geçerlidir.

MatchesSecondaryFilterIfPresent()Kombinasyon için en iyi isim olup olmadığından emin değilim ; ama daha iyi bir şey hemen akla geliyor.

C # dilinde olmasına rağmen kod çok nesneye yönelik değildir. Statik yöntemler kullanıyor ve statik alanlara benziyor (örn. repo). Genel olarak, statik durumun yeniden kullanma kabiliyetini zorlaştırırken kodunuzu yeniden kırmak için zorlaştırması ve test etmesini zorlaştırdığı ve sorunuza göre şu şekildedir: bunun gibi statik kullanım nesneye yönelik yapıdan daha az okunabilir ve korunabilirdir.

Bu kodu daha çok nesne yönelimli bir forma dönüştürmelisiniz. Bunu yaptığınızda, nesnelerin, alanların vb. Karşılaştırma yapmak için basit bir talep (örneğin if ( a.compareTo (b) ) { }, tüm saha karşılaştırmalarını içerebilecek.)

C #, nesneler ve alanları ile ilgili karşılaştırmalar yapmak için zengin bir arayüz ve sistem yardımcı programına sahiptir. Bariz ötesinde .Equalsyöntemle başlayanlar için, içine bakmak IEqualityComparer, IEquatableve yardımcı programlar gibi System.Collections.Generic.EqualityComparer.Default.

İkincisi kesinlikle tercih edilir, ilk yolu olan vakaları gördüm ve okumak her zaman imkansızdır. Bunu ilk şekilde yapma hatasını yaptım ve yöntemleri tahmin etmek için değiştirmem istendi.

İkisinin de aynı olduğunu söyleyebilirim, okunabilirlik için biraz boşluk eklerseniz ve okuyucuya daha belirsiz kısımlarda yardımcı olması için yorumlarınızı eklerseniz.

Unutmayın: İyi yorumlar okuyucuya kodu yazarken ne düşündüğünüzü söyler .

Önerdiğim gibi değişikliklerle, muhtemelen daha az karmaşık ve dağınık olduğu için eski yaklaşımla giderdim. Alt program çağrıları dipnotlar gibidir: faydalı bilgiler sağlar ancak okuma akışını bozarlar. Eğer tahminler daha karmaşık olsaydı, onları somutlaştırılmış kavramların anlaşılabilir parçalara yerleştirilebilmesi için onları ayrı yöntemlere bölerdim.

Peki, yeniden kullanmak isteyeceğiniz parçalar varsa, bunları ayrı bir şekilde adlandırılmış fonksiyonlara ayırmak en iyi fikirdir.
Bunları asla kullanmayın olabilir bile, bunu yaparken daha iyi koşullar yapılandırmak ve onlar açıklayan onlara etiketleyebilmek izin verebilir demek .

Şimdi ilk seçeneğinize bakalım ve ne de sizin girintiniz olduğunu ve her şeyi yararlı kıldığınızı ya da şartlı her şeyi iyi yapılandırdığınızı kabul edin:

private static bool ContextMatchesProp(CurrentSearchContext context, TValToMatch propVal) {
    return propVal.PropertyId == context.Definition.Id && !repo.ParentId.HasValue
        || repo.ParentId == propVal.ParentId
        && propVal.SecondaryFilter.HasValue == context.SecondaryFilter.HasValue
        && (!propVal.SecondaryFilter.HasValue || propVal.SecondaryFilter.Value == context.SecondaryFilter.Value);
}

İlki kesinlikle korkunç. Sen || aynı hattaki iki şey için; Bu, kodunuzdaki bir hatadır veya kodunuzu gizlemeye niyetlidir.

    return (   (   propVal.PropertyId == context.Definition.Id
                && !repo.ParentId.HasValue)
            || (   repo.ParentId == propVal.ParentId
                && (   (   propVal.SecondaryFilter.HasValue
                        && context.SecondaryFilter.HasValue 
                        && propVal.SecondaryFilter.Value == context.SecondaryFilter)
                    || (   !context.SecondaryFilter.HasValue
                        && !propVal.SecondaryFilter.HasValue))));

Bu, en azından yarı yarıya iyi biçimlendirilmiş (biçimlendirme karmaşıksa, bunun nedeni if-koşulunun karmaşık olmasından kaynaklanmaktadır) ve en azından içerisindeki herhangi bir şeyin saçma olup olmadığını anlama şansınız var. Biçimlendirilmiş çöplerinizle karşılaştırıldığında, başka bir şey daha iyi. Ancak, sadece aşırılıkları yapabiliyor gibi görünüyorsunuz: Ya bir if ifadesinin karışıklığı ya da dört tamamen anlamsız yöntem.

Unutmayın (cond1 && cond2) || (! cond1 && cond3) olarak yazılabilir

cond1 ? cond2 : cond3

bu karışıklığı azaltacaktır. Yazardım

if (propVal.PropertyId == context.Definition.Id && !repo.ParentId.HasValue) {
    return true;
} else if (repo.ParentId != propVal.ParentId) {
    return false;
} else if (propVal.SecondaryFilter.HasValue) {
    return (   context.SecondaryFilter.HasValue
            && propVal.SecondaryFilter.Value == context.SecondaryFilter); 
} else {
    return !context.SecondaryFilter.HasValue;
}

Bu iki çözümden de hoşlanmıyorum, ikisi de mantıklı gelmeleri zor ve okunması zor. Sadece küçük yöntemler için küçük yöntemlere soyutlama yapmak her zaman sorunu çözmez.

İdeal olarak, özellikleri metaprogrmatik olarak karşılaştıracağınızı düşünüyorum, bu nedenle yeni bir özellik tanımlamıyorsunuz veya her yeni özellik kümesini karşılaştırmak istediğinizde dallanıyorsanız.

C # hakkında emin değilim, ancak javascript içinde böyle bir şey çok daha iyi olurdu ve en azından MatchesDefinitionId ve MatchesParentId yerine

function compareContextProp(obj, property, value){
  if(obj[property])
    return obj[property] == value
  return false
}