'Git' voodoo kaçınarak?

switchEle alması gereken birkaç durumu olan bir yapıya sahibim . switchAşırı faaliyet enumkombine değerler aracılığıyla yinelenen kod sorunu teşkil hangi:

// All possible combinations of One - Eight.
public enum ExampleEnum {
    One,
    Two, TwoOne,
    Three, ThreeOne, ThreeTwo, ThreeOneTwo,
    Four, FourOne, FourTwo, FourThree, FourOneTwo, FourOneThree,
          FourTwoThree, FourOneTwoThree
    // ETC.
}

Şu anda switchyapı, her bir değeri ayrı ayrı ele almaktadır:

// All possible combinations of One - Eight.
switch (enumValue) {
    case One: DrawOne; break;
    case Two: DrawTwo; break;
    case TwoOne:
        DrawOne;
        DrawTwo;
        break;
     case Three: DrawThree; break;
     ...
}

Oradaki fikri anladın. Şu anda ifbunun tek bir satırla kombinasyonları işlemek için yığılmış bir yapıya dönüştürdüm :

// All possible combinations of One - Eight.
if (One || TwoOne || ThreeOne || ThreeOneTwo)
    DrawOne;
if (Two || TwoOne || ThreeTwo || ThreeOneTwo)
    DrawTwo;
if (Three || ThreeOne || ThreeTwo || ThreeOneTwo)
    DrawThree;

Bu, okumak için kafa karıştırıcı ve bakımı zor olan inanılmaz derecede uzun mantıksal değerlendirme sorununu ortaya koymaktadır. Bunu tekrar gözden geçirdikten sonra, alternatifler hakkında düşünmeye başladım, switchdavalar arasında ters düşecek bir yapı fikrini düşündüm .

Bir gotoolayı kullanmak zorundayım çünkü C#düşmeye izin vermiyor. Bununla birlikte, switchyapı içinde atlamasına rağmen inanılmaz derecede uzun mantık zincirlerini önler ve hala kod çoğaltması getirir.

switch (enumVal) {
    case ThreeOneTwo: DrawThree; goto case TwoOne;
    case ThreeTwo: DrawThree; goto case Two;
    case ThreeOne: DrawThree; goto default;
    case TwoOne: DrawTwo; goto default;
    case Two: DrawTwo; break;
    default: DrawOne; break;
}

Bu hala yeterince temiz bir çözüm değil ve gotokaçınmak istediğim anahtar kelimeyle ilişkili bir damgalama var . Eminim bunu temizlemenin daha iyi bir yolu olmalı.

Benim sorum

Okunabilirliği ve bakımını etkilemeden bu özel durumu ele almanın daha iyi bir yolu var mı?

Kodları gotoifadelerle okumayı zor buluyorum . enumFarklı bir şekilde yapılandırmanızı tavsiye ederim . Örneğin, enumher bir bitin seçeneklerden birini temsil ettiği bir bit alanıysa, şöyle görünebilir:

[Flags]
public enum ExampleEnum {
    One = 0b0001,
    Two = 0b0010,
    Three = 0b0100
};

Flags özelliği, derleyiciye, örtüşmeyen değerleri ayarladığınızı söyler. Bu kodu çağıran kod uygun biti ayarlayabilir. Daha sonra neler olduğunu netleştirmek için böyle bir şey yapabilirsiniz:

if (myEnum.HasFlag(ExampleEnum.One))
{
    CallOne();
}
if (myEnum.HasFlag(ExampleEnum.Two))
{
    CallTwo();
}
if (myEnum.HasFlag(ExampleEnum.Three))
{
    CallThree();
}

Bu myEnum, bit alanlarını düzgün bir şekilde ayarlamak ve Flags özniteliği ile işaretlemek için ayarlanan kodu gerektirir . Ancak, örneğin örneğindeki enums değerlerini şu şekilde değiştirerek yapabilirsiniz:

[Flags]
public enum ExampleEnum {
    One = 0b0001,
    Two = 0b0010,
    Three = 0b0100,
    OneAndTwo = One | Two,
    OneAndThree = One | Three,
    TwoAndThree = Two | Three
};

Formda bir sayı yazdığınızda 0bxxxx, onu ikili olarak belirtirsiniz. Böylece bit 1, 2 veya 3'ü ayarladığımızı görebilirsiniz (peki, teknik olarak 0, 1 veya 2, ama siz anlıyorsunuz). Kombinasyonları sık sık birlikte ayarlayabilirseniz, kombinasyonları bit yönünde VEYA kullanarak da adlandırabilirsiniz.

