C# Class properties and local variables (of methods)

[umask]

Goedenavond, sorry dat ik zo laat stoor. Ik heb een dringende vraag, omdat ik iets niet helemaal snap...

Programmeertaal: C# (versie 7.3)
Omgeving: Visual Studio 2019

Klasse A
- hier maak ik een instantie aan van een klasse X en geef ik vervolgens wat parameters door in de constructor (in de klasse zelf bind ik deze parameters weer aan de interne properties). Voor het testen zeg ik eerst PropertyName = parameter; en roep ik ook een methode methode aan in de constructor van klasse X. In de methode stop ik dan de PropertyName in ipv de parameter door te geven.

Klasse X
- de methode geeft uiteindelijk een object/type terug, maar wat ik niet snap is dat ik nergens in mijn code bijvoorbeeld zeg PropertyName equals to local variable (van de methode) en toch weet Visual Studio op de een of andere manier dat PropertyName gelijk staat aan de huidige staat van de lokale variable. In de methode van klasse X, zeg ik niet eens PropertyName = local variable of iets.. en toch: als ik een type/object terug geef, ik dan gewoon de informatie van de local variable krijg maar wat vreemd is, is dat de huidige staat van de local variable gelijk staat aan de PropertyName, zonder dat ik ook maar 1x heb aangegeven: Ok => nu is PropertyName gelijk aan local variable ...

Heeft dit te maken, omdat ik in de constructor heb aangegeven: Gebruik de PropertyName? En Visual Studio heeft een referentie aangemaakt voor deze PropertyName in de methode en deze gekoppeld aan de local variable? Staat daarom steeds de local variable gelijk aan de PropertyName en andersom?

Ik hoor het graag van u en bij voorbaat dank..

Update: conclusie

Het kwam doordat de originele lijst die ik doorstuurde een reference type is. List<T> is een class en classes zijn reference types, dus die lijst die ik doorstuur is een reference type. Zie: https://docs.microsoft.co...c.list-1?view=netcore-3.1. Ik wist dat classes wel reference types waren, alleen stond ik er even niet bij stil.. (bij het gebruik van List<T>)

Maar als ik een kopie van deze lijst stuur, wordt de originele lijst niet gemanipuleerd, maar wordt de gekopieerde lijst als het ware aangepast en niet de originele. De objecten worden dan gerefereerd naar de kopieerde lijst en niet naar de originele. Nu ik dit weet, bedank ik de andere voor hun bijdrage. De volgende keer zal ik proberen te beginnen met het tonen van voorbeeld codes (die compileren).

[ Voor 20% gewijzigd door umask op 23-05-2020 02:17 ]

[Juup]

