Archief - C# Constructor overloading

Het archief is een bevroren moment uit een vorige versie van dit forum, met andere regels en andere bazen. Deze posts weerspiegelen op geen enkele manier onze huidige ideeën, waarden of wereldbeelden en zijn op sommige plaatsen gecensureerd wegens ontoelaatbaar. Veel zijn in een andere tijdsgeest gemaakt, al dan niet ironisch - zoals in het ironische subforum Off-Topic - en zouden op dit moment niet meer gepost (mogen) worden. Toch bieden we dit archief nog graag aan als informatiedatabank en naslagwerk. Lees er hier meer over of start een gesprek met anderen.

TooChé

Legacy Member
Is er een manier in VS waarbij ge een 1 constructor schrijft met maximaal aantal parameters, maar die toelaat da ge diezelfde constructor aanroept met minder parameters in plaats van die null (bvb) in te vullen?

dus stel:

constructor(par1,par2,par3,par4){}


aanroepen met : constructor(value1,value2)

lykmeraid

Legacy Member
Ge zegt het toch zelf ? Gewoon constructor overloading doen, dus een 2e constructor aanmaken die 2 parameters accepteert. In de code van die constructor kunt ge par3/4 nog steeds een waarde toekennen als ge dat wilt.

sparks

Legacy Member
Probeer eens default values te geven
constructor(obj par1 = null, obj par2 = null, obj par3 = null, obj par4 = null)

werkt normaal wel pas vanaf 4.0
Ge kunt ze zo ook named aanroepen en bijvoorbeeld alleen par1 en par3 meegeven.

TooChé

Legacy Member
lykmeraid zei:
Ge zegt het toch zelf ? Gewoon constructor overloading doen, dus een 2e constructor aanmaken die 2 parameters accepteert. In de code van die constructor kunt ge par3/4 nog steeds een waarde toekennen als ge dat wilt.

Tis dus de bedoeling dat ik net geen 2e constructor schrijf. In C++ schrijft ge een constructor en kunt ge die perfect aanroepen met verschillend aantal parameters

sparks zei:
Probeer eens default values te geven
constructor(obj par1 = null, obj par2 = null, obj par3 = null, obj par4 = null)

werkt normaal wel pas vanaf 4.0
Ge kunt ze zo ook named aanroepen en bijvoorbeeld alleen par1 en par3 meegeven.

ik dacht da ge da in VS2010 al kon, ook voor 2.0.
Want dat heb ik vergeten vermelden, het moet in framework 2.0 :)

sparks

Legacy Member
Dan zal het niet werken want het is een nieuwe feature van 4.0, je zal dus overloading moeten doen en meerdere constructors schrijven

Albireo

Legacy Member
Als je weet hoeveel parameters er maximaal zullen zijn, kan je het zo doen:
Code:
        public Class1(string value1, int value2, double value3, double value4) {
            this.value1 = value1;
            this.value2 = value2;
            this.value3 = value3;
            this.value4 = value4;
        }
        public Class1(string value1, int value2):this(value1,value2,1.0,1.0) {}
Dit noemt men constructor chaining.

Als je een variabel aantal parameters moet accepteren, kan je het "params" keyword gebruiken.
Code:
public Class1(string value1, int value2, params double[] values) {
            this.value1 = value1;
            this.value2 = value2;
            this.values=values; //this.values is gedefinieerd als een array van double
        }
Deze constructor kan als volgt gebruikt worden
Code:
Class1 c1 = new Class1("", 1, 1.0, 5.0, 6.5, 0.0, 42.0);
Je kan aan deze constructor zoveel doubles meegeven als nodig is.
Zie params (C#)

TooChé

Legacy Member
dit is inderdaad toepasbaar indien ge met allemaal dezelfde types van parameters zit. Als uw 3e en 4e parameter bvb van een ander type zijn, is het minder efficiënt dan gewoon te gaan overloaden

voltje

Legacy Member
Tuurlijk kan da...

Maak u een object aan met volgende properties:

Property Name (string), Property Value (object), Property Type (type)

Geef aan u constructor een collection mee van deze class.

Vervolgens vul je in de constructor mbv reflection de nodige properties op (ittererend over de collectie)

Misschien een "wtf" manier, maar t ga he :P

BTW: Ik doe het NIET op deze manier, hoewel het een enorm vuile manier is is het wel mogelijk.

(Waarom niet gwn overloading doen?)

sparks

Legacy Member
voltje zei:
Tuurlijk kan da...

Maak u een object aan met volgende properties:

Property Name (string), Property Value (object), Property Type (type)

Geef aan u constructor een collection mee van deze class.

Vervolgens vul je in de constructor mbv reflection de nodige properties op (ittererend over de collectie)

Misschien een "wtf" manier, maar t ga he :P

BTW: Ik doe het NIET op deze manier, hoewel het een enorm vuile manier is is het wel mogelijk.

(Waarom niet gwn overloading doen?)

Ik denk dat het was om minder code te hebben.

voltje

Legacy Member
T geen ik zeg doet ge in 5 lijnen ofzo? :)

