byte[] Array in einzlene Arrays aufteilen?

BorisDieKlinge

Guten Morgen,

habe bspw.

byte[] tmp = new byte[120];

nun will ich das in 6 teil jeweils 20 byte splitten...

wer verrät mir die schönste oder effizientes möglichkeit??

und dann das ganze wieder zusammenstückeln später;) lg

meine lösung:

byte[][] part = new byte[6][];

            MemoryStream buf = new MemoryStream(tet);

            buf.Read(part[0], 0, 20);
            buf.Read(part[1], 20, 20);
            buf.Read(part[2], 40, 20);
            buf.Read(part[3], 60, 20);
            buf.Read(part[4], 80, 20);
            buf.Read(part[5], 100, 20);

oder gibt ne effizientere lösung?

oneill5000

was meinst du mit "splitten"? was soll das ergebnis dieses splittens sein?

BorisDieKlinge

ich hab eine bytesteam von n-Bytes, und will dieses in x-Part Byte Packet (datenübertragung) splitten und später wieder zusammensetzen.

PuppetMaster2k

Vielleicht ließe sich da was mit Linq machen, sofern du Linq nutzen kannst. Da gäbe es dann die Möglichkeit Skip() und Take() einzisetzen.

EXDW

aus dem bauch heraus wuerd ich sagen:

byte[] tmp = ByteArrayFromSomwhere();
List<List<byte>> splittedLists = SplitArray(tmp, 20);

List<List<byte>> SplitArray(byte[] originalArray, int partLength)
{
    List<List<byte>> splittedList = new List<List<byte>>();
    for(int i = 0; i < originalArray.length; ++i) // eventuell das ++i weg lassen, weiss ich grad nicht
    {
        List<byte> part = new List<byte>();
        for(int j = 0; j < partLength && i < originalArray.length; ++j, ++i)
            part.Add(tmp[i]);
        splittedList.Add(part);
    }
    return splittedList
}

weiss nicht obs funzt, war beim tippen ausgedacht
ich seh den vorteil darin das die letzte liste auch nur die restlichen bytes enthaellt - auch wenn es nur 15 statt 20 sind

oneill5000

@BorisDieKlinge

weißt du ob buf immer genau 120 Byte enthält?
ansonsten bietet msdn eigentlich die selbe lösung an wie du sie genommen hast...

//...
byte[] byteArray;
MemoryStream memStream = new MemoryStream(100);
//...memStream wird gefüllt...
// Read the first 20 bytes from the stream.
byteArray = new byte[memStream.Length];
count = memStream.Read(byteArray, 0, 20);
//...

BorisDieKlinge

ne der quellbuffer ist nicht immer 120 bytes groß, wobei die Packet größe anfsngs definiert wird.. ich habs mit memory buffer gemacht

MemoryStream ms = new MemoryStream(SourceByteArray);
List<byte> foo = new List<byte>();

for(int i=0; i< SourceByteArray.Length/n; ms.Read((part=new byte[n]),0,n), i++)
  foo.Add(part);

ms.Read((part=new byte[SoruceByteArray.Length%n],0,SoruceByteArray.Length%n);
foo.Add(part);

so ungefähr;)