Post eens wat code (tussen [code=C#][/code] haken)

[RobIII]

Wat ik vermoed dat hier aan de hand is op basis van je verhaal is het verschil tussen een value type en een reference type. Maar het zou ontzettend handig zijn als je even een simpel code voorbeeld zou posten zoals @Juup aangeeft; gebruik daarbij dan a.u.b. code tags. Probeer je code wel te beperken tot een minimaal aantal regels code om je probleem te demonstreren.

[BertS]

Als ik het zo lees heb je één slag gemist: class-variables. Je hebt denk ik een variabele gedeclareerd op het niveau van de class X (die variabele staat buiten de constructor en buiten de method die je aanroept). In de constructor assign je de waarde van je constructor parameter aan die class-variabele. Die variabele is dan in de hele instance van class X beschikbaar.
Dus als die method intern in class X is, hier je die property/variabele niet mee te geven als parameter aan je method.

[umask]

Ik zal even een voorbeeld plaatsen dat illustreert hoe het ongeveer in code eruitziet:

Class: Application

C#:

using System;
using System.Collections.Generic;
using System.Linq;
using Business.Logic;

namespace Application
{
   class Application
   {
      private static TypeA typeA;
      private static readonly List<TypeB> listTypeB = new List<TypeB>();
      private static readonly List<TypeC> listTypeC = new List<TypeC>();

      // Items are added to listTypeB (you can assume this, because this is not relevant for describing the problem..)
      // Items are added to listTypeC (..^..)
      
      // Why is there a new list being created of TypeC list below? 
      // Well, somehow when I 'print' the values from Application 
      // to the debugger, the values of listTypeC are being emptied? 
      // By creating a 'new list' of TypeC '.ToList()' the original values in Application 
      // are untouched (TypeC is a reference type, so the new list will 
      // contain references to the same objects as the original list..)? 
      // If I don't do this, I get an empty list when printing .. 
      // but this 'converting' is also an issue though..I mean like: 
      // is there a better way to do this? Why is the list emptied? 
      // This only happends when I pass the list as arguments to 
      // the constructor of another class.. in this case class TypeA.
      typeA = new TypeA(listTypeB, listTypeC.ToList());
   }
}

Class: TypeA

C#:

using System;
using System.Collections.Generic;
using System.Linq;

namespace Business.Logic
{
   class TypeA
   {
      public TypeA(List<TypeB> listB, List<TypeC> listc)
      {
         ListPropertyTypeB = listB;
         ExampleMethodOfClassTypeA(ListPropertyTypeB, listc);
      }
   }
}

Hoop dat dit mijn vraag duidelijker maakt .

[ Voor 3% gewijzigd door umask op 23-05-2020 01:58 ]

[RobIII]

umask schreef op zaterdag 23 mei 2020 @ 00:13:
Hoop dat dit mijn vraag duidelijker maakt .

Nou, nee, niet bepaald. Dit compiled niet zo (met wat je gegeven hebt) en er staat nog steeds een ontzettend warrig verhaal bij. Maak nou eens een stukje code zonder allerlei TypeA, TypeB en TypeC en weet-ik-veel die overbodig zijn maar gewoon het minimum dat nodig is om je voorbeeld te demonstreren en wat compiled en te starten is. Geef daarbij aan wat je ziet, wat je verwacht en waarom je denkt dat 't volgens jou verschillend is.

Maar mijn glazen bol zegt nu, op basis van wat ik zie, dat je niet helemaal snapt wat static doet.

[CodeCaster]

Je hebt de code te veel versimpeld, je laat te veel relevante code weg en je vertelt niet duidelijk wat er nu gebeurt.

Volgens mij is je vraag: "waarom moet ik ToList() gebruiken als ik een List<T> als argument doorgeef, want als ik dat niet doe is listTypeC leeg na new TypeA()".

Dan is het antwoord: omdat List<T> een reference type is, en je in ExampleMethodOfClassTypeA waarschijnlijk een listc.Clear() aanroept...

[ Voor 6% gewijzigd door CodeCaster op 23-05-2020 00:19 ]

[umask]

RobIII schreef op zaterdag 23 mei 2020 @ 00:17:
[...]
Maar mijn glazen bol zegt nu, op basis van wat ik zie, dat je niet helemaal snapt wat static doet.

Kunt u toelichten waarom u dit eigenlijk denkt?

[umask]

CodeCaster schreef op zaterdag 23 mei 2020 @ 00:19:
waarschijnlijk een listc.Clear() aanroept...

Nee, ik roep nergens clear aan.. wat zou het dan kunnen zijn?
Update:Wel dus, had het over het hoofd gezien..

[ Voor 19% gewijzigd door umask op 23-05-2020 01:57 ]

[CodeCaster]

umask schreef op zaterdag 23 mei 2020 @ 00:20:
[...]


Nee, ik roep nergens clear aan..

En wat doe je dan wel met die code? Nogmaals, als je niet alle relevante code toont én je probleem niet duidelijk omschrijft, kunnen we alleen maar gokken wat er precies gebeurt en hoe dat zou kunnen gebeuren.

[ Voor 31% gewijzigd door CodeCaster op 23-05-2020 00:21 ]

[RobIII]

umask schreef op zaterdag 23 mei 2020 @ 00:19:
[...]


Kunt u toelichten waarom u dit eigenlijk denkt?

Geen idee want ik kan geen hout snijden van wat je nou precies niet snapt of wat je vraag is, maar gebaseerd op 25 jaar programmeervragen beantwoorden zegt mijn spidey-sense me dat hier je wel blabla static blabla in je code getyped hebt maar geen idee hebt waarom. Je vraag betreft, op wat ik er uit kan destilleren, iets met instanties van classes etc. en static heeft daar mee te maken.

Zorg nou eerst maar eens dat wanneer we je code over nemen de code compiled en dus compleet is en je probleem demonstreert. Dat doet 't nu bij lange na niet (en dan heb ik voor 't overzicht even het hele verhaal in je comments weggelaten).

[ Voor 19% gewijzigd door RobIII op 23-05-2020 00:25 ]

[umask]

RobIII schreef op zaterdag 23 mei 2020 @ 00:21:
[...]

Geen idee want ik kan geen hout snijden van wat je nou precies niet snapt of wat je vraag is, maar gebaseerd op 25 jaar programmeervragen beantwoorden zegt mijn spidey-sense me dat hier je wel blabla static blabla in je code getyped hebt maar geen idee hebt waarom. Je vraag betreft, op wat ik er uit kan destilleren, iets met instanties van classes etc. en static heeft daar mee te maken.

Ik had static variables/instanties gebruikt, omdat ik vergeten ben erbij te vermelden dat de variables static moeten zijn, omdat ze in een static methode leven.. Ik zal wel even een voorbeeld code herschrijven dat compileert

[ Voor 4% gewijzigd door umask op 23-05-2020 00:26 ]

[RobIII]

umask schreef op zaterdag 23 mei 2020 @ 00:25:
[...]


Ik had static variables/instanties gebruikt, omdat ik vergeten ben erbij te vermelden dat de variables static moeten zijn, omdat ze in een static methode leven..

Dat zegt me nog steeds niet of je wel snapt wat static doet. Ga nou eerst maar eens je code zo maken dat 't compileert, geen overbodige zooi bevat en gewoon je probleem demonstreert. Zodat wij je code kunnen copy/pasten, bekijken wat er gebeurt en zien of we je vraag kunnen beantwoorden. Dat kan nu niet.

Je eerste vraag uit je code is bijv:

Why is there a new list being created of TypeC list below?

Uh, er wordt een nieuwe lijst van TypeC gemaakt. Dus ik heb ook geen "why" voor je. Dan komt er een compleet warrig verhaal met allerlei aannames en dan weer een vraag als:

Why is the list emptied?

Er wordt niets leeggemaakt

Je code strookt totaal niet met wat je zegt/vraagt en is, derhalve, alleen maar verwarrender.

[ Voor 38% gewijzigd door RobIII op 23-05-2020 00:30 ]

[umask]

RobIII schreef op zaterdag 23 mei 2020 @ 00:26:
[...]

Dat zegt me nog steeds niet of je wel snapt wat static doet. Ga nou eerst maar eens je code zo maken dat 't compileert, geen overbodige zooi bevat en gewoon je probleem demonstreert.

Ik zal wel even proberen uit te leggen dan wat de static keyword doet en bevestig aub even of dit zo klopt... Ik wil dat de informatie 'aan de klasse' zelf wordt gekoppeld en niet zo zeer aan de properties/fields van de instanties van de klasse.. dus deze waarde wordt gedeeld met andere instanties van de klasse.. daarom gebruik ik de static keyword

[RobIII]

umask schreef op zaterdag 23 mei 2020 @ 00:29:
[...]


Ik zal wel even proberen uit te leggen dan wat de static keyword doet en bevestig aub even of dit zo klopt... Ik wil dat de informatie 'aan de klasse' zelf wordt gekoppeld en niet zo zeer aan de properties/fields van de instanties van de klasse.. dus deze waarde wordt gedeeld met andere instanties van de klasse.. daarom gebruik ik de static keyword

Ok, hartstikke mooi. Dan post nu eens, alsjeblieft, code die wél compileert en uitvoerbaar is en zet dan, eronder/erboven (en dus niet in de comments...) eens concreet neer wat je ziet dat er gebeurt, wat je verwacht(te) dat er gebeurt en wat je dénkt dat er aan de hand is. Dan kunnen wij je misschien zeggen waar je denkfout zit. Laat daarbij alle verwarrende TypeB en TypeC en weet-ik-veel die niet relevant zijn voor je vraag achterwege. Nog beter hou je 't bij concrete(re) types als "Application", "Customer", "Order" of iets 'gangbaars' zodat 't tastbaarder is dan het abstracte idee dat je nu geforceerd met allerlei ongedefinieerde types probeert uit te leggen.

[ Voor 18% gewijzigd door RobIII op 23-05-2020 00:34 ]

[CodeCaster]

Volgens mij is dit precies je vraag (of nou ja, ongeveer, want je doet in ieder geval geen Clear(), zeg je):

C#:

using System;
using System.Linq;
using System.Collections.Generic;

public class Test
{
    private static readonly List<string> listOne = new List<string> { "one", "1" };
    private static readonly List<string> listTwo = new List<string> { "two", "2" };
    
    public static void Main()
    {
        PrintList(listOne);
        Foo(listOne);
        PrintList(listOne);

        PrintList(listTwo);
        Foo(listTwo.ToList());
        PrintList(listTwo);
    }
    
    private static void Foo<T>(List<T> list)
    {
        list.Clear();
    }
    
    private static void PrintList<T>(List<T> list)
    {
        Console.WriteLine(list.Any() ? string.Join(",", list) : "(empty list)");
    }
}

En dan is je vraag waarom je .ToList() moet doen op regel 17 om niet de oorspronkelijke listTwo te laten aanpassen door de code die je aanroept.

En dan is het antwoord dus: omdat List<T> een reference type is, en ToList() een kopie maakt van de lijst.

En in jouw geval past de code in ExampleMethodOfClassTypeA() de lijst aan die als listc wordt meegegeven, wat weerspiegelt tot aan de aanroepende code die listTypeC meegeeft.

En als dit allemaal in de verste verte niet op jouw probleem lijkt, begin dan from scratch zoals RobIII al aangeeft, en leg je probleem duidelijk uit. Wat is er precies "leeg"? Wanneer? Waar? Hoe zie je dit?

[umask]

CodeCaster schreef op zaterdag 23 mei 2020 @ 00:36:
En als dit allemaal in de verste verte niet op jouw probleem lijkt, begin dan from scratch zoals RobIII al aangeeft, en leg je probleem duidelijk uit. Wat is er precies "leeg"? Wanneer? Waar? Hoe zie je dit?

Ik was nog eens gaan kijken naar mijn code en aan het debuggen, toen kwam ik er inderdaad achter dat ik ergens wat aan het leeg halen was.. (was wel de bedoeling, alleen had het even niet opgemerkt). Je hebt wel een goed voorbeeld gegeven met de verduidelijking. Ik begrijp het nu, want tijdens het debuggen zag ik dus dat als ik niks weghaalde ik de waardes zag en vervolgens zette ik de code dat zorgde dat iets uit de lijst werd gehaald en toen waren de objecten uit die lijst verdwenen en inderdaad, omdat het referenties zijn naar dezelfde objecten, wordt de originele lijst die gebruikt wordt (in beide klassen) geleegd. Maar als ik dus een nieuwe/kopie lijst (To.List()) van de originele lijst mee had gestuurd, werd de originele niet aangepast, maar de kopie ervan..

Hieronder code die wel compileert en nu ik weet waar de oorzaak ligt. De oorzaak ligt in de 'class House'..

Class: Program.cs

C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        private static House regularHouse;
        private static readonly List<Grocery> groceries = new List<Grocery>() 
        { 
            new Grocery(1, "Biscuit"),
            new Grocery(2, "Water"),
            new Grocery(3, "Bread")
        };

        private static readonly List<Material> materials = new List<Material>()
        {
            new Material(1, "Hammer"),
            new Material(2, "Lock"),
            new Material(3, "Key")
        };

        static void Main(string[] args)
        {
            regularHouse = new House(groceries, materials);
            House houseResult = regularHouse;

            foreach (Grocery grocery in groceries)
            {
                Console.WriteLine($"Grocery Id: {grocery.Id} Name: {grocery.Name} Value: {grocery.Value}");
            }

            if (materials.Count == 0)
            {
                Console.WriteLine("\nMaterials are empty..");
            }
            else
            {
                foreach (Material material in materials)
                {
                    Console.WriteLine($"\nMaterial Id: {material.Id} Name: {material.Name} Value: {material.Value}");
                }
            }

            Console.ReadLine();
        }
    }
}