IMO, sorunun kökü bu kod parçasının bile olmaması gerektiğidir.

Görünüşe göre üç bağımsız koşul ve bu şartlar doğruysa yapmanız gereken üç bağımsız eyleminiz var. Öyleyse tüm bunlar, ne yapmaları gerektiğini söylemek için üç Boole bayrağı gerektiren tek bir kod parçasına dönüştürülüyor (bunları bir enum'a karıştırıp karıştırmamayacağınız) ve sonra üç bağımsız şeyin bir kombinasyonunu yapıyor? Tek sorumluluk ilkesi burada izinsiz gün geçirmiş gibi görünüyor.

Çağrıları ait olduğu üç işleve (örneğin, eylemleri yapmanız gerektiğini keşfettiğiniz yere) koyun ve bu örneklerdeki kodu geri dönüşüm kutusuna gönderin.

Üç bayrak olmayan ve üç bayrak olsaydı, 1024 farklı kombinasyonu işlemek için bu tür bir kodu genişletir miydiniz? Umarım değildir! 1024 çok fazla ise, aynı nedenle, 8 de çok fazladır.

Hiçbir zaman gotos kullanmak biridir "çocuklara yalan" bilgisayar biliminin kavramları. Bu, zamanın% 99'unun doğru tavsiyesidir ve çok nadir görülmediği ve yeni kodlayıcılara "kullanmayın" olarak açıklanması halinde herkes için çok daha iyi olması konusunda uzmanlaşmıştır.

Yani ne zaman gerektiğini , kullanılmadan? Orada birkaç senaryo , ancak isabet gibi görünüyor temel biridir: Eğer bir devlet makinesini kodlarken . Algoritmanızın bir durum makinesinden daha iyi organize ve yapılandırılmış bir ifadesi yoksa, koddaki doğal ifadesi yapılandırılmamış dalları içerir ve bunun yapısını tartışmasız bir şekilde yapamayan bir şey yapılabilecek çok şey yoktur. devlet makinesinin kendisi daha az değil, daha belirsizdir.

Derleyici yazarları bunu bilir, bu nedenle LALR ayrıştırıcılarını ^* uygulayan çoğu derleyicinin kaynak kodu gotos içerir. Bununla birlikte, çok az kişi, kendi sözcük analizcilerini ve ayrıştırıcılarını kodlayacaktır.

^{* - IIRC, LALL gramerlerini, tekrarlayan bir şekilde inişli çıkışlı olarak, masaları veya diğer yapılandırılmamış kontrol ifadelerini atlamaya başvurmadan uygulamak mümkündür.}

Şimdi sıradaki soru, "Bu örnek bu vakalardan biri mi?"

Baktığım şey şu ki, mevcut durumun işlenmesine bağlı olarak üç farklı olası sonraki durumunuz var. Bunlardan biri ("varsayılan") yalnızca bir kod satırı olduğundan, teknik olarak geçerli olduğu durumların sonunda bu kod satırına dokunarak ondan kurtulabilirsiniz. Bu sizi 2 muhtemel devlete indirger.

Kalanlardan biri ("Üç") yalnızca görebildiğim bir yerden dallanmış. Böylece ondan aynı şekilde kurtulabilirsin. Bu gibi görünen bir kod ile bitirdiniz:

switch (exampleValue) {
    case OneAndTwo: i += 3 break;
    case OneAndThree: i += 4 break;
    case Two: i += 2 break;
    case TwoAndThree: i += 5 break;
    case Three: i += 3 break;
    default: i++ break;
}

Ancak, yine de verdiğiniz oyuncak bir örnekti. "Varsayılan" değerinin önemsiz miktarda bir kod içerdiği durumlarda, "üç" birden fazla devletten geçiyorsa veya (en önemlisi) daha fazla bakım yapılması devletleri eklemek veya karmaşık hale getirmek olasıdır , dürüst olmak gerekirse daha iyi durumda olursunuz. goto'ları kullanmak (ve belki de kalması gereken iyi bir neden olmadığı sürece, işlerin devlet makinesi doğasını gizleyen enum-case yapısından kurtulmak bile).

En iyi cevap, polimorfizm kullanmaktır .

IMO, if olayını daha net ve tartışmalı şekilde kısaltan bir cevap daha :

if (One || OneAndTwo || OneAndThree)
  CallOne();
if (Two || OneAndTwo || TwoAndThree)
  CallTwo();
if (Three || OneAndThree || TwoAndThree)
  CallThree();

goto Muhtemelen benim 58. seçimim ...

Neden bu değil:

public enum ExampleEnum {
    One = 0, // Why not?
    OneAndTwo,
    OneAndThree,
    Two,
    TwoAndThree,
    Three
}
int[] COUNTS = { 1, 3, 4, 2, 5, 3 }; // Whatever

int ComputeExampleValue(int i, ExampleEnum exampleValue) {
    return i + COUNTS[(int)exampleValue];
}

Tamam, katılıyorum, bu hackish (Ben bir C # geliştirici btw değilim, bu yüzden kod için özür dilerim), ama verimlilik açısından bu şart? Dizi dizini olarak enums kullanmak C # geçerlidir.

Bayrakları kullanmak istemiyorsanız veya istemiyorsanız, kuyruk özyinelemeli işlevi kullanın. 64bit sürüm modunda, derleyici ifadenize çok benzeyen bir kod üretecektir goto. Sadece onunla uğraşmak zorunda değilsin.

int ComputeExampleValue(int i, ExampleEnum exampleValue) {
    switch (exampleValue) {
        case One: return i + 1;
        case OneAndTwo: return ComputeExampleValue(i + 2, ExampleEnum.One);
        case OneAndThree: return ComputeExampleValue(i + 3, ExampleEnum.One);
        case Two: return i + 2;
        case TwoAndThree: return ComputeExampleValue(i + 2, ExampleEnum.Three);
        case Three: return i + 3;
   }
}

Kabul edilen çözüm gayet iyi ve sorununuz için somut bir çözüm. Ancak alternatif, daha soyut bir çözüm önermek istiyorum.

Tecrübelerime göre, mantık akışını tanımlamak için enums kullanımı, çoğu zaman zayıf sınıf tasarımının bir işareti olduğu için bir kod kokusudur.

Geçen yıl üzerinde çalıştığım kodda bunun gerçek dünya örneğiyle karşılaştım. Orijinal geliştirici hem ithalat hem de ihracat mantığı olan ve bir enuma göre ikisi arasında geçiş yapan tek bir sınıf yaratmıştı. Şimdi kod benzerdi ve çift kod vardı, ancak kodun okunması oldukça zor ve test edilmesi neredeyse imkansız hale gelmişti. Her ikisini de basitleştiren ve aslında rapor edilmemiş bazı hataları tespit etmeme ve ortadan kaldırmama izin veren iki ayrı sınıfa kadar yeniden düzenlemeye başladım.

Bir kez daha, mantık akışını kontrol etmek için enums kullanmanın genellikle bir tasarım problemi olduğunu belirtmeliyim. Genel durumda, Enums, olası değerlerin açıkça tanımlandığı tipte güvenli, tüketici dostu değerler sağlamak için kullanılmalıdır. Bir özellik olarak (örneğin, bir tablodaki sütun kimliği olarak) bir mantık kontrol mekanizmasından daha iyi kullanılırlar.

Soruda sunulan sorunu göz önüne alalım. Buradaki bağlamı veya bu numaralamanın neyi temsil ettiğini gerçekten bilmiyorum. Kart çekiyor mu? Resim çizme? Kan almak? Sipariş önemli mi? Ayrıca performansın ne kadar önemli olduğunu da bilmiyorum. Performans veya bellek kritikse, o zaman bu çözüm muhtemelen istediğin gibi olmayacak.

Her durumda, enum düşünelim:

// All possible combinations of One - Eight.
public enum ExampleEnum {
    One,
    Two,
    TwoOne,
    Three,
    ThreeOne,
    ThreeTwo,
    ThreeOneTwo
}

Burada sahip olduğumuz şey, farklı iş kavramlarını temsil eden birkaç farklı enum değeridir.

Bunun yerine kullanabileceğimiz şeyleri basitleştirmek için soyutlamalar.

Aşağıdaki arayüzü düşünelim:

public interface IExample
{
  void Draw();
}

Bunu daha sonra soyut bir sınıf olarak uygulayabiliriz:

public abstract class ExampleClassBase : IExample
{
  public abstract void Draw();
  // other common functionality defined here
}

Bir, iki ve üçlü Çizimleri temsil etmek için somut bir sınıfa sahip olabiliriz (argüman uğruna farklı mantıklara sahip). Bunlar potansiyel olarak yukarıda tanımlanan temel sınıfı kullanabilir, ancak DrawOne kavramının enum tarafından temsil edilen kavramdan farklı olduğunu kabul ediyorum:

public class DrawOne
{
  public void Draw()
  {
    // Drawing logic here
  }
}

public class DrawTwo
{
  public void Draw()
  {
    // Drawing two logic here
  }
}

public class DrawThree
{
  public void Draw()
  {
    // Drawing three logic here
  }
}

Ve şimdi, diğer sınıflara mantık sağlamak için oluşturulabilecek üç ayrı sınıfımız var.

public class One : ExampleClassBase
{
  private DrawOne drawOne;

  public One(DrawOne drawOne)
  {
    this.drawOne = drawOne;
  }

  public void Draw()
  {
    this.drawOne.Draw();
  }
}

public class TwoOne : ExampleClassBase
{
  private DrawOne drawOne;
  private DrawTwo drawTwo;

  public One(DrawOne drawOne, DrawTwo drawTwo)
  {
    this.drawOne = drawOne;
    this.drawTwo = drawTwo;
  }

  public void Draw()
  {
    this.drawOne.Draw();
    this.drawTwo.Draw();
  }
}

// the other six classes here

Bu yaklaşım çok daha ayrıntılı. Ancak avantajları var.

Bir hata içeren aşağıdaki sınıfı göz önünde bulundurun:

public class ThreeTwoOne : ExampleClassBase
{
  private DrawOne drawOne;
  private DrawTwo drawTwo;
  private DrawThree drawThree;

  public One(DrawOne drawOne, DrawTwo drawTwo, DrawThree drawThree)
  {
    this.drawOne = drawOne;
    this.drawTwo = drawTwo;
    this.drawThree = drawThree;
  }

  public void Draw()
  {
    this.drawOne.Draw();
    this.drawTwo.Draw();
  }
}

Eksik drawThree.Draw () çağrısını bulmak ne kadar basittir? Eğer sipariş önemliyse, beraberlik aramalarının sırasını görmek ve takip etmek de çok kolaydır.

Bu yaklaşımın dezavantajları:

• Sunulan sekiz seçeneğin her biri ayrı bir sınıf gerektiriyor
• Bu daha fazla bellek kullanacak
• Bu, kodunuzu yüzeysel olarak daha büyük hale getirir
• Bazen bu yaklaşım mümkün olmamakla birlikte, bazı değişiklikler olabilir

Bu yaklaşımın avantajları:

• Bu sınıfların her biri tamamen test edilebilir; Çünkü
• Beraberlik yöntemlerinin döngüsel karmaşıklığı düşüktür (ve teoride gerekirse, DrawOne, DrawTwo veya DrawThree sınıflarıyla alay edebilirim)
• Beraberlik yöntemleri anlaşılabilir - bir geliştirici, beynini, metodun ne yaptığını hesaplayan düğümlere bağlamak zorunda değildir.
• Hata bulmak kolay ve yazmak zor
• Sınıflar daha yüksek seviyeli sınıflar oluşturur, bu da ThreeThreeThree sınıfını tanımlamanın kolay olduğunu gösterir

Herhangi bir karmaşık mantık kontrol kodunun vaka ifadelerine yazılması gerektiğini hissettiğinizde bu (veya benzeri) bir yaklaşımı düşünün. Gelecek, yaptığın için mutlu olacaksın.

Burada bir anahtar kullanmaya niyetliysen, her durumu ayrı ayrı ele alırsan kodun daha hızlı olacak

switch(exampleValue)
{
    case One:
        i++;
        break;
    case Two:
        i += 2;
        break;
    case OneAndTwo:
    case Three:
        i+=3;
        break;
    case OneAndThree:
        i+=4;
        break;
    case TwoAndThree:
        i+=5;
        break;
}

her durumda sadece tek bir aritmetik işlem gerçekleştirilir

Ayrıca başkalarının da belirttiği gibi, eğer gotos kullanmayı düşünüyorsanız, muhtemelen algoritmanızı yeniden düşünmelisiniz (yine de C # 'ın vaka düşme eksikliğinin bir goto kullanmak için bir neden olabileceğini kabul ediyorum). Edgar Dijkstra'nın "Zararlı Olarak Kabul Edilen İfadesine Git" adlı ünlü makalesine bakın

Özel bir örneğiniz için, sayımdan gerçekten istediğiniz her şey, adımların her biri için yap / yapma göstergesi olmadığından, üç ifadenizi yeniden yazan çözüm, a'ya iftercih switchedilir ve kabul edilen cevabı vermeniz iyi olur. .

Eğer ki biraz daha karmaşık mantığı olsaydı Ama değil bu yüzden temiz çalışmak, o zaman yine bulabilir gotos switchdeyimi kafa karıştırıcı. Böyle bir şey görmeyi tercih ederim:

switch (enumVal) {
    case ThreeOneTwo: DrawThree; DrawTwo; DrawOne; break;
    case ThreeTwo:    DrawThree; DrawTwo; break;
    case ThreeOne:    DrawThree; DrawOne; break;
    case TwoOne:      DrawTwo; DrawOne; break;
    case Two:         DrawTwo; break;
    default:          DrawOne; break;
}

Bu mükemmel değil ama bence bu gotos'den daha iyi . Olayların dizileri o kadar uzunsa ve birbirlerini o kadar çoğaltırsa, her durum için tam diziyi hecelemenin bir anlamı olmazsa goto, kodun çoğaltılmasını azaltmak yerine bir alt yordamı tercih ederim .

Bugünlerde hiç kimsenin goto anahtar kelimesinden nefret etmek için bir nedeni olduğundan emin değilim. Kesinlikle arkaiktir ve kullanım durumlarının% 99'unda gerekli değildir, ancak bir nedenden dolayı dilin bir özelliğidir.

gotoAnahtar kelimeden nefret etmenin nedeni,

if (someCondition) {
    goto label;
}

string message = "Hello World!";

label:
Console.WriteLine(message);

Hata! Bu kesinlikle işe yaramayacak. messageDeğişken bu kod yolu tanımlı değil. Yani C # bunu geçemez. Ancak bu örtülü olabilir. Düşünmek

object.setMessage("Hello World!");

label:
object.display();

Ve displaysonra bunun içinde WriteLineifade olduğunu varsayalım .

Bu tür bir hatayı bulmak zor olabilir çünkü gotokod yolunu gizler.

Bu basitleştirilmiş bir örnek. Gerçek bir örneğin neredeyse kesin olmayacağını varsayalım. label:Ve kullanımı arasında elli kod satırı olabilir message.

Dil goto, sadece bloklardan inerek, nasıl kullanılabileceğini sınırlayarak bunu düzeltmeye yardımcı olabilir. Ancak C # goto, bununla sınırlı değildir. Kodun üstünden atlayabilir. Dahası, eğer sınırlayacaksanız goto, ismi değiştirmek de o kadar iyidir. Diğer diller break, sayıların (çıkacak blokların) veya bir etiketin (blokların birinde) bloklardan aşağıya inişlerinde kullanılır .

Kavramı gotodüşük seviyeli bir makine dili talimatıdır. Ancak, daha yüksek seviyeli dillere sahip olmamızın nedeni, değişken kapsam gibi daha yüksek seviyeli soyutlamalarla sınırlı olmamızdır.

Bütün bunlar, eğer durumdan diğerine atlamak için gotobir switchcümle içinde C # kullanıyorsanız , bu oldukça zararsızdır. Her dava zaten bir giriş noktasıdır. Daha tehlikeli formlarla gotobu zararsız kullanımını sınırladığı için, bu durumda onu aramanın aptalca olduğunu düşünüyorum goto. Bunun continueiçin böyle bir şey kullandıklarını tercih ederim. Fakat bazı nedenlerden dolayı, dili yazmadan önce bana sormayı unuttular.

Bu kadar çok seçeneğiniz olduğunda (ve dediğiniz gibi, daha fazlası), o zaman belki kod değil veridir.

Enum değerlerini eylemlerle eşleştiren, işlevler olarak veya eylemleri temsil eden basit bir enum türü olarak ifade edilen bir sözlük oluşturun. Ardından, kodunuz basit bir sözlük aramasına indirgenebilir, ardından işlev değeri aranır veya basitleştirilmiş seçimlerdeki bir anahtar kullanılır.

Bir döngü kullanın ve kesme ve devam etme arasındaki fark.

do {
  switch (exampleValue) {
    case OneAndTwo: i += 2; break;
    case OneAndThree: i += 3; break;
    case Two: i += 2; continue;
    case TwoAndThree: i += 2;
    // dropthrough
    case Three: i += 3; continue;
    default: break;
  }
  i++;
} while(0);