[C#]unsafe code: pointer zelf adresseren

[Verwijderd]

Dit is mijn eerste post op GOT, heb meelij... Op mijn 'reguliere' forum was onvoldoende kennis aanwezig voor onderstaande vraag.

Ik ben onlangs begonnen met programmeren in C#. Mijn achtergrond is voornamelijk Delphi, C++ en wat exotischere talen als PL/1 en VAXPascal.

Voor het starten van een communicatieprotocol dat bij de fabrieksapparatuur hoort die ik beheer is het nodig om een hard geadresseerde pointer te gebruiken (heeft te maken met aangeleverd DLL's, er is niet echt een zinnige manier om dit anders te doen).

In C# heb ik daarvoor de volgende code bedacht:

C#:

unsafe
{
    fixed (void * io = 0xBADBAD80)
    {
        // doe hier een aanroep naar de DLL met void pointer 'io' die naar 0xBADBAD80 wijst
    }
}

De compiler (Studio 2005) geeft dan echter (terecht) als melding dat een uint niet impliciet naar een void* kan worden gecast en dat daar een expliciete cast voor beschikbaar is. De tweede poging was dan ook:

C#:

unsafe
{
    fixed (void * io = (void *)0xBADBAD80)
    {
        // doe hier een aanroep naar de DLL met void pointer 'io' die naar 0xBADBAD80 wijst
    }
}

Helaas... dan komt de compiler met de melding dat er in een fixed declaration niet gecast mag worden...

Mijn concrete vraag is dus: hoe kan ik een void pointer maken die naar 0xBADBAD80 verwijst en waar de garbage collector vanaf blijft???

[.oisyn]

Logisch, waarom zou je een vast adres willen 'fixen'?. fixed is er juist voor om managed objecten, waarvan hun plek in het geheugen niet vast staat omdat de garbage collector die rond kan moven, vast te zetten zodat de pointer die je ervan krijgt naar dat object blijft wijzen binnen de scope van het fixed block. Maar aangezien je adres een vast adres is hoeft (en kan) dat niet.

Doe gewoon

C#:

unsafe
{
    void * io = (void*)0xbadbad80;
}

[ Voor 7% gewijzigd door .oisyn op 02-03-2007 11:14 ]

[Verwijderd]

.oisyn schreef op vrijdag 02 maart 2007 @ 11:13:
Logisch, waarom zou je een vast adres willen 'fixen'?. fixed is er juist voor om managed objecten, waarvan hun plek in het geheugen niet vast staat omdat de garbage collector die rond kan moven, vast te zetten zodat de pointer die je ervan krijgt naar dat object blijft wijzen binnen de scope van het fixed block. Maar aangezien je adres een vast adres is hoeft (en kan) dat niet.

Doe gewoon

C#:

unsafe
{
    void * io = (void*)0xbadbad80;
}

OK. Maar even voor mijn beeldvorming: volgens de documentatie is 'unsafe' niet 'unmanaged'. Ik kan er redelijk zeker van zijn dat de pointer niet 'verhuist'?

Aan de andere kant: ik begrijp nu ook ineens de foutmelding bij een van mijn andere pogingen dat ik geen 'already fixed object' mag gebruiken voor een fixed block. (had een soort van combinatie van jouw en mijn code geprobeerd).

Ik ga er mee aan de slag!

[Invisible_man]

Ah, daar was laatst ook al een topic over waar ik ook een stuk code in heb geplaatst wat bruikbaar kan zijn voor jou (ook voor het aanspreken van een "native" DLL).

De truuk is idd dat je geen eerder gemaakte variabelen moet gebruiken icm je dll en het liefst type's zoals strings en char's terugbrengt naar byte's (die worden immers overal hetzelfde geinterpreteerd).

[ Voor 30% gewijzigd door Invisible_man op 02-03-2007 12:38 ]

[Woy]

Verwijderd schreef op vrijdag 02 maart 2007 @ 12:33:
[...]
OK. Maar even voor mijn beeldvorming: volgens de documentatie is 'unsafe' niet 'unmanaged'. Ik kan er redelijk zeker van zijn dat de pointer niet 'verhuist'?

Je pointer kan mischien wel verhuizen (Al zal dat met een value-object niet waarschijnlijk gebeuren ), echter de waarde van je pointer kan alleen veranderen als je dat zelf doet.

het idee van fixed is dat je een managed object heb waar je een pointer naar toe wil. Aangezien dat object van plek kan veranderen kan het dan voorkomen dat je pointer niet meer naar het goede geheugen wijst ( Je pointer veranderd immers niet mee ). Door fixed te gebruiken wordt er gegarandeerd dat het object niet verplaatst wordt en je pointer altijd naar het object verwijst.