Class: House.cs

C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    public class House
    {
        public List<Grocery> Groceries { get; set; }
        public House(List<Grocery> groceries, List<Material> materials)
        {
            Groceries = groceries;
            GetHouseWithStorage(Groceries, materials);
        }

        public House GetHouseWithStorage(List<Grocery> groceries, List<Material> materials)
        {
            for (int grocery = 0; grocery < groceries.Count; grocery++)
            {
                groceries[grocery].Value += (2.15 + grocery);
            }

            for (int material = 0; material < materials.Count; material++)
            {
                materials[material].Value += (5.50 + material);
            }

            while (materials.Count > 0)
            {
                for (int i = 0; i < materials.Count; i++)
                {
                    // Now I see, it happends because of this line ...
                    // But why is the original list also being emptied? 
                    // Because of references to the same objects in the original list..
                    materials.Remove(materials[i]);
                }
            }

            return this;
        }
    }
}

Class: Grocery.cs

C#:

namespace ConsoleApp1
{
    public class Grocery
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public double Value { get; set; }

        public Grocery(int id, string name)
        {
            Id = id;
            Name = name;
        }
    }
}

Class: Material.cs

C#:

namespace ConsoleApp1
{
    public class Material
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public double Value { get; set; }

        public Material(int id, string name)
        {
            Id = id;
            Name = name;
        }
    }
}

