c# pointer / ref naar variable in class

[Verwijderd]

ik heb een globale variable

string glstring;

daarnaast heb ik een class met een hoop variabele er in van het type string
deze class word minimaal 2x aangemaakt als globale;

dus bv.

tstclass tst = new tstclass()
tstclass tst2 = new tstclass()
enz

de tstclass ziet er als volgend uit

public class tstclass
{
public string bla;
public string blaat;

}

hoe kan ik zorgen dat glstring het 1 moment verwijst naar tst.bla en het volgende moment naar tst.blaat;
dus al ik dan doe glstring="bla die"; dat die waarde in tst.bla komt te staan

in ansi C zou dit dmv van pointers te doen zijn. in c# ook wel maar wil als het kan liever niet unsafe code make

Het zal heel simpel zijn waarschijnlijk maar ik zie het niet

[H!GHGuY]

Het is simpel: niet.

Een string is een immutable type. Bovendien is de glstring vergelijkbaar met een reference. Dus als je iets toewijst aan glstring vervang je die ene reference. Je zal ofwel een extra indirectie moeten toevoegen ofwel eens grondig je design bekijken want wat je wil doen ziet er niet uit.

[Verwijderd]

H!GHGuY schreef op zondag 22 februari 2009 @ 16:09:
Het is simpel: niet.

Een string is een immutable type. Bovendien is de glstring vergelijkbaar met een reference. Dus als je iets toewijst aan glstring vervang je die ene reference. Je zal ofwel een extra indirectie moeten toevoegen ofwel eens grondig je design bekijken want wat je wil doen ziet er niet uit.

Het gene wat ik wil doen is namelijk dat ik via communicatie (serieel) data binnenkrijg met daarin een string
welke in de class moet komen in een variabele
en na een volgend commando krijg ik weer data binnen met een andere string daarin die ook weer in die class terecht moet komen op een volgende variabele.

de communicatie word op interrupt afgehandelt.

anders iemand een ideetje hoe dit beter op te lossen is

[ Voor 3% gewijzigd door Verwijderd op 22-02-2009 16:34 ]

[Verwijderd]

Aangezien je in C# niet zelf je pointers toekent doe je dit wel met reference variables als je dus (ik werk zelf niet met globals) je global naar je class.property wilt laten wijzen zou dat als volgt uit moeten zien:

C#:

string glstring;

public class tstClass
{
     public string bla { get; set; }
     public string blaat { get; set; }
}

tstClass tst = new tstClass();

glstring = tst.bla; // Nu dient glstring als reference naar tst.bla;
glstring = "Ik stop nu data in de tst.bla property";

[Verwijderd]

Verwijderd schreef op zondag 22 februari 2009 @ 16:35:
Aangezien je in C# niet zelf je pointers toekent doe je dit wel met reference variables als je dus (ik werk zelf niet met globals) je global naar je class.property wilt laten wijzen zou dat als volgt uit moeten zien:

C#:

string glstring;

public class tstClass
{
     public string bla { get; set; }
     public string blaat { get; set; }
}

tstClass tst = new tstClass();

glstring = tst.bla; // Nu dient glstring als reference naar tst.bla;
glstring = "Ik stop nu data in de tst.bla property";

als ik het op die manier doe zal tst.bla nog steeds null zijn.
hij zet de waarde niet in tst.bla maar die blijft in glstring staan helaas

[ Voor 5% gewijzigd door Verwijderd op 22-02-2009 16:46 ]

[Verwijderd]

Ik heb wat gezocht op google en kan weinig vinden als: Global as Reference Variable, wat ik wel veel tegenkom zijn topics waarin mensen data doorwillen geven via een Global en deze wordt aangeraden om een static class te gebruiken (wat naar mijn idee ook zou werken).

Ik zelf werk nooit met Globals en er zijn meerdere mensen die zweren bij het idee dus misschien dat dit een goede oplossing biedt

[Verwijderd]

Verwijderd schreef op zondag 22 februari 2009 @ 17:04:
Ik heb wat gezocht op google en kan weinig vinden als: Global as Reference Variable, wat ik wel veel tegenkom zijn topics waarin mensen data doorwillen geven via een Global en deze wordt aangeraden om een static class te gebruiken (wat naar mijn idee ook zou werken).

Ik zelf werk nooit met Globals en er zijn meerdere mensen die zweren bij het idee dus misschien dat dit een goede oplossing biedt

ja had ook al een tijd gegoogeld veel mensen met dit probleem maar geen nette oplossing.

evt is een grote switch ook nog een "smerige" oplossing zoals

tstclass welke;

welke=tst1;

switch (eepromadres)
{
case 1704 :welke.bla="waarde";
break;
case 1719: welk.blaat="waarde";
}

