API tasarımında “çok fazla parametre” sorunu nasıl önlenir?

Bu API işlevi var:

public ResultEnum DoSomeAction(string a, string b, DateTime c, OtherEnum d, 
     string e, string f, out Guid code)

Sevmiyorum. Çünkü parametre sırası gereksiz yere önemli hale gelir. Yeni alanlar eklemek zorlaşıyor. Nelerin geçtiğini görmek daha zor. Alt fonksiyonlardaki tüm parametreleri geçirmenin başka bir yükünü oluşturduğu için yöntemi daha küçük parçalara yeniden düzenlemek daha zordur. Kodun okunması daha zordur.

En açık fikirle geldim: verileri çevreleyen bir nesne var ve her parametreyi tek tek geçmek yerine onu iletiyor. İşte ben geldim:

public class DoSomeActionParameters
{
    public string A;
    public string B;
    public DateTime C;
    public OtherEnum D;
    public string E;
    public string F;        
}

Bu, API beyanımı şu şekilde düşürdü:

public ResultEnum DoSomeAction(DoSomeActionParameters parameters, out Guid code)

Güzel. Çok masum görünüyor ama aslında büyük bir değişiklik getirdik: değişebilirlik getirdik. Çünkü daha önce yaptığımız şey aslında anonim değişmez bir nesneyi geçmekti: yığın üzerindeki fonksiyon parametreleri. Şimdi çok değişebilen yeni bir sınıf yarattık. Arayanın durumunu değiştirme yeteneğini yarattık . Bu berbat. Şimdi nesnemin değişmez olmasını istiyorum, ne yapmalıyım?

public class DoSomeActionParameters
{
    public string A { get; private set; }
    public string B { get; private set; }
    public DateTime C { get; private set; }
    public OtherEnum D { get; private set; }
    public string E { get; private set; }
    public string F { get; private set; }        

    public DoSomeActionParameters(string a, string b, DateTime c, OtherEnum d, 
     string e, string f)
    {
        this.A = a;
        this.B = b;
        // ... tears erased the text here
    }
}

Gördüğünüz gibi aslında asıl sorunumu yeniden yarattım: çok fazla parametre. Bu yolun gitmediği açık. Ne ben yapacağım? Böyle bir değişmezliği elde etmek için son seçenek şöyle bir "salt okunur" yapı kullanmaktır:

public struct DoSomeActionParameters
{
    public readonly string A;
    public readonly string B;
    public readonly DateTime C;
    public readonly OtherEnum D;
    public readonly string E;
    public readonly string F;        
}

Bu, çok fazla parametreye sahip yapıcılardan kaçınmamıza ve değişmezliğe ulaşmamıza izin verir. Aslında tüm sorunları düzeltir (parametre sıralaması vb.). Hala:

• Herkes (FXCop ve Jon Skeet dahil) kamuya açık alanların ifşa edilmesinin kötü olduğunu kabul eder .
• Eric Lippert ve arkadaşları değişmezlik için salt okunur alanlara güvenmenin bir yalan olduğunu söylüyor .

İşte o zaman kafam karıştı ve bu soruyu yazmaya karar verdi: C # 'de değişebilirliğe neden olmadan "çok fazla parametre" probleminden kaçınmanın en kolay yolu nedir? Bu amaç için salt okunur bir yapı kullanmak, ancak yine de kötü bir API tasarımına sahip olmak mümkün müdür?

AÇIKLAMALAR:

• Tek bir sorumluluk ilkesinin ihlal edilmediğini varsayalım. Orijinal durumumda, fonksiyon sadece verilen parametreleri tek bir DB kaydına yazar.
• Verilen işleve özel bir çözüm aramıyorum. Bu tür sorunlara genel bir yaklaşım arıyorum. Ben özellikle değişebilirlik ya da korkunç bir tasarım getirmeden "çok fazla parametre" sorunu çözmek ilgilendi.

GÜNCELLEME