[umask]

Ik had al een vermoeden dat het aan de 'reference type' lag. Maar was er niet zeker van, daarom stelde ik deze vraag en nu met jouw uitleg en verduidelijking is het nóg duidelijker geworden. bedankt hiervoor en sorry dat ik niet meteen met een voorbeeld code kwam, zal de volgende keer hier meteen mee beginnen ..

[Josk79]

Is inderdaad omdat List een reference type (object op basis van een class of een array) is.

code:

a = new List<int>();
b = a;
a.Add(123);

Nu verwijzen a en b naar hetzelfde object, dus b bevat ook nummertje 123.

[RobIII]

Enigszins offtopic maar toch ook weer wel ontopic: je moet écht leren je te beperken tot relevante(!) code en een minimale(!) testcase te maken. Je post nu even pakweg 120(!) regels code om een probleem te demonstreren wat je in een fractie van het aantal regels code ook had kunnen tonen (zoals @CodeCaster overigens ook al demonstreert).

Dat doe je overigens niet alleen voor ons / anderen, maar óók (en misschien wel vóóral) voor jezelf. Je kunt je daardoor beter concentreren op het daadwerkelijke probleem en niet verzanden in alle fluff eromheen. Je kunt makkelijk(er) wat dingetjes veranderen, 'spelen' met je code, kijken wat het doet, experimenteren en zodoende leren.