een erg erg lelijke oplossing maar werk wel

[Verwijderd]

Is het dan niet makkelijk in je class een naam mee te geven aan een property of dergelijke dat is toch een stuk netter

C#:

public class tstClass
{
     public tstClass(string className)
     {
           this.className = className;
     }
     private string className;
     public string ClassName {get {return className; } } 
}

tstClass class1 = new tstClass("class1");

switch(ClassName)
{
 case "class1" //etc.
}

Nou weet ik niet of je hiermee ook je gewenste functionaliteit bereikt

[ Voor 19% gewijzigd door Verwijderd op 22-02-2009 17:44 ]

[Cousin Boneless]

Je bedoelt dat je eerst je target bepaalt en dat later asynchroon de target wordt gevuld? Een delegate biedt in dat geval misschien uitkomst:

C#:

    public delegate void propertySetter(string value);

    public class tstclass
    {
        public string bla;
        public string blaat;

        public void setBla(string value)
        {
            bla = value;
        }

        public void setBlaat(string value)
        {
            blaat = value;
        }
    }

C#:

            tstclass tst = new tstclass();
            tstclass tst2 = new tstclass();

            // Bepalen van de target
            propertySetter setter = new propertySetter(tst.setBla);

            // Bij ontvangst van data
            setter("nieuwe waarde");

            // Resultaat tonen
            label1.Text = tst.bla;

Mja.. vaag omschreven probleem geeft een vaag antwoord

[ Voor 14% gewijzigd door Cousin Boneless op 23-02-2009 01:43 . Reden: nog wat korter ]

[Verwijderd]

Cousin Boneless schreef op maandag 23 februari 2009 @ 00:28:
Je bedoelt dat je eerst je target bepaalt en dat later asynchroon de target wordt gevuld? Een delegate biedt in dat geval misschien uitkomst:

C#:

    public delegate void propertySetter(string value);

    public class tstclass
    {
        public string bla;
        public string blaat;

        public void setBla(string value)
        {
            bla = value;
        }

        public void setBlaat(string value)
        {
            blaat = value;
        }
    }

C#:

            tstclass tst = new tstclass();
            tstclass tst2 = new tstclass();

            // Bepalen van de target
            propertySetter setter = new propertySetter(tst.setBla);

            // Bij ontvangst van data
            setter("nieuwe waarde");

            // Resultaat tonen
            label1.Text = tst.bla;

Mja.. vaag omschreven probleem geeft een vaag antwoord

dit doet precies wat ik wil morgen ff in de software aanpassen

[Cousin Boneless]

Let er wel op dat er meerdere wegen naar Rome leiden, en dit uit OO oogpunt misschien wel een hele hobbelige is. Je gooit de encapsulation van tstclass overboord doordat nu elk field indirect public moet zijn. Daarnaast loopt de hoeveelheid code evenredig met het aantal fields op, doordat elk field speciaal voor deze manier van laden een setter nodig heeft.
Misschien moet je het meer zoeken in associatief geheugen (hashtable). Dat wrap je inclusief deze asynchrone logica in een loader class (dus geen globale variabelen) waarmee je de tstclass in één keer construeert met een specifieke constructor.
De beste oplossing is zonder context niet te geven. Je kan de logica van het laden in tstclass onderbrengen (en dus private fields behouden), maar dat heeft dan weer het nadeel dat tstclass erg veel "weet" van de omgeving waarin deze gebruikt wordt.

[Mastermind]

Misschien is dit wat je wilt?

C#:

        private void button2_Click(object sender, EventArgs e)
        {
            TestClass t = new TestClass();
            SerialData sd = new SerialData();
            sd = t.bla;
            sd.Data = "Staat in bla";
            System.Diagnostics.Debug.WriteLine("sd.Data = " + sd.Data);
            System.Diagnostics.Debug.WriteLine("t.bla = " + t.bla.Data);
            System.Diagnostics.Debug.WriteLine("t.bla2 = " + t.bla2.Data);
            sd = t.bla2;
            sd.Data = "Staat in bla2";
            System.Diagnostics.Debug.WriteLine("sd.Data = " + sd.Data);
            System.Diagnostics.Debug.WriteLine("t.bla = " + t.bla.Data);
            System.Diagnostics.Debug.WriteLine("t.bla2 = " + t.bla2.Data);
        }
    }

    public class TestClass
    {
            public SerialData bla = new SerialData();
            public SerialData bla2 = new SerialData();
        
    }

    public class SerialData
    {
        private string _Data;
        public string Data
        {
            get
            {
                return _Data;
            }
            set
            {
                _Data = value;
            }

        }
    }