Ik raad het wel niet aan om dat te doen, maar als hij echt zoiets zoekt...

sparks

Legacy Member
TooChé zei:
is het minder efficiënt dan gewoon te gaan overloaden

Ik denk dat dit ook wel toepasselijk is op het geen je zei.

Nuja doet er niet toe, het is mogelijk zoals je aanhaalde, gewoon geen goede manier (zoals je ook aanhaalde)

TooChé

Legacy Member
yup, wou eigenlijk gewoon weten of C# over een zelfde eenvoudige manier beschikt als in C++

Albireo

Legacy Member
Als constructor chaining niet praktisch zou zijn, zou je ook al de parameters voor je constructor in een apart object kunnen steken en dat object doorgeven aan je constructor.
Code:
    class ProgramParameters {
        int param1 = 42;
        DateTime param2 = DateTime.MaxValue;
        double param3 = Math.PI;
        string param4 = "Hello world!";
        public int Param1 {
            get { return param1; }
            set { this.param1 = value; }
        }
        public DateTime Param2 {
            get { return param2; }
            set { this.param2 = value; }
        }
        public double Param3 {
            get { return this.param3; }
            set { this.param3 = value; }
        }
        public string Param4 {
            get { return this.param4; }
            set { this.param4 = value; }
        }
    }
En in je eigenlijke klasse
Code:
    class Program {
        private ProgramParameters parameters;
        public Program(ProgramParameters parameters) {
            this.parameters=parameters;
        }
    }

voltje

Legacy Member
En ik dacht da mijn manier bizar was :P wrm zoude da doen?
Da geeft u ni het voordeel van "minder" parameters door tegeven, tenzij ge null meegeeft.
Da kunde zondr u klassee ook...

sparks

Legacy Member
Toch wel?
Program objProgram = new Program(new ProgramParameters(){ Param1 = 1, Param4 = "Test" });

Op die manier geef je toch ook alleen de paramets mee die nodig zijn?

Albireo

Legacy Member
Alle parameters hebben hun standaardwaarde tenzij je ze expliciet een waarde geeft. Je kan ProgramParameters gebruiken zonder ook maar 1 waarde hoeven in te geven.

kleine correctie:
Code:
        public Program(ProgramParameters parameters) {
            if (parameters == null) {
                this.parameters = new ProgramParameters();
            }
            else {
                this.parameters = parameters;
            }
        }

Albireo

Legacy Member
Can't tell if sincere or sarcastic.... :wtf:

PS. simpelste oplossing: gebruik properties i.p.v. een constructor

voltje

Legacy Member
Tuurlijk is parnaka sarcastisch :-)
Alle code trekt op niets, maar ja... Tis een antwoord op zijn vraag.

En ja, idd waarom geen properties gebruiken?
Gebruik ik ook veel, zo kan je doen:

Class oInstance = new Class() { Property1=..., Property2=... };
Het archief is een bevroren moment uit een vorige versie van dit forum, met andere regels en andere bazen. Deze posts weerspiegelen op geen enkele manier onze huidige ideeën, waarden of wereldbeelden en zijn op sommige plaatsen gecensureerd wegens ontoelaatbaar. Veel zijn in een andere tijdsgeest gemaakt, al dan niet ironisch - zoals in het ironische subforum Off-Topic - en zouden op dit moment niet meer gepost (mogen) worden. Toch bieden we dit archief nog graag aan als informatiedatabank en naslagwerk. Lees er hier meer over of start een gesprek met anderen.
Terug
Bovenaan