[ Voor 43% gewijzigd door RobIII op 23-05-2020 02:24 ]

[umask]

RobIII schreef op zaterdag 23 mei 2020 @ 02:19:
Enigszins offtopic maar toch ook weer wel ontopic: je moet écht leren je te beperken tot relevante(!) code en een minimale(!) testcase te maken. Je post nu even pakweg 120(!) regels code om een probleem te demonstreren wat je in een fractie van het aantal regels code ook had kunnen tonen.

Klopt, ik zal hier in de toekomst aan proberen te denken, bedankt voor de tip

[BertS]

RobIII schreef op zaterdag 23 mei 2020 @ 02:19:
Enigszins offtopic maar toch ook weer wel ontopic: je moet écht leren je te beperken tot relevante(!) code en een minimale(!) testcase te maken. Je post nu even pakweg 120(!) regels code om een probleem te demonstreren wat je in een fractie van het aantal regels code ook had kunnen tonen (zoals @CodeCaster overigens ook al demonstreert).

Dat doe je overigens niet alleen voor ons / anderen, maar óók (en misschien wel vóóral) voor jezelf. Je kunt je daardoor beter concentreren op het daadwerkelijke probleem en niet verzanden in alle fluff eromheen. Je kunt makkelijk(er) wat dingetjes veranderen, 'spelen' met je code, kijken wat het doet, experimenteren en zodoende leren.

En daarbij vind je regelmatig bij die 'oefening' de oorzaak en oplossing van je probleem, zodat je de post uiteindelijk niet eens hoeft te submitten _{(* BertS spreekt uit ervaring)}