[C#] Constructor aanroepen binnen klasse

[Kayshin]

In mijn applicatie heb ik een klasse event. Binnen deze klasse zit een constructor met een x-aantal parameters (type, timestamp, id, whatever). Deze constructor maakt het object aan aan de hand van de parameters die je dus meegeeft.

Nu wil ik echter geen parameters meegeven maar een (ingelezen uit een bestand) event regel, welke dan eerst verwerkt wordt (conversie naar datetime etc), waarna ik dan binnen zijn eigen klasse de andere constructor aan wil roepen.

Wat ik dus wil is 2 constructors, 1 met een List<string> als parameter en 1 met een x-aantal andere velden met verschillende types.

Ik heb eens gekeken naar constructor chaining, echter lijkt het voor mij er op dat ik dan alleen bepaalde velden optioneel kan maken oid, ik vat het niet helemaal.

Wat ik zou willen is dus zoiets (nee dit functioneert niet met this=new Event, maar dat is wel het principe dat ik graag voor elkaar zou willen krijgen)

C#:

public Event(List<string> eventLine)
        {
            DateTime tmp;
            DateTime.TryParseExact(eventLine[2], "MM/dd/yyyy HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out tmp);
            int miliseconds = Convert.ToInt32(eventLine[3].PadRight(6, '0'));
            this = new Event(EventType.Exception, eventLine[1], tmp, miliseconds, eventLine[5], eventLine[6]);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Event"/> class
        /// </summary>
        /// <param name="et">Event type</param>
        /// <param name="trigger">Trigger for transition</param>
        /// <param name="timestamp">Timestamp of event</param>
        /// <param name="milliseconds">Number of milliseconds to be added to the timestamp</param>
        public Event(EventType et, string trigger, DateTime timestamp, int milliseconds, string classification, string severityLevel)
        {
            this.id = AdditionalFunctions.GenerateId();
            this.type = et;
            this.trigger = trigger;
            this.timestamp = timestamp;
            this.milliseconds = milliseconds;
            this.breakpoint = false;
            this.classification = classification;
            this.severitylevel = severitylevel;
        }

[Koppensneller]

C#:

public Event(List<string> eventLine)
        {
            DateTime tmp;
            DateTime.TryParseExact(eventLine[2], "MM/dd/yyyy HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out tmp);
            int miliseconds = Convert.ToInt32(eventLine[3].PadRight(6, '0'));
            FillInfo(EventType.Exception, eventLine[1], tmp, miliseconds, eventLine[5], eventLine[6]);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Event"/> class
        /// </summary>
        /// <param name="et">Event type</param>
        /// <param name="trigger">Trigger for transition</param>
        /// <param name="timestamp">Timestamp of event</param>
        /// <param name="milliseconds">Number of milliseconds to be added to the timestamp</param>
        public Event(EventType et, string trigger, DateTime timestamp, int milliseconds, string classification, string severityLevel)
        {
            FillInfo(et, trigger, timestamp, milliseconds, classification, severityLevel)
        }
        
        private void FillInfo(EventType et, string trigger, DateTime timestamp, int milliseconds, string classification, string severityLevel)
        {
            this.id = AdditionalFunctions.GenerateId();
            this.type = et;
            this.trigger = trigger;
            this.timestamp = timestamp;
            this.milliseconds = milliseconds;
            this.breakpoint = false;
            this.classification = classification;
            this.severitylevel = severitylevel;
        }
}

Zo kan 'ie toch ook gewoon?

[Kayshin]

Ja dat kan maar ik vroeg me af of dit ook op een of andere manier binnen de constructors kan werken, zodat ik daar niet per sé een extra functie voor hoef te maken.

[alex3305]

Je kunt toch ook constructor overloading gebruiken, mocht je dat nodig hebben? Of begrijp ik je dan misschien verkeerd? Daarnaast lijkt me de oplossing van Koppensneller al voldoende.

Vergeet overigens niet dat je niet zomaar this mag wijzigen tijdens runtime. Het lijkt me daarnaast ook in de meeste gevallen ongewenst gedrag. Je zou namelijk ook bepaalde variabelen in dezelfde klasse (en dus het object) kunnen wijzigen om hetzelfde te bereiken.

[SaphuA]

.

[ Voor 96% gewijzigd door SaphuA op 31-01-2022 15:01 ]

[Kayshin]

@SaphuA die had ik ook al gevonden, echter wordt daar een int geparsed naar het type dat de constructor verwacht, ik heb een heel ander type parameter waar ik mee wil werken. Of mis ik het hele idee nou? Ik heb namelijk naar verschillende van deze constructies en oplossingen gekeken echter lijkt dit nergens op mijn specifieke probleem.

[ Voor 31% gewijzigd door Kayshin op 20-03-2013 15:28 ]

[Koppensneller]

SaphuA schreef op woensdag 20 maart 2013 @ 15:23:
Is dit wat je zoekt? http://stackoverflow.com/a/4009032/314447

Daar zat ik ook aan te denken, maar in het geval van de TS levert dat volgens mij niet bepaald mooie code op.

[Niek.NET]

Een goede vraag die je je zelf kunt stellen is wie / wat verantwoordelijk is voor het parsen van die List<string>. In mijn optiek moet je dat soort dingen niet in een constructor oplossen. Dit is namelijk volstrekt onduidelijk voor degene die die constructor gaat aanroepen. Ik zou hiervoor een static methode aanmaken die Parse heet. Een andere oplossing is een EventParser class aanmaken maar dat lijkt mij in jouw geval overkill.

code:

        /// <summary> 
        /// Initializes a new instance of the <see cref="Event"/> class 
        /// </summary> 
        /// <param name="et">Event type</param> 
        /// <param name="trigger">Trigger for transition</param> 
        /// <param name="timestamp">Timestamp of event</param> 
        /// <param name="milliseconds">Number of milliseconds to be added to the timestamp</param> 
        public Event(EventType et, string trigger, DateTime timestamp, int milliseconds, string classification, string severityLevel) 
        { 
            this.id = AdditionalFunctions.GenerateId(); 
            this.type = et; 
            this.trigger = trigger; 
            this.timestamp = timestamp; 
            this.milliseconds = milliseconds; 
            this.breakpoint = false; 
            this.classification = classification; 
            this.severitylevel = severitylevel; 
        }

        public static Event Parse(List<string> eventLine) 
        { 
            DateTime tmp; 
            DateTime.TryParseExact(eventLine[2], "MM/dd/yyyy HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out tmp); 
            int miliseconds = Convert.ToInt32(eventLine[3].PadRight(6, '0')); 
            return new Event(EventType.Exception, eventLine[1], tmp, miliseconds, eventLine[5], eventLine[6]); 
        }

Edit:

Dit patroon zie je trouwens ook veel terug in het .NET framework.

[ Voor 63% gewijzigd door Niek.NET op 20-03-2013 15:32 ]

[Kayshin]

Ik had zelf al het idee gehad om een extra functie te schrijven, dat is in principe het probleem niet, het gaat mij erom of dit op een of andere manier ook zo kan. Een extra class hiervoor aanmaken is inderdaad overkill XD

En de event class is zelf verantwoordelijk voor het parsen van zijn event lines, dat is de hele bedoeling van mijn event class

[ Voor 23% gewijzigd door Kayshin op 20-03-2013 15:31 ]

[Kayshin]

Niek.NET schreef op woensdag 20 maart 2013 @ 15:29:
Een goede vraag die je je zelf kunt stellen is wie / wat verantwoordelijk is voor het parsen van die List<string>. In mijn optiek moet je dat soort dingen niet in een constructor oplossen. Dit is namelijk volstrekt onduidelijk voor degene die die constructor gaat aanroepen. Ik zou hiervoor een static methode aanmaken die Parse heet. Een andere oplossing is een EventParser class aanmaken maar dat lijkt mij in jouw geval overkill.

code:

blaat

Edit:

Dit patroon zie je trouwens ook veel terug in het .NET framework.

Dit functioneert voor mij tot nu toe ook nog het beste, echter zou ik nog steeds het liefste gewoon de klasse willen instantiëren op de manier die ik uitlegde.

[Niek.NET]

Kayshin schreef op woensdag 20 maart 2013 @ 15:44:
[...]

Dit functioneert voor mij tot nu toe ook nog het beste, echter zou ik nog steeds het liefste gewoon de klasse willen instantiëren op de manier die ik uitlegde.

Waarom wil je dit? Is dit een stijl kwestie of heb je functionele eisen waaraan je wilt voldoen. Nu is het voor ons natuurlijk moeilijk discussiëren. Waar komt bijvoorbeeld die List<string> vandaan?

[Kayshin]

Die list<string> komt uit een bestand dat ik inlees en ja, het gaat bij mij in dit geval vooral om een stijlkwestie. Een oplossing had ik al lang bedacht maar ik hoopte dat er een of andere manier was om dit voor elkaar te krijgen

[Niek.NET]

Kayshin schreef op woensdag 20 maart 2013 @ 15:52:
Die list<string> komt uit een bestand dat ik inlees en ja, het gaat bij mij in dit geval vooral om een stijlkwestie. Een oplossing had ik al lang bedacht maar ik hoopte dat er een of andere manier was om dit voor elkaar te krijgen

Functioneel gezien heeft Koppensneller die al gegeven. Dat je perse constructor overloading wil gebruiken om dit te realiseren is wat lastiger maar ook niet onmogelijk. Je zult dan niet gebruik kunnen maken van de TryParseExact omdat deze een scope nodig heeft waarbinnen je de out parameter definieert. Dit levert echter onduidelijkere code op dan het voorbeeld van Koppensneller.

[Grijze Vos]

Van de guidelines

Consider using a static factory method instead of a constructor if the semantics of the desired operation do not map directly to the construction of a new instance, or if following the constructor design guidelines feels unnatural.

Emphasis mine

[R4gnax]

Zoals gewoonlijk; eens met Grijze Vos.

Trouwens; afhankelijk van wat je hier aan het doen bent zou het zelfs zo kunnen zijn dat je een conceptueel foute architectuur aan het hanteren bent waar zaken gecombineerd worden die dat helemaal niet horen te zijn. Het feit dat je een aantal text lines uit een file één op één omzet naar een List<string> en dat aan je Event class mee moet geven om te verwerken stinkt daar eerlijk gezegd heel sterk naar.

Ik zou in dit geval bijvoorbeeld eerder een EventReader klasse verwachten die gegeven een bepaalde file naam of Stream een (lijst van) Event instance(s) kan produceren. Je kunt dan alsnog een static factory method maken op Event die intern van deze EventReader gebruik maakt ...

[H!GHGuY]

Wat je wil heet "named constructor" - de inhoud is hierboven al aangegeven