[C#] Bytes in multidimensionale array

[SimonBlok]

Beste mensen,
Ik ben een beginner op het gebied van C#, dus loop tegen wat probleempjes op. Ik ben gewend om in PHP te ontwikkelen en kom erachter dat PHP een wel erg tolerante scripttaal is.

Ik heb verschillende bytes (00100111, 00000001, enz...). Deze wil ik in een soort object opslaan. Zie volgend voorbeeld:

code:

array["1" => "00100111",
"2" => "0000001",
"A" => "1110011"]

Dit wil ik in C# als object/array beschikbaar hebben. Een bepaald karakter dus als key en een byte (of in ieder geval een rijtje van enen en nullen) als waarde.

Nu ben ik al op zoek geweest en zijn er verschillende manieren om multidimensionale arrays op te bouwen in C#, maar ik heb nog geen oplossingen gezien die je zelf een key laten definiëren. Heeft iemand iedeeën om dit voor elkaar te krijgen?

[SideShow]

hashtable

Hashtable lijst = new Hashtable();

lijst["byte1"] = 100;
lijst["byte2"] = 101;

foreach(DictionaryElement e in lijst)
{
Console.WriteLine("Key: {0}, Value: {1}", (string)e.Key, (int)e.Value);
}

Zoiets ... je moet zelfs maar eens kijken hoe je best een bit reeksje opslaat of gebruikt

[Voor 134% gewijzigd door SideShow op 30-05-2011 13:18]

[Danot]

SideShow schreef op maandag 30 mei 2011 @ 13:11:
hashtable

Hashtable lijst = new Hashtable();

lijst["byte1"] = 100;
lijst["byte2"] = 101;

Of voor type safety, de Dictionary. MSDN: Dictionary(TKey, TValue) Class (System.Collections.Generic)

C#:

Dictionary<string, int> dictionary =  new Dictionary<string, int>();
dictionary.Add("a", 10101);
dictionary.Add("b", 10101);
dictionary.Add("c", 10101);

[Voor 13% gewijzigd door Danot op 30-05-2011 13:21]

[djexplo]

Kijk ook eens naar
- http://www.codeproject.co...aryAndHexConversions.aspx
- http://stackoverflow.com/...ween-hex-and-decimal-in-c
Want een array of hashtable aanmaken om van hex naar string array van bits te gaan is wel heel omslachtig.

[Voor 3% gewijzigd door djexplo op 30-05-2011 13:20]

[CodeCaster]

SideShow schreef op maandag 30 mei 2011 @ 13:11:
hashtable

Of een Dictionary, of een SortedList, of eigenlijk elke implementatie van IDictionary.

[RobIII]

saimen schreef op maandag 30 mei 2011 @ 13:08:
Ik heb verschillende bytes (00100111, 00000001, enz...). voorbeeld:

Ofwel 39₁₀ en 1₁₀

saimen schreef op maandag 30 mei 2011 @ 13:08:

code:

array["1" => "00100111",
"2" => "0000001",
"A" => "1110011"]

Dat zijn strings (Die "00100111" e.d. dus).

Ga even 5 minuten zitten voor Getallen en talstelsels FAQ en je bent al een heel stuk wijzer

Danot schreef op maandag 30 mei 2011 @ 13:16:
[...]

Of voor type safety, de Dictionary. MSDN: Dictionary(TKey, TValue) Class (System.Collections.Generic)

C#:

Dictionary<string, int> dictionary =  new Dictionary<string, int>();
dictionary.Add("a", 10101);
dictionary.Add("b", 10101);
dictionary.Add("c", 10101);

Jij maakt 't helemaal spannend; je zet int's in je dictionary (die je overigens ook als int declareert) terwijl TS het over bytes heeft

[Voor 34% gewijzigd door RobIII op 30-05-2011 13:29]

[Zeebonk]

Let wel even heel goed op, Danot en SideShow doen nu alsof ze binaire getallen mee geven aan de collecties terwijl dit gewoon als int's worden geïnterpreteerd...

10101 bij Danot is dus niet gelijk aan 21 maar aan 10101

[Voor 15% gewijzigd door Zeebonk op 30-05-2011 13:32]

[jmzeeman]

Gebruik een Dictionary zoals al eerder aangegeven maar gebruik dan wel de goede types dus:

C#:

Dictionary<char,byte> waardes = new Dictionary<char,byte>();

Als waardes voor de bytes zou ik hex gebruiken omdat c# geen binary literals kent. Als je echt persee binary waardes wil hebben zal je ze als strings in je code moeten hebben staan en ze converten naar bytes. Zo bijvoorbeeld:

C#:

waardes.Add('A',0x73);//als hex
waardes.Add('A',Convert.ToByte("01110011",2));//lelijk maar wel als binary

[SimonBlok]

Jongens bedankt! Hier kan ik zeker wat mee. Ik ga aan de gang met de Dictionary-class. Het zullen hex-waardes gaan worden die ik dan zelf wel weer terugreken naar binaire waarden.

Voor de leesbaarheid binnen de code zou het wel makkelijker zijn als het een binaire waarde zou kunnen zijn.

Bedankt in ieder geval, ik kan verder!

[jmzeeman]

Je kan voor de leesbaarheid natuurlijk ook gewoon de binary waarde als commentaar er bij zetten.

[Herko_ter_Horst]

Waarom heb je belang bij de binaire waardes? Zijn dit vlaggetjes of representeren ze iets anders? Je hebt in C# meer mogelijkheden om data te representeren...

Indien vlaggetjes: BitArray/BitVector, of natuurlijk een eigen class/struct met booleans.
Indien een vaste set van waardes: enum.

[Voor 9% gewijzigd door Herko_ter_Horst op 30-05-2011 14:15]

[SimonBlok]

Herko_ter_Horst schreef op maandag 30 mei 2011 @ 14:11:
Waarom heb je belang bij de binaire waardes? Zijn dit vlaggetjes of representeren ze iets anders? Je hebt in C# meer mogelijkheden om data te representeren...

Indien vlaggetjes: BitArray/BitVector, of natuurlijk een eigen class/struct met booleans.
Indien een vaste set van waardes: enum.

Het gaat om het aansturen van hardware (7-segment LED-dislay). Het gaat dus om uitgangen van een interfacekaart die 0 of 1 moeten zijn. Het zal dus een set van vaste waarden zijn. Ik heb het ook geprobeerd met een enum, maar kwam daar ook niet echt uit, kreeg het niet voor elkaar om zelf een key te definiëren.

[roy-t]

De C# manier om dit te doen zijn inderdaad enums, enums als bit flags is erg goed te doen, zie deze MSDN pagina en dan het hoofdstuk "Enums as BitFlags" MSDN: Enumeration Types (C# Programming Guide)

Komt er op neer da tje de enum zo defineerd:

C#:

[Flags]
enum Days2
{
    None = 0x0,
    Sunday = 0x1,
    Monday = 0x2,
    Tuesday = 0x4,
    Wednesday = 0x8,
    Thursday = 0x10,
    Friday = 0x20,
    Saturday = 0x40
}

(De code tussen '[' en ']' zijn attributes en geven extra betekenis aan een standaard stukje code)

[Voor 8% gewijzigd door roy-t op 30-05-2011 14:44]

[Caelorum]

roy-t schreef op maandag 30 mei 2011 @ 14:42:
[..]

Enums zijn daar wel handig in ja.
Dan kanje namelijk ook iets doen zoals dit:

C#:

UitgangCodes out = UitgangCodes.uitgang1 | UitgangCodes.uitgang2; //om uitgnag 1 en 2 aan te zetten bijvoorbeeld

Maar dan waarshcijnlijk in het Engels.

[Voor 7% gewijzigd door Caelorum op 30-05-2011 15:23]

[jmzeeman]

Toch vraag ik me af of in deze situatie enums nou zoveel toevoegen, persoonlijk zou ik het denk ik bij hex houden (maar mischien ben ik iets te vertrouwd met hex).
enum vs hex:

C#:

LookupTable.Add('A', Segments.Top | Segments.TopLeft | Segments.TopRight | Segments.Middle | Segments.BottomLeft | Segments.BottomRight);
LookupTable.Add('A',0x77);

Ik weet niet of ik de enum variant hier nou veel duidelijker vindt. Dat het veel meer tekst is in combinatie met het feit dat het iets is wat je vrijwel nooit zal veranderen doet mij neigen naar de hex variant.

[Voor 22% gewijzigd door jmzeeman op 30-05-2011 15:37]

[Anoniem: 167624]

De hoeveelheid tekst doet er niet toe. Wat belangrijk is dat als iemand anders (ik nu bijvoorbeeld, of jijzelf over een maand) die regel code ziet staan het bij de eerste regel (enum) gelijk duidelijk is wat er gebeurd terwijl je bij de tweede regel eerst op moet gaan zoeken waar die 0x77 ook al weer voor staat. Dat heeft niks te maken met hoe vertrouwd je ermee bent om hexadecimale getallen te lezen. Ik zie ook direct dat het om bits 0, 1, 2, 4, 5 en 6 gaat, maar daar schiet ik niks mee op, omdat het niet duidelijk is wat bit 0 betekend.

[Patriot]

jmzeeman schreef op maandag 30 mei 2011 @ 15:34:Ik weet niet of ik de enum variant hier nou veel duidelijker vindt. Dat het veel meer tekst is in combinatie met het feit dat het iets is wat je vrijwel nooit zal veranderen doet mij neigen naar de hex variant.

Zelfs in een situatie waarin je het nooit gaat veranderen is het makkelijker, omdat je geen verklarend commentaar hoeft toe te voegen voor anderen die de code in de toekomst gaan doorlezen.

Het is gewoon code die vaak wat meer zegt over wat er precies gebeurd, dat is vooral handig bij het debuggen omdat je direct ziet wat er mis is. Stel ik heb een stukje code die een stukje hardware aanstuurt met vier poorten, voor elke poort een bitje. Als ik dan de 1e, 2e en 4e poort aan wil zetten kan ik dat met de hex waarde 0xD doen, maar dat zegt natuurlijk niet zo heel veel. Dan vind ik het duidelijker om iets te doen in de zin van Ports.Port1 | Ports.Port2 | Ports.Port4. Dan zie je na een week ook nog direct wat die code precies doet.

[Caelorum]

Sterker nog. Je kan ook gewoon bepaalde functionaliteiten in de enum aangeven.
Dus iets als Active(Enum.TurnLightOn)
Dat het dan poort 1 t/m 16 + 19 aanzet zal mij een worst wezen

[Herko_ter_Horst]

De vraag is of er betekenis toe te kennen is aan de verschillende bits die gebruikt worden, anders dan aan/uit. Als het aan/uit is, zou ik gewoon een BitArray gebruiken.

[RobIII]

Ik zou voor elke combinatie van leds die een cijfer vormen op de lcd een enum value maken.

[Herko_ter_Horst]

RobIII schreef op maandag 30 mei 2011 @ 17:09:
Ik zou voor elke combinatie van leds die een cijfer vormen op de lcd een enum value maken.

Dan blijft de vraag hoe je de waardes van de enum inzichtelijk initialiseert. In Java kun je met een enum veel meer kanten op, maar in C# heb je te maken met de onderliggende integerwaarde.

Natuurlijk kun je die eenmalig "uitrekenen" en er dan nooit meer naar kijken, maar ik vraag me af of dat de bedoeling is. De vraag is of er een leesbare (en indien mogelijk: compacte) weergave is van wat de TS wil.

Het voorbeeld van jmzeeman is wat dat betreft zo slecht nog niet (ik ben het overigens geheel met Yexo eens: leesbaarheid is veel belangrijker dan compacte code: het hexadecimale getal is twee stappen verwijderd van wat je eigenlijk bedoelt), alleen zou ik nog overwegen de BitArrays toe te voegen (afhankelijk van of je alleen geinteresseerd bent in de gecombineerde waarde, of ook nog makkelijk wilt kunnen kijken naar de afzonderlijke bits):

C#:

enum Led // naar voorbeeld van roy-t
{
    Top = 0x1,
    UpperLeft = 0x2,
    UpperRight = 0x4,
    Middle = 0x8,
    LowerLeft = 0x10,
    LowerRight = 0x20,
    Bottom = 0x40
}

Dictionary<string, BitArray> ledChars = new Dictionary<string, BitArray>(); // key zou ook char kunnen zijn, als C# dat toestaat?
ledChars.add("1",  new BitArray(Led.UpperRight | Led.LowerRight));
ledChars.add("2", new BitArray(Led.Top | Led.UpperRight | Led.Middle | Led.LowerLeft | Led.Bottom));
ledChars.add("A", new BitArray(Led.Top | Led.UpperLeft | Led.UpperRight | Led.Middle | Led.LowerLeft | Led.LowerRight));

Hiermee is in elk geval inzichtelijk dat de Led uit 7 segmenten bestaat die een bepaalde positie hebben. Door de BitArrays op deze manier te initialiseren, is direct duidelijk welke segmenten aangezet zullen worden (bijkomend voordeel van de bitwise-or: in welke volgorde je ze opgeeft maakt niet uit).

offtopic:
Vergeef me de syntaxfouten, ben een Javaan, geen C#-er.

[Voor 61% gewijzigd door Herko_ter_Horst op 30-05-2011 17:52]

[Caelorum]

Herko_ter_Horst schreef op maandag 30 mei 2011 @ 17:22:
[...]
Dan blijft de vraag hoe je de waardes van de enum inzichtelijk initialiseert. In Java kun je met een enum veel meer kanten op, maar in C# heb je te maken met de onderliggende integerwaarde.

Dat is neit correct:

quote: http://msdn.microsoft.com/en-us/library/sbbt4032(VS.80).aspx

Every enumeration type has an underlying type, which can be any integral type except char.

en MSDN: Integral Types Table (C#)

[Herko_ter_Horst]

Caelorum schreef op maandag 30 mei 2011 @ 17:55:
[...]

Dat is neit correct:

[...]

en MSDN: Integral Types Table (C#)

Hoezo "niet correct"? Er staat toch letterlijk in de tekst wat ik zeg: een enum heeft een onderliggend type, dat kan elk integer-type zijn, behalve char.

In elk geval heb je niet de mogelijkheden van een class, zoals in Java.

[RobIII]

Herko_ter_Horst schreef op maandag 30 mei 2011 @ 17:22:
[...]

Dan blijft de vraag hoe je de waardes van de enum inzichtelijk initialiseert.

Call me old-skool:

C#:

/*
                32                       Zero : 1 + 2 + 4 + 8 + 16 + 32 = 63
                                         One  : 1 + 2 = 3
                 |                       Two  : 32 + 1 + 64 + 8 + 4 = 109
                 |                       Three: 32 + 1 + 64 + 2 + 4 = 103
              ______                     Four : 16 + 64 + 1 + 2 = 83
          __ /      \ __                 Five : 32 + 16 + 64 + 2 + 4 = 118
         /  \\______//  \                Six  : 32 + 16 + 8 + 4 + 2 + 64 = 126
16 ----  |  |        |  |  ------ 1      Seven: 32 + 1 + 2 = 35
         |  | ______ |  |                Eight: 64 + 2 + 4 + 8 + 1 + 32 + 16  = 127
         \__//  64  \\__/                Nine : 64 + 16 + 32 + 1 + 2 + 4 = 119
         /  \\______//  \
8 -----  |  |        |  |  ------ 2
         |  | ______ |  |
         \__//      \\__/
             \______/
                 |
                 |
     
                 4
*/
public enum LCDValues {
    Zero = 63,
    One = 3,
    Two = 109,
    Three = 103,
    Four = 83,
    Five = 118,
    Six = 126,
    Seven = 35,
    Eight = 127,
    Nine = 119
}

Of:

C#:

/*
                32                       
                                         
                 |                       
                 |                       
              ______                     
          __ /      \ __                 
         /  \\______//  \                
16 ----  |  |        |  |  ------ 1      
         |  | ______ |  |                
         \__//  64  \\__/                
         /  \\______//  \
8 -----  |  |        |  |  ------ 2
         |  | ______ |  |
         \__//      \\__/
             \______/
                 |
                 |
     
                 4
*/
public enum LCDValues {
    Zero = 63,      //1 + 2 + 4 + 8 + 16 + 32 = 63
    One = 3,        //1 + 2 = 3
    Two = 109,      //32 + 1 + 64 + 8 + 4 = 109
    Three = 103,    //32 + 1 + 64 + 2 + 4 = 103
    Four = 83,      //16 + 64 + 1 + 2 = 83
    Five = 118,     //32 + 16 + 64 + 2 + 4 = 118
    Six = 126,      //32 + 16 + 8 + 4 + 2 + 64 = 126
    Seven = 35,     //32 + 1 + 2 = 35
    Eight = 127,    //64 + 2 + 4 + 8 + 1 + 32 + 16  = 127
    Nine = 119      //64 + 16 + 32 + 1 + 2 + 4 = 119
}

In sommige gevallen is een fatsoenlijke ASCII-Art comment meer waard dan 1000 woorden
Idem voor andere zaken:

code:

0       +-------------+
        |   HEADER    |  12 bytes Contains identifier "SOMEFOO", major and minor version number (both WORD) and padded with a 0-byte
12      +-------------+
        |     FOO     |  4 bytes Foo-di-derp derp
16      +-------------+
        |   Envelope  |  34..38 bytes Whachamagoo
        | +---------+ |  |
        | |   Bar   | |  +--      4 bytes You get my drift...
        | +---------+ |  |
        | |   Baz   | |  +--     10 bytes Whoopteedoo...
        | +---------+ |  |
        | |  FooBar | |  +-- 20..24 bytes
        | +---------+ |
 50/54  +-------------+
        |             |
        |     ...     |
        |     ...     |

Om maar eens wat te noemen...

[Voor 42% gewijzigd door RobIII op 30-05-2011 19:53]

[PrisonerOfPain]

RobIII schreef op maandag 30 mei 2011 @ 18:57:
[...]


Call me old-skool:
In sommige gevallen is een fatsoenlijke ASCII-Art comment meer waard dan 1000 woorden

Als iedereen het zo eens zou doen

[RobIII]

PrisonerOfPain schreef op maandag 30 mei 2011 @ 19:09:
[...]


Als iedereen het zo eens zou doen

Mja, dit is nog wel te doen; in andere gevallen ben je bijv. afhankelijk van (diepgaande) domeinkennis en andere zaken. Dan red je het niet altijd op een dergelijke manier In zo'n geval verwijs je gewoon naar externe documentatie of andere bronnen.

[Caelorum]

Herko_ter_Horst schreef op maandag 30 mei 2011 @ 18:00:
[...]

Hoezo "niet correct"? Er staat toch letterlijk in de tekst wat ik zeg: een enum heeft een onderliggend type, dat kan elk integer-type zijn, behalve char.

Nee dat zei je niet. Je zei "maar in C# heb je te maken met de onderliggende integerwaarde.". Integer != elk numeriek type.

Maar dit is veels te offtopic allemaal...

[Woy]

Caelorum schreef op maandag 30 mei 2011 @ 21:00:
[...]

Nee dat zei je niet. Je zei "maar in C# heb je te maken met de onderliggende integerwaarde.". Integer != elk numeriek type.

Maar dit is veels te offtopic allemaal...

Wikipedia: Integer (informatica)

Integer betekent niet perse Int32

[Caelorum]

Woy schreef op maandag 30 mei 2011 @ 22:18:
[...]

Wikipedia: Integer (informatica)

Integer betekent niet perse Int32

In dat geval my bad.

[.oisyn]

Herko's hele punt was dat een enum in C# gewoon een integer-type is, terwijl het in Java een class instance is, waar je methods op kunt definieren.

Kan in C# overigens ook wel weer, door een class te maken met een private construtor en wat public static instances. Vergelijkbaar met hoe Java het deed voor versie 5

[creator1988]

Je kan in je enum ook weer flags combineren btw.

C#:

[Flags]
public enum Test
{
    A = 0x01,
    B = 0x02,
    C = Test.A | Test.B
}

[SimonBlok]

Ik ben eruit! Ik heb alles met enums opgelos, vond ik het meest overzichtelijk. Ook de tip voor het gebruik maken van een voorgedefinieerde segmentarray met hierin alle segmenten vond ik een goeie! Bedankt iedereen voor de vele oplossingen, ben een hoop wijzer geworden zo.

C#:

[Flags]
        enum segments
        {
            top         = 0x02,
            topLeft     = 0x01,
            topRight    = 0x04,
            center      = 0x08,
            bottomLeft  = 0x80,
            bottomRight = 0x20,
            bottom      = 0x40,
            dot         = 0x10
        }        
        
        enum segmentChars
        {
            zero = segments.topLeft | segments.top | segments.topRight | segments.bottomRight | segments.bottom | segments.bottomLeft,
            one = segments.topRight | segments.bottomRight,
            two = segments.top | segments.topRight | segments.center | segments.bottomLeft | segments.bottom,
            three = segments.top | segments.topRight | segments.center | segments.bottomRight | segments.bottom,
            four = segments.topLeft | segments.topRight | segments.center | segments.bottomRight,
            five = segments.topLeft | segments.top | segments.center | segments.bottomRight | segments.bottom,
            six = segments.topLeft | segments.top | segments.center | segments.bottomRight | segments.bottom | segments.bottomLeft,
            seven = segments.top | segments.topRight | segments.bottomRight,
            eight = segments.topLeft | segments.top | segments.topRight | segments.center | segments.bottomRight | segments.bottom | segments.bottomLeft,
            nine = segments.topLeft | segments.top | segments.topRight | segments.center | segments.bottomRight | segments.bottom,
        }

Nu zit ik echter nog met een ander probleempje: bij het opvragen van een waarde uit de "segmentChars-enum" wil ik dynamisch een key opvragen. Ik wil dus opvragen: segmentChars.$keyName (PHP-style). Dit werkt niet, maar hoe kan ik toch dynamisch zo'n waarde opvragen? Een enum is geen object was handige methoden heeft om dit te doen namelijk. Iemand tips?

[Caelorum]

saimen schreef op dinsdag 31 mei 2011 @ 19:43:
Nu zit ik echter nog met een ander probleempje: bij het opvragen van een waarde uit de "segmentChars-enum" wil ik dynamisch een key opvragen. Ik wil dus opvragen: segmentChars.$keyName (PHP-style). Dit werkt niet, maar hoe kan ik toch dynamisch zo'n waarde opvragen? Een enum is geen object was handige methoden heeft om dit te doen namelijk. Iemand tips?

Bedoel je zoiets: http://stackoverflow.com/...482/cast-int-to-enum-in-c ?

[Woy]

MSDN: Enum.Parse Method (System) is je vriend daarvoor