c# - पठनीयता को बनाए रखते हुए डुप्लिकेट कोड को हटाने के लिए मैं कई कंस्ट्रक्टर का उपयोग कैसे कर सकता हूं?




parameters constructor (2)

int a, b, c;

Constructor()
{
    a = 5;
    b = 10;
    c = 15;
    //do stuff
}
Constructor(int x, int y)
{
    a = x;
    b = y;
    c = 15;
    //do stuff
}
Constructor(int x, int y, int z)
{
    a = x;
    b = y;
    c = z;
    //do stuff
}

"सामान" और कुछ असाइनमेंट के दोहराव को रोकने के लिए, मैंने कुछ इस तरह की कोशिश की:

int a, b, c;

Constructor(): this(5, 10, 15)
{
}
Constructor(int x, int y): this(x, y, 15)
{
}
Constructor(int x, int y, int z)
{
    a = x;
    b = y;
    c = z;
    //do stuff
}

यह काम करता है कि मैं क्या करना चाहता हूं, लेकिन कभी-कभी मुझे नई वस्तुओं को बनाने या कुछ गणना करने के लिए कुछ लंबे कोड का उपयोग करने की आवश्यकता होती है:

int a, b, c;

Constructor(): this(new Something(new AnotherThing(param1, param2, param3),
    10, 15).CollectionOfStuff.Count, new SomethingElse("some string", "another
    string").GetValue(), (int)Math.Floor(533 / 39.384))
{
}
Constructor(int x, int y): this(x, y, (int)Math.Floor(533 / 39.384))
{
}
Constructor(int x, int y, int z)
{
    a = x;
    b = y;
    c = z;
    //do stuff
}

यह कोड पहले की तरह ही बहुत ज्यादा है, केवल जो पैरामीटर पास किए जा रहे हैं वे बहुत पठनीय नहीं हैं। मैं कुछ करना पसंद करूंगा:

int a, b, c;

Constructor(): this(x, y, z) //compile error, variables do not exist in context
{
    AnotherThing at = new AnotherThing(param1, param2, param3);
    Something st = new Something(aThing, 10, 15)
    SomethingElse ste = new SomethingElse("some string", "another string");

    int x = thing.CollectionOfStuff.Count;
    int y = ste.GetValue();
    int z = (int)Math.Floor(533 / 39.384);

    //In Java, I think you can call this(x, y, z) at this point.
    this(x, y, z); //compile error, method name expected
}
Constructor(int x, int y): this(x, y, z) //compile error
{
    int z = (int)Math.Floor(533 / 39.384);
}
Constructor(int x, int y, int z)
{
    a = x;
    b = y;
    c = z;
    //do stuff
}

मूल रूप से मैं कंस्ट्रक्टर बॉडी के भीतर मापदंडों का निर्माण कर रहा हूं। फिर मैं उन निर्मित मापदंडों को दूसरे कंस्ट्रक्टर को पास करने की कोशिश कर रहा हूं। मुझे लगता है कि मुझे याद है कि जावा में कोडिंग करते समय किसी अन्य कंस्ट्रक्टर के शरीर के अंदर कंस्ट्रक्टर को कॉल करने के लिए "यह" और "सुपर" कीवर्ड का उपयोग करने में सक्षम होना चाहिए। यह C # में संभव नहीं लगता है।

क्या आसानी से ऐसा करने का कोई तरीका है? क्या मैंने कुछ गलत किया? यदि यह संभव नहीं है, तो क्या मुझे बिना पढ़े कोड के साथ रहना चाहिए?

मुझे लगता है कि मैं हमेशा डुप्लिकेट किए गए कोड को पूरी तरह से कंस्ट्रक्टर्स के बाहर काट सकता हूं। फिर प्रत्येक कंस्ट्रक्टर बस अपनी बात करेगा और दूसरे कंस्ट्रक्टर्स द्वारा साझा किए गए कोड को कॉल करेगा।


तुम कर सकते हो

Constructor() : this(5, 10, 15)
{
}
Constructor(int x, int y) : this(x, y, 15)
{
}
Constructor(int x, int y, int z)
{
  int a = x;
  int b = y;
  int c = z;
  //do stuff
}

हालांकि अगर आपको मापदंडों के आधार पर कुछ फैंसी तर्क करने की आवश्यकता है, तो मैं एक कारखाने पैटर्न का उपयोग करूंगा:

public class myclass
{
  private myclass(int x, int y, int z)
  {
    int a = x;
    int b = y;
    int c = z;
    //do stuff
  }
  public static myclass Create()
  {
    AnotherThing at = new AnotherThing(param1, param2, param3);
    Something st = new Something(aThing, 10, 15)
    SomethingElse ste = new SomethingElse("some string", "another string");

    int x = thing.CollectionOfStuff.Count;
    int y = ste.GetValue();
    int z = (int)Math.Floor(533 / 39.384);

    return new myclass(x, y ,z);
  }
  public static myclass Create(int x, int y)
  {
    if (x = 1)
      return new myclass(x, y, 2)
    else 
      return new myclass(x, y, 15);
  }
  public static myclass Create(int x, int y, int z)
  {
    //so on and so forth
    return new myclass(x, y, z);
  }
}

हालाँकि, आपको फ़ैक्टरी पैटर्न की आवश्यकता नहीं है , लेकिन यह निश्चित रूप से आपके निर्माता तर्क को पठनीय बनाता है।


सभी कंस्ट्रक्टरों से एक आरंभीकरण विधि को कॉल करने के विकल्प के रूप में (जो आपको आसानी से खेतों का उपयोग करने से रोकता है) या कारखाने के तरीके (जो आपके पास कक्षाएं लेते समय अतिरिक्त जटिलता का परिचय देते हैं), आप एक पैरामीटर ऑब्जेक्ट का उपयोग कर सकते हैं:

int a, b, c;

public Constructor()
    : this(new ConstructorParameters())
{
}

public Constructor(int x, int y)
    : this(new ConstructorParameters(x, y))
{
}

public Constructor(int x, int y, int z)
{
    a = x;
    b = y;
    c = z;
    //do stuff 
} 

private Constructor(ConstructorParameters parameters)
    : this(parameters.X, parameters.Y, parameters.Z)
{
}

private class ConstructorParameters
{
    public int X;
    public int Y;
    public int Z;

    public ConstructorParameters()
    {
        AnotherThing at = new AnotherThing(param1, param2, param3); 
        Something st = new Something(at, 10, 15) 
        SomethingElse ste = new SomethingElse("some string", "another string"); 

        X = st.CollectionOfStuff.Count; 
        Y = ste.GetValue(); 
        Z = (int)Math.Floor(533 / 39.384); 
    }

    public ConstructorParameters(int x, int y)
    {
        X = x;
        Y = y;
        Z = (int)Math.Floor(533 / 39.384);
    }
}




code-duplication