Mehrere Bytearrays zu einem

  • VB.NET

Es gibt 18 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Wie wäre es mit einer List(Of Byte):

    VB.NET-Quellcode

    1. Dim bb As New List(Of Byte)
    2. Dim a1() As Byte = {1, 2, 3}
    3. Dim a2() As Byte = {11, 12, 13}
    4. Dim a3() As Byte = {21, 22, 23}
    5. bb.AddRange(a1)
    6. bb.AddRange(a2)
    7. bb.AddRange(a3)
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Hi
    oder

    VB.NET-Quellcode

    1. Shared Function Concat(ByVal ParamArray arrays()() As Byte) As Byte()
    2. Dim target() As Byte
    3. Dim len As Long
    4. For Each ba As Byte() in arrays
    5. len += ba.LongLength
    6. Next
    7. target = DirectCast(Array.CreateInstance(GetType(Byte), len), Byte())
    8. len = 0
    9. For Each ba As Byte() in arrays
    10. Array.Copy(ba, ba.GetLowerBound(0), target, len, ba.LongLength)
    11. len += ba.LongLength
    12. Next
    13. Return target
    14. End Function

    (arrays mit unterer Grenze sieht man allerdings eh nie, also wäre das GetLowerBound evtl. auch zu vernachlässigen)

    Next

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „~blaze~“ ()

    :whistling: Wie benutzt man deine Concat-Funktion?
    Bei mir wird in Zeile 5 das a1 angemeckert:
    Ein Wert des Typs "1-dimensionales Array von Byte" kann nicht in "1-dimensionales Array von 1-dimensionales Array von Byte" konvertiert werden, da "Byte" nicht von "1-dimensionales Array von Byte" abgeleitet ist.
    Ich habe FW4.0 eingestellt...

    VB.NET-Quellcode

    1. Dim a1() As Byte = {1, 2, 3}
    2. Dim a2() As Byte = {11, 12, 13}
    3. Dim a3() As Byte = {21, 22, 23}
    4. '
    5. Dim a4() As Byte = Concat(a1)


    Kommando zurrück, ich habs...

    VB.NET-Quellcode

    1. Dim a4() As Byte = Nothing
    2. a4.Concat(a1)

    geht auch nicht :whistling:

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „VB1963“ ()

    So sollte es tun. Jetzt kannst du es einfach so übergeben, wie du wolltest, ohne das ParamArray würde es

    VB.NET-Quellcode

    1. Concat(New Byte()(){a, b, c})

    heißen müssen, also ein Array von einem Array. Kann man übrigens auch noch für beliebige T definieren:

    VB.NET-Quellcode

    1. Shared Function Concat(Of T)(ByVal ParamArray arrays()() As T) As T()
    2. If arrays Is Nothing Then Throw New ArgumentNullException("arrays")
    3. Dim target() As T
    4. Dim len As Long
    5. For Each ba As T() in arrays
    6. len += ba.LongLength
    7. Next
    8. target = DirectCast(Array.CreateInstance(GetType(T), len), T())
    9. len = 0
    10. For Each ba As T() in arrays
    11. Array.Copy(ba, ba.GetLowerBound(0), target, len, ba.LongLength)
    12. len += ba.LongLength
    13. Next
    14. Return target
    15. End Function


    Gruß
    ~blaze~

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „~blaze~“ ()

    List(Of T) macht übrigens sogesehen alles ähnlich. Ein T-Array liegt der Liste zugrunde, es verfügt über eine int-Variable, die die aktuelle Zahl der Elemente count festhält und noch paar andere Sachen. Das Array ist nicht unbedingt so groß wie count und die tatsächliche Array-Kapazität müsste man vorher berechnen, sonst muss das darunterliegende Array jedes mal vergrößert werden. Arrays sind aber an sich Speicherblöcke mit fester Größe, d.h. es muss komplett neuer Speicher angefordert und bestehender kopiert werden, wenn das Array zu klein wird und das kann sich bei einer großen Zahl an T-Arrays extrem stark auf die Performance auswirken. D.h. normalerweise berechnet man vorher die Kapazität und übergibt sie an den Konstruktor oder die Capacity-Eigenschaft oder man macht's gleich selber, dann fällt der ToArray-Aufruf auch noch mit weg, da müssen halt ebenfalls ein neues Array angelegt und die Daten reinkopiert werden (wobei das nicht "so" schlimm ist, wie ständige Vergrößerungen).

    Gruß
    ~blaze~

    LinkedList(Of T). Das Problem bei verketteten Listen ist halt, dass sie nicht in dem Sinne ILists sind, da eine Indizierbarkeit wegfällt. Außerdem sind halt Speicherverbrauch und "Fragmentierung" höher, während bei einem Array die einzelnen Speicherblöcke sequentiell angeordnet sind und sich Anfang und Ende durch Zeiger bzw. Zahlen bestimmen lassen.

    Gruß
    ~blaze~

    Z.B. das Einfügen von Elementen in eine bestehende Liste. Bei einem Array müsste ggf. das Array erst vergrößert werden, danach alle Elemente am und nach dem Index, an dem das Element eingefügt wird, nach hinten verschoben werden und danach das Element gesetzt werden. Bei verketteten Listen wird einfach nur Next vom Vorgänger und Previous vom Nachfolger neu gesetzt.
    Da das mit dem Array vllt. bisschen unverständnlich ist, hier mal meine Art, es zu implementieren:

    VB.NET-Quellcode

    1. Private ReadOnly _underlyingArray() As T
    2. Private ReadOnly _hold As Integer = 256 'Differenz, um die ein zu kleiner Puffer vergroessert werden soll
    3. Private _count As Integer
    5. Public Sub Insert(ByVal index As Integer, ByVal item As T) Implements IList(Of T).Insert
    6. If index < 0 OrElse index > _underlyingArray.Length Then Throw New IndexOutOfRangeException("index")
    7. Extend(1) 'ggf. um mind. 1 Element vergrößern
    8. 'Alle Elemente ab index um 1 nach hinten verschieben
    9. Array.Copy(_underlyingArray, index, _underlyingArray, index + 1, _underlyingArray.Length - index)
    10. _underlyingArray(_count) = item 'Element setzen
    11. _count += 1
    12. End Sub
    14. Private Sub Extend(ByVal delta As Integer)
    15. Dim size As Integer = _count + delta
    16. If size > _underlyingArray.Length Then
    17. Array.Resize(_underlyingArray, size + _hold - size Mod _hold) 'auf ein Vielfaches von _hold vergroessern
    18. End If
    19. End Sub

    Ist jetzt wieder aus dem Kopf implementiert, kann also gut sein, dass Logikfehler enthalten sind (oder Fehler :P). Das Prinzip sollte aber erkennbar sein.

    Gruß
    ~blaze~

    Quadsoft schrieb:

    hm, was ist dann überhaupt ein vorteil der verketteten listen?

    Ich hab die MS-LinkedList noch nie sinnvoll einsetzen können.
    Es kam durchaus vor, dassich mal eine doppelt verkettete Liste gebraucht hab, aber am Ende stellte sich olle List(Of T) doch als praktischer heraus.
    Und einmal, für eine Undo-Verwaltung, was ja eiglich die Klassische Anwendung einer LinkedList sein sollte, hat die MS-LinkedList immer noch nicht getaugt, und ich hab mir eine eigene LinkedList geschrieben.

    Man muß auch bedenken, dass List(Of T) irrsinnig grauenhaft schnell ist. Ist ziemlich sch...-egal, dass da zum Einfügen und Removen immer der ganze Salat umkopiert wird.
    Das erfolgt hochoptimiert, ich glaub sogar mit speziellen Prozessorbefehlen.

    ein Bekannter wolltemal die .Net Auflistungsklassen alle neu schreiben, weiler die vom Design her vermurkst fand. Hat er aufgegeben, weil das schnellste, wasser zuwege brachte, immer noch zig mal langsamer war als die doofe List(oft).
    Weil da kanner ganz fabelhaftes Design programmieren - benutzen wird das keiner :(

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

Facebook
Telefonspende