Burada verilen cevapların farklı avantajları / dezavantajları vardır. Bu yüzden bunu bir topluluk wikisine dönüştürmek istiyorum. Ben kod örneği ve Artıları / Eksileri ile her cevap gelecekte benzer sorunlar için iyi bir rehber olacağını düşünüyorum. Şimdi nasıl yapılacağını öğrenmeye çalışıyorum.

Çerçevelerde kucaklanan bir stil genellikle ilgili parametreleri ilgili sınıflara gruplamak gibidir (ancak yine de değişebilirlikle sorunludur):

var request = new HttpWebRequest(a, b);
var service = new RestService(request, c, d, e);
var client = new RestClient(service, f, g);
var resource = client.RequestRestResource(); // O params after 3 objects

Oluşturucu ve alana özgü dil stili API'sı - Akıcı Arayüz kombinasyonunu kullanın. API biraz daha ayrıntılıdır, ancak intellisense ile yazılması çok hızlı ve anlaşılması kolaydır.

public class Param
{
        public string A { get; private set; }
        public string B { get; private set; }
        public string C { get; private set; }


  public class Builder
  {
        private string a;
        private string b;
        private string c;

        public Builder WithA(string value)
        {
              a = value;
              return this;
        }

        public Builder WithB(string value)
        {
              b = value;
              return this;
        }

        public Builder WithC(string value)
        {
              c = value;
              return this;
        }

        public Param Build()
        {
              return new Param { A = a, B = b, C = c };
        }
  }


  DoSomeAction(new Param.Builder()
        .WithA("a")
        .WithB("b")
        .WithC("c")
        .Build());

Sahip olduğunuz şey, söz konusu sınıfın Tek Sorumluluk İlkesini ihlal ettiğinden oldukça emin bir gösterge çünkü çok fazla bağımlılığı var. Bu bağımlılıkları Cephe Bağımlılıkları kümelerine yeniden yansıtmanın yollarını arayın .

Sadece bir adresinin parametre veri yapısını değiştirmek classbir etmek structve sen iyi gitmek.

public struct DoSomeActionParameters 
{
   public string A;
   public string B;
   public DateTime C;
   public OtherEnum D;
   public string E;
   public string F;
}

public ResultEnum DoSomeAction(DoSomeActionParameters parameters, out Guid code) 

Yöntem şimdi yapının kendi kopyasını alacaktır. Değişken değişkeninde yapılan değişiklikler yöntem tarafından gözlenemez ve yöntemde değişken üzerinde yapılan değişiklikler arayan tarafından gözlenemez. İzolasyon değişmezlik olmadan sağlanır.

Artıları:

• Uygulaması en kolay
• Altta yatan mekanikte en az davranış değişikliği

Eksileri:

• Değişmezlik açık değildir, geliştiricinin dikkatini gerektirir.
• Değişmezliği korumak için gereksiz kopyalama
• Yığın alanı kaplar

Veri sınıfınızda bir oluşturucu sınıfı oluşturmaya ne dersiniz. Veri sınıfı tüm ayarlayıcılara özel olarak sahip olacak ve sadece üretici bunları ayarlayabilecektir.

public class DoSomeActionParameters
    {
        public string A { get; private set; }
        public string B  { get; private set; }
        public DateTime C { get; private set; }
        public OtherEnum D  { get; private set; }
        public string E  { get; private set; }
        public string F  { get; private set; }

        public class Builder
        {
            DoSomeActionParameters obj = new DoSomeActionParameters();

            public string A
            {
                set { obj.A = value; }
            }
            public string B
            {
                set { obj.B = value; }
            }
            public DateTime C
            {
                set { obj.C = value; }
            }
            public OtherEnum D
            {
                set { obj.D = value; }
            }
            public string E
            {
                set { obj.E = value; }
            }
            public string F
            {
                set { obj.F = value; }
            }

            public DoSomeActionParameters Build()
            {
                return obj;
            }
        }
    }

    public class Example
    {

        private void DoSth()
        {
            var data = new DoSomeActionParameters.Builder()
            {
                A = "",
                B = "",
                C = DateTime.Now,
                D = testc,
                E = "",
                F = ""
            }.Build();
        }
    }

Ben bir C # programcısı değilim ama C # adlı bağımsız değişkenleri desteklediğine inanıyorum: (F # yapar ve C # büyük ölçüde bu tür bir şey için uyumlu özelliktir) Yapar: http://msdn.microsoft.com/tr-tr/library/dd264739 .aspx # Y342

Böylece orijinal kodunuzu aramak:

public ResultEnum DoSomeAction( 
 e:"bar", 
 a: "foo", 
 c: today(), 
 b:"sad", 
 d: Red,
 f:"penguins")

bu daha fazla alan / düşünce gerektirmez ve caydırıcı sistemde olup bitenleri hiç değiştirmediğiniz gerçeğinin tüm faydalarına sahiptir. Bağımsız değişkenlerin adlandırıldığını belirtmek için hiçbir şeyi yeniden kodlamanız gerekmez

Düzenleme: işte bu konuda bulduğum bir makale. http://www.globalnerdy.com/2009/03/12/default-and-named-parameters-in-c-40-sith-lord-in-training/ C # 4.0 destekli argümanlardan bahsetmeliyim, 3.0

Neden sadece değişmezliği zorlayan bir arayüz oluşturmuyoruz (yani sadece alıcılar)?

Temelde ilk çözümünüzdür, ancak parametreye erişmek için işlevi arabirimi kullanmaya zorlarsınız.

public interface IDoSomeActionParameters
{
    string A { get; }
    string B { get; }
    DateTime C { get; }
    OtherEnum D { get; }
    string E { get; }
    string F { get; }              
}

public class DoSomeActionParameters: IDoSomeActionParameters
{
    public string A { get; set; }
    public string B { get; set; }
    public DateTime C { get; set; }
    public OtherEnum D { get; set; }
    public string E { get; set; }
    public string F { get; set; }        
}

ve işlev bildirimi şöyle olur:

public ResultEnum DoSomeAction(IDoSomeActionParameters parameters, out Guid code)

Artıları:

• structÇözüm gibi yığın alanı sorunu yok
• Dil semantiği kullanarak doğal çözüm
• Değişmezlik açıktır
• Esnek (tüketici isterse farklı bir sınıf kullanabilir)

Eksileri:

• Bazı tekrarlanan çalışmalar (iki farklı kuruluşta aynı beyanlar)
• Geliştirici DoSomeActionParametersbunun eşleştirilebilecek bir sınıf olduğunu tahmin etmelidirIDoSomeActionParameters

Bunun eski bir soru olduğunu biliyorum ama aynı problemi çözmek zorunda kaldığım için önerimden vazgeçeceğimi düşündüm. Kuşkusuz, benim sorunum sizinkinden biraz farklıydı, çünkü kullanıcıların bu nesneyi kendileri inşa etmelerini istememe ek gereksinimim vardı (verilerin tüm hidrasyonu veritabanından geldi, böylece tüm inşaatları dahili olarak hapse atabilirim). Bu, özel bir kurucu ve aşağıdaki modeli kullanmama izin verdi;

    public class ExampleClass
    {
        //create properties like this...
        private readonly int _exampleProperty;
        public int ExampleProperty { get { return _exampleProperty; } }

        //Private constructor, prohibiting construction outside of this class
        private ExampleClass(ExampleClassParams parameters)
        {                
            _exampleProperty = parameters.ExampleProperty;
            //and so on... 
        }

        //The object returned from here will be immutable
        public ExampleClass GetFromDatabase(DBConnection conn, int id)
        {
            //do database stuff here (ommitted from example)
            ExampleClassParams parameters = new ExampleClassParams()
            {
                ExampleProperty = 1,
                ExampleProperty2 = 2
            };

            //Danger here as parameters object is mutable

            return new ExampleClass(parameters);    

            //Danger is now over ;)
        }

        //Private struct representing the parameters, nested within class that uses it.
        //This is mutable, but the fact that it is private means that all potential 
        //"damage" is limited to this class only.
        private struct ExampleClassParams
        {
            public int ExampleProperty { get; set; }
            public int AnotherExampleProperty { get; set; }
            public int ExampleProperty2 { get; set; }
            public int AnotherExampleProperty2 { get; set; }
            public int ExampleProperty3 { get; set; }
            public int AnotherExampleProperty3 { get; set; }
            public int ExampleProperty4 { get; set; }
            public int AnotherExampleProperty4 { get; set; } 
        }
    }

Oluşturucu tarzı bir yaklaşım kullanabilirsiniz, ancak DoSomeActionyönteminizin karmaşıklığına bağlı olarak , bu dokunuş ağır olabilir. Bu çizgiler boyunca bir şey:

public class DoSomeActionParametersBuilder
{
    public string A { get; set; }
    public string B { get; set; }
    public DateTime C { get; set; }
    public OtherEnum D { get; set; }
    public string E { get; set; }
    public string F { get; set; }

    public DoSomeActionParameters Build()
    {
        return new DoSomeActionParameters(A, B, C, D, E, F);
    }
}

public class DoSomeActionParameters
{
    public string A { get; private set; }
    public string B { get; private set; }
    public DateTime C { get; private set; }
    public OtherEnum D { get; private set; }
    public string E { get; private set; }
    public string F { get; private set; }

    public DoSomeActionParameters(string a, string b, DateTime c, OtherEnum d, string e, string f)
    {
        A = a;
        // etc.
    }
}

// usage
var actionParams = new DoSomeActionParametersBuilder
{
    A = "value for A",
    C = DateTime.Now,
    F = "I don't care for B, D and E"
}.Build();

result = foo.DoSomeAction(actionParams, out code);

Manji cevabına ek olarak - bir operasyonu birkaç küçük operasyona bölmek de isteyebilirsiniz. Karşılaştırmak:

 BOOL WINAPI CreateProcess(
   __in_opt     LPCTSTR lpApplicationName,
   __inout_opt  LPTSTR lpCommandLine,
   __in_opt     LPSECURITY_ATTRIBUTES lpProcessAttributes,
   __in_opt     LPSECURITY_ATTRIBUTES lpThreadAttributes,
   __in         BOOL bInheritHandles,
   __in         DWORD dwCreationFlags,
   __in_opt     LPVOID lpEnvironment,
   __in_opt     LPCTSTR lpCurrentDirectory,
   __in         LPSTARTUPINFO lpStartupInfo,
   __out        LPPROCESS_INFORMATION lpProcessInformation
 );

ve

 pid_t fork()
 int execvpe(const char *file, char *const argv[], char *const envp[])
 ...

POSIX bilmeyenler için çocuğun yaratılması şu kadar kolay olabilir:

pid_t child = fork();
if (child == 0) {
    execl("/bin/echo", "Hello world from child", NULL);
} else if (child != 0) {
    handle_error();
}

Her tasarım seçeneği, hangi işlemleri yapabileceği konusunda ödünleşimi temsil eder.

PS. Evet - inşaatçıya benzer - sadece ters (yani arayan yerine callee tarafında). Bu özel durumda yapıcıdan daha iyi olabilir veya olmayabilir.

burada Mikeys'den biraz farklı bir şey ama yapmaya çalıştığım her şeyi mümkün olduğunca az yazmak

public class DoSomeActionParameters
{
    readonly string _a;
    readonly int _b;

    public string A { get { return _a; } }

    public int B{ get { return _b; } }

    DoSomeActionParameters(Initializer data)
    {
        _a = data.A;
        _b = data.B;
    }

    public class Initializer
    {
        public Initializer()
        {
            A = "(unknown)";
            B = 88;
        }

        public string A { get; set; }
        public int B { get; set; }

        public DoSomeActionParameters Create()
        {
            return new DoSomeActionParameters(this);
        }
    }
}

DoSomeActionParameters olabildiğince değişmez ve varsayılan kurucusu özel olduğu için doğrudan oluşturulamaz

Başlatıcı değişmez değil, sadece bir aktarımdır

Kullanım, Başlatıcıdaki başlatıcıdan yararlanır (sapmamı alırsanız) ve Başlatıcı varsayılan yapıcısında varsayılanlara sahip olabilirim

DoSomeAction(new DoSomeActionParameters.Initializer
            {
                A = "Hello",
                B = 42
            }
            .Create());

Parametreler burada isteğe bağlı olacaktır, eğer bazılarının gerekli olmasını istiyorsanız bunları Initializer varsayılan yapıcısına koyabilirsiniz

Ve doğrulama Oluştur yöntemine girebilir

public class Initializer
{
    public Initializer(int b)
    {
        A = "(unknown)";
        B = b;
    }

    public string A { get; set; }
    public int B { get; private set; }

    public DoSomeActionParameters Create()
    {
        if (B < 50) throw new ArgumentOutOfRangeException("B");

        return new DoSomeActionParameters(this);
    }
}

Şimdi öyle görünüyor

DoSomeAction(new DoSomeActionParameters.Initializer
            (b: 42)
            {
                A = "Hello"
            }
            .Create());

Hala biraz kooki biliyorum, ama yine de deneyeceğim

Düzenleme: create yöntemini parametreler nesnesindeki bir statik haline taşımak ve başlatıcıyı geçen bir temsilci eklemek, bazı cookieness çağrıdan çıkarır

public class DoSomeActionParameters
{
    readonly string _a;
    readonly int _b;

    public string A { get { return _a; } }
    public int B{ get { return _b; } }

    DoSomeActionParameters(Initializer data)
    {
        _a = data.A;
        _b = data.B;
    }

    public class Initializer
    {
        public Initializer()
        {
            A = "(unknown)";
            B = 88;
        }

        public string A { get; set; }
        public int B { get; set; }
    }

    public static DoSomeActionParameters Create(Action<Initializer> assign)
    {
        var i = new Initializer();
        assign(i)

        return new DoSomeActionParameters(i);
    }
}

Yani çağrı şimdi böyle görünüyor

DoSomeAction(
        DoSomeActionParameters.Create(
            i => {
                i.A = "Hello";
            })
        );

Yapıyı kullanın, ancak ortak alanlar yerine ortak mülklere sahip olun:

• Herkes (FXCop ve Jon Skeet dahil) kamuya açık alanların ifşa edilmesinin kötü olduğunu kabul eder.

Jon ve FXCop, alanları değil, özellikleri ortaya koyduğunuz için tatmin olacaktır.

• Eric Lippert ve arkadaşları değişmezlik için salt okunur alanlara güvenmenin bir yalan olduğunu söylüyor.

Eric, satisifed edilecektir çünkü özellikleri kullanarak, değerin sadece bir kez ayarlanmasını sağlayabilirsiniz.

    private bool propC_set=false;
    private date pC;
    public date C {
        get{
            return pC;
        }
        set{
            if (!propC_set) {
               pC = value;
            }
            propC_set = true;
        }
    }

Bir yarı değişmez nesne (değer ayarlanabilir ancak değiştirilemez). Değer ve Referans türleri için çalışır.

Samuel'in aynı problemi yaşadığımda projemde kullandığım cevabının bir çeşidi :

class MagicPerformer
{
    public int Param1 { get; set; }
    public string Param2 { get; set; }
    public DateTime Param3 { get; set; }

    public MagicPerformer SetParam1(int value) { this.Param1 = value; return this; }
    public MagicPerformer SetParam2(string value) { this.Param2 = value; return this; }
    public MagicPerformer SetParam4(DateTime value) { this.Param3 = value; return this; }

    public void DoMagic() // Uses all the parameters and does the magic
    {
    }
}

Ve kullanmak için:

new MagicPerformer().SeParam1(10).SetParam2("Yo!").DoMagic();

Benim durumumda parametreler kasıtlı olarak değiştirilebilirdi, çünkü ayarlayıcı yöntemler olası tüm kombinasyonlara izin vermedi ve sadece bunların ortak kombinasyonlarını ortaya çıkardı. Çünkü parametrelerimin bazıları oldukça karmaşıktı ve olası tüm durumlar için yazma yöntemleri zor ve gereksiz olurdu (çılgın kombinasyonlar nadiren kullanılır).