Birden fazla anahtar durumlu bir uygulama nasıl yeniden düzenlenir?

Ben girdi olarak bir tamsayı alır ve girişe dayalı farklı sınıfların statik yöntemleri çağırır bir uygulama var. Her yeni sayı eklendiğinde, başka bir vaka eklememiz ve farklı bir sınıfın farklı bir statik yöntemini çağırmamız gerekir. Artık anahtarda 50 kasa var ve her seferinde başka bir kasa eklemem gerektiğinde ürperiyorum. Bunu yapmanın daha iyi bir yolu var mı?

Biraz düşündüm ve bu fikri buldum. Strateji modelini kullanıyorum. Bir anahtar durumu yerine, anahtar girdi tamsayı olan strateji nesneleri bir harita var. Yöntem çağrıldıktan sonra, nesneyi arar ve nesne için genel yöntemi çağırır. Bu şekilde anahtar kutusu yapısını kullanmaktan kaçınabilirim.

Ne düşünüyorsun?

Artık anahtarda 50 kasa var ve her seferinde başka bir kasa eklemem gerektiğinde ürperiyorum.

Ben polimorfizmi seviyorum. SOLID'i seviyorum. Saf nesne yönelimli programlamayı seviyorum. Bunların kötü bir temsilci olduğunu görmekten nefret ediyorum çünkü dogmatik olarak başvuruyorlar.

Stratejiyi yeniden düzenlemek için iyi bir örnek vermediniz. Yeniden düzenleme işleminin bu arada bir adı vardır. Buna Koşulluları Polimorfizmle Değiştir denir .

C2.com'dan sizin için uygun bir tavsiye buldum :

Sadece aynı veya çok benzer koşullu testlerin sık sık tekrarlanması gerçekten mantıklıdır. Basit, nadiren tekrarlanan testler için, basit bir koşulu birden çok sınıf tanımının ayrıntılarıyla değiştirmek ve büyük olasılıkla bunları aslında şartlı olarak gerekli aktiviteyi gerektiren koddan uzağa taşımak, kod kitaplığının bir ders kitabı örneğiyle sonuçlanacaktır. Dogmatik saflığa göre netliği tercih edin. - DanMuller

50 kasalı bir anahtarınız var ve alternatifiniz 50 nesne üretmektir. Oh ve 50 satır nesne inşaat kodu. Bu ilerleme değil. Neden olmasın? Çünkü bu yeniden düzenleme sayı 50'den düşürmek için hiçbir şey yapmaz. Bu yeniden düzenleme kullanarak başka bir yerde aynı girdi üzerinde başka bir anahtar deyimi oluşturmanız gerekir. İşte bu yeniden düzenleme, 100'ü 50'ye çevirdiği için yardımcı oluyor.

Sahip olduğunuz tek anahtar gibi "anahtara" atıfta bulunduğunuz sürece bunu önermiyorum. Şimdi yeniden düzenleme yapmanın tek avantajı, bazı goofball'un 50 kasa anahtarınızı kopyalayıp yapıştırma şansını azaltmasıdır.

Önerdiğim, bu 50 vakayı, çarpanlarına ayrılabilecek ortaklıklar açısından yakından incelemek. Yani 50 mi? Gerçekten mi? Bu kadar çok davaya ihtiyacınız olduğundan emin misiniz? Burada çok şey yapmaya çalışıyor olabilirsiniz.

Kodunuzun bazı işlevlerinde başlatılan ve aşağıdaki gibi birkaç kod satırına sahip olduğunuz strateji nesnelerinin tek başına haritası

     myMap.Add(1,new Strategy1());
     myMap.Add(2,new Strategy2());
     myMap.Add(3,new Strategy3());

siz ve meslektaşlarınızın ayrı sınıflarda çağrılacak işlevleri / stratejileri daha düzenli bir şekilde uygulamalarını gerektirir (çünkü strateji nesnelerinizin aynı arabirimi uygulaması gerekir). Bu kod genellikle biraz daha kapsamlıdır.

     case 1:
          MyClass1.Doit1(someParameters);
          break;
     case 2:
          MyClass2.Doit2(someParameters);
          break;
     case 3:
          MyClass3.Doit3(someParameters);
          break;

Ancak, yeni bir numara eklenmesi gerektiğinde sizi bu kod dosyasını düzenleme yükünden kurtarmaz. Bu yaklaşımın gerçek faydaları farklıdır:

• Haritanın başlatma şimdi aslında gönderme kodu ayrılmış olur çağıran belirli bir sayıya bağlı fonksiyon ve ikincisi yok değil artık bu 50 tekrara içerirler, bu sadece benzeyecek myMap[number].DoIt(someParameters). Bu nedenle, yeni bir numara geldiğinde bu dağıtım koduna dokunulmasına gerek yoktur ve Açık-Kapalı prensibine göre uygulanabilir. Dahası, dağıtım kodunun kendisini genişletmeniz gereken gereksinimler olduğunda, artık 50 yeri değiştirmek zorunda kalmayacaksınız, sadece bir tanesini değiştirmek zorunda kalacaksınız.

• haritanın içeriği çalışma zamanında belirlenir (anahtar yapısının içeriği derleme saatinden önce belirlenirken), bu size başlatma mantığını daha esnek veya genişletilebilir yapma fırsatı verir.

Yani evet, bazı faydaları var ve bu kesinlikle daha fazla SOLID koduna doğru bir adım. Ancak, refactor'a ödüyorsa, sizin veya ekibinizin kendi başına karar vermesi gereken bir şeydir. Gönderim kodunun değiştirilmesini beklemiyorsanız, başlatma mantığının değiştirilmesini ve okunabilirliğinin switchgerçek bir sorun olmadığını düşünüyorsanız, yeniden düzenleme işleminiz o kadar önemli olmayabilir.

@DocBrown'un cevabında ana hatlarıyla verilen strateji lehine çok iyiyim .

Cevaba bir iyileştirme önereceğim.

Aramalar

 myMap.Add(1,new Strategy1());
 myMap.Add(2,new Strategy2());
 myMap.Add(3,new Strategy3());

dağıtılabilir. Açık-Kapalı prensibine daha iyi uyan başka bir strateji eklemek için aynı dosyaya geri dönmek zorunda değilsiniz.

Strategy1Strategy1.cpp dosyasında uyguladığınızı varsayalım. İçinde aşağıdaki kod bloğuna sahip olabilirsiniz.

namespace Strategy1_Impl
{
   struct Initializer
   {
      Initializer()
      {
         getMap().Add(1, new Strategy1());
      }
   };
}
using namespace Strategy1_Impl;

static Initializer initializer;

Her StategyN.cpp dosyasında aynı kodu tekrarlayabilirsiniz. Gördüğünüz gibi, bu tekrarlanan kod çok olacak. Kod çoğaltmayı azaltmak için, tüm Strategysınıfların erişebileceği bir dosyaya yerleştirilebilecek bir şablon kullanabilirsiniz .

namespace StrategyHelper
{
   template <int N, typename StrategyType> struct Initializer
   {
      Initializer()
      {
         getMap().Add(N, new StrategyType());
      }
   };
}

Bundan sonra, Strategy1.cpp'de kullanmanız gereken tek şey:

static StrategyHelper::Initializer<1, Strategy1> initializer;

StrategyN.cpp dosyasında ilgili satır:

static StrategyHelper::Initializer<N, StrategyN> initializer;

Somut Strateji sınıfları için bir sınıf şablonu kullanarak şablonların kullanımını başka bir seviyeye taşıyabilirsiniz.

class Strategy { ... };

template <int N> class ConcreteStrategy;

Ve sonra, yerine Strategy1kullanın ConcreteStrategy<1>.

template <> class ConcreteStrategy<1> : public Strategy { ... };

S'yi kaydetmek için yardımcı sınıfı değiştirin Strategy:

namespace StrategyHelper
{
   template <int N> struct Initializer
   {
      Initializer()
      {
         getMap().Add(N, new ConcreteStrategy<N>());
      }
   };
}

Strateg1.cpp içindeki kodu şu şekilde değiştirin:

static StrategyHelper::Initializer<1> initializer;

StrategN.cpp'deki kodu şu şekilde değiştirin:

static StrategyHelper::Initializer<N> initializer;