Ottenere dai suoi singoli dati-byte un valore numerico di tipo superiore al Byte

Volendo estrarre un valore di dimensioni superiori al tipo Byte, memorizzato in un flusso di dati oppure in un'area di memoria riservata oppure in un vettore di tipo Byte[], si potrà procedere come appresso indicato.

Se il valore può essere rappresentato da un Integer

Poniamo il caso che il valore da estrapolare sia il seguente Integer: 1122867.

1^a modalità

Public Sub Main()

 Dim bb As Byte[] = [&33, &22, &11, &00]
 Dim i As Integer
 
' Dereferenziamo il "Puntatore" restituito dalla proprietà .Data del vettore: 
 i = Int@(bb.Data)
  
 Print i
   
End

e similmente con gli altri tipi di dati superiori al Byte.

2^a modalità

Public Sub Main()
 
 Dim i As Integer

' Se i byte, che nel file rappresentano quel numero, sono disposti secondo l'ordine "Little-Endian", allora:
 Dim bb As Byte[] = [&33, &22, &11, &00]
 
 i = CInt(bb[3]) * 16777216     ' &01000000
 i += bb[2] * 65536             ' &010000
 i += bb[1] * 256               ' &0100
 i += bb[0]
 
' Se, invece, l'ordine dei byte è "Big-Endian", allora la sequenza degli indici dei singoli elementi del vettore sarà invertita:
 ' Dim bb As Byte[] = [&00, &11, &22, &33]
 
 ' i = CInt(bb[0]) * 16777216
 ' i += bb[1] * 65536
 ' i += bb[2] * 256
 ' i += bb[3]

  Print i
   
End

Se il valore può essere rappresentato solo da un Long

Se la grandezza del valore può essere rappresentata solo da un Long, allora si potrà procedere come segue.

Ad esempio si deve estrarre un valore memorizzato da 4 byte &FF &FF &FF &FF in Little-Endian:

Public Sub Main()
 
 Dim bb As Byte[] = [&FF, &FF, &FF, &FF]
 Dim l As Long
 
 l = CLong(bb[3]) * 16777216    ' &01000000
 l += bb[2] * 65536             ' &010000
 l += bb[1] * 256               ' &0100
 l += bb[0]
 
 Print l, Hex(l, 8)
 
End

Se invece il valore è memorizzato in Big-Endian:

Public Sub Main()
 
 Dim bb As Byte[] = [&FF, &FF, &FF, &FF]
 Dim l As Long
 
 l = CLong(bb[0]) * 16777216    ' &01000000
 l += bb[1] * 65536             ' &010000
 l += bb[2] * 256               ' &0100
 l += bb[3]
 
 Print l, Hex(l, 8)
 
End

3^a modalità

Si potrà anche effettuare uno spostamento a sinistra dei bit di ciascun byte-valore letto a partire dal secondo.

Se il valore, rappresentabile solo con il tipo di dati Long, è memorizzato in Little-Endian:

Public Sub Main()
 
 Dim l As Long
 Dim bb As Byte[] = [&33, &22, &11, &FF]   ' 4279312947
 
 l = CLong(bb[0])
 l += CLong(Shl(CInt(bb[1]), 8))
 l += CLong(Shl(CInt(bb[2]), 16))
 l += CLong(Shl(CLong(bb[3]), 24))
 
' Altresì utilizzando l'operatore OR:
 ' l = CLong(bb[0])
 ' l = l Or CLong(Shl(CInt(bb[1]), 8))
 ' l = l Or CLong(Shl(CInt(bb[2]), 16))
 ' l = l Or CLong(Shl(CLong(bb[3]), 24))
 
 Print l, Hex(l, 8)
 
End

Se il valore, rappresentabile solo con il tipo di dati Long, è memorizzato in Big-Endian:

Public Sub Main()
 
 Dim l As Long
 Dim bb As Byte[] = [&FF, &11, &22, &33]   ' 4279312947
 
 l = CLong(Shl(CLong(bb[0]), 24))
 l += CLong(Shl(CInt(bb[1]), 16))
 l += CLong(Shl(CInt(bb[2]), 8))
 l += CLong(bb[3])
 
' Altresì utilizzando l'operatore OR:
 ' l = CLong(Shl(CLong(bb[0]), 24))
 ' l = l Or CLong(Shl(CInt(bb[1]), 16))
 ' l = l Or CLong(Shl(CInt(bb[2]), 8))
 ' l = l Or CLong(bb[3])
 
 Print l, Hex(l, 8)
 
End