Base64-codering in Visual Basic: een complete gids

Hier is een probleem dat Visual Basic-ontwikkelaars al vijfentwintig jaar tegenkomen: je hebt een JPEG, een binaire blob, een licentiebestand of een volstrekt gewone zin, en het kanaal dat voor je ligt accepteert alleen tekst. Een JSON-veld, een omgevingsvariabele, een e-mailbijlage, een URL, een configbestand, een databasekolom getypeerd als tekst, en alle andere deuren in het gebouw delen één regel: alleen afdrukbaar tekens. Base64 is de poortwachter die binair binnenlaat. Hij schrijft je bytes om als een stroom van letters, cijfers, plus, slash en equals, zodat alles wat als tekst reist ze kan meedragen. En het goede nieuws: elk onderdeel van de encoder dat je ooit zult nodig hebben, zit al in de .NET-runtime. Geen pakketten, geen componenten, geen ceremonie.

In één adem, want de startpagina van deze site gaat diep in op het formaat zelf: Base64 neemt drie invoerbytes en schrijft ze weg als vier tekens uit een alfabet van 64 symbolen, en voegt één of twee =-tekens aan de staart toe wanneer het aantal bytes niet exact deelbaar is. Die vier-voor-drie-ruil is de reden waarom gecodeerde data ongeveer een derde groter is dan het origineel, de beruchte groottebelasting die je eenmaal per encoding betaalt. Alles anders in dit artikel gaat over het maken van je encoding zodat die precies doet wat het volgende systeem verwacht: het juiste alfabet, de juiste padding, de juiste regelafbrekingen en de juiste charset.

De encoder-gereedschapskist: alles is ingebouwd

De encoderingskant van de runtime groeide over dezelfde vier golven als de decoderingskant, dus de gereedschapskist heeft een lange staart van nog steeds ondersteunde opties. Hier is de volledige familie en het werk waarvoor elk van hen is gemaakt:

Voor het versielandschap: .NET 10 is de huidige long-term-support-lijn (november 2025, ondersteund tot november 2028), .NET 8 en .NET 9 worden ondersteund tot november 2026, en .NET 11 is in preview met een verse reeks Base64-gemaksmethoden onderweg. Alles in de tabel hierboven is stabiel over al die versies heen. Het enige versiedrempel is Base64Url: ingebouwd vanaf .NET 9, beschikbaar op .NET Framework 4.6.2 en nieuwer via het Microsoft.Bcl.Memory-pakket, en dat is het enige pakket dat dit artikel ooit van je vraagt te installeren. Om een los werkproject te starten, levert de .NET SDK Visual Basic mee:

dotnet new console -lang VB -o Packer
cd Packer
dotnet run

Je eerste encoding: bytes erin, tekst eruit

Negentig procent van het encoderingsleven in Visual Basic is twee aanroepen, en de volgorde telt: de encoder neemt bytes, geen tekst, dus als je met een string begint kies je eerst een encoding om hem naar bytes te zetten, en pas daarna kom je de Base64-stap. Dit is de hele dans:

Imports System
Imports System.Text
Module Encoder
    Sub Main()
        Dim text As String = "Man"
        Dim bytes() As Byte = Encoding.UTF8.GetBytes(text)
        Dim packed As String = System.Convert.ToBase64String(bytes)
        Console.WriteLine(packed)
        ' TWFu
    End Sub
End Module

Dat middendeel van drie regels is het hele ambacht, en de string "TWFu" is de perfecte rooktest voor elke encoder die je schrijft. De overloads geven je controle zodra je die nodig hebt. De vormen voor array-onderdelen coderen een stuk van een array zonder dat stuk eerst naar buiten te kopiëren, wat handig is wanneer de echte payload in een grotere buffer zit:

Imports System
Module SlicePacker
    Sub Main()
        Dim data() As Byte = {1, 2, 3, 4, 5, 6, 7, 8}
        Dim packed As String = System.Convert.ToBase64String(data, 2, 4)
        Console.WriteLine(packed)
        ' AwQFBg==  (alleen de bytes 3 tot 6 werden gecodeerd)
    End Sub
End Module

En de array-naar-karaktervorm, ToBase64CharArray, schrijft naar een karakterbuffer die je reserveert en vertelt je hoeveel tekens hij vulde, wat het juiste gereedschap is wanneer de bestemming deel is van een grotere tekststructuur die je handmatig bouwt. Houd de huishoudregel voor de Visual Basic-syntaxis in gedachten: een byte-array wordt geschreven als Byte() met de lege haakjes. Laat ze weg en je hebt een enkele byte, en Option Strict On (standaard uit in de templates - de moeite waard om in elk project aan te zetten) vangt de verwarring op compileertijd.

De uitvoer vormen: padding, regelafbrekingen en exacte maten

Dezelfde bytes twee keer encoderen kan legitiem twee verschillende strings opleveren, en de verschillen komen allemaal door de vormgeving van de uitvoer. Eerst padding: wanneer de inputlengte geen veelvoud van drie is, vult de encoder de laatste groep aan met één of twee =-tekens. De RFC zegt om ze op te nemen tenzij de specificatie die je volgt anders zegt, en ToBase64String neemt ze standaard op. Ten tweede regelafbrekingen: de tweede parameter van de formatoverloads, Base64FormattingOptions.InsertLineBreaks, laat de encoder regels van 76 tekens uitscheiden, gescheiden door CRLF, en dat is exact de MIME-regel. MIME zelf gebruikt een limiet van 76 tekens, een nauw familielid van de oude regels van 64 tekens van PEM, en beide limieten gaan terug tot beperkingen binnen SMTP. Als je consument een e-mailpipeline is, zet regelafbrekingen aan; als het een URL, een JSON-veld of een databasekolom is, laat ze uit, want een onzichtbare CRLF in je data zal een weg vinden om je later te verrassen:

Imports System
Module MimePacker
    Sub Main()
        Dim data(113) As Byte
        For i As Integer = 0 To 113
            data(i) = CByte(i)
        Next
        Dim wrapped As String = System.Convert.ToBase64String(data, Base64FormattingOptions.InsertLineBreaks)
        Console.WriteLine(wrapped.Length)
        ' 154: twee regels van 76 tekens plus één CRLF ertussenin
    End Sub
End Module

Ten derde exacte maten, want je zult buffers en kolombreedtes willen vooraf reserveren. De regel is vier tekens per drie invoerbytes, afgerond naar boven: 1000 bytes wordt 1336 tekens. In plaats van de somming zelf te doen, heeft de runtime een helper die de maximale gecodeerde lengte teruggeeft voor een gegeven inputgrootte, en dat is wat je doorgeeft aan de bufferallocatie:

Imports System.Buffers.Text
Module Sizing
    Sub Main()
        Dim dataLength As Integer = 1000
        Dim textNeeded As Integer = Base64.GetMaxEncodedToUtf8Length(dataLength)
        Console.WriteLine(textNeeded)
        ' 1336
    End Sub
End Module

Diezelfde vier-voor-drie-verhouding is de groottebelasting in haar zuiverste vorm: elke gecodeerde waarde is zo'n 33 procent groter dan de bytes die hij draagt, dus plan je opslag- en overdrachtsgroottes met die marge in gedachten. En één gedrag is het weten waard vóórdat het je bijt: als je een string decodeert en daarna het resultaat opnieuw encodeert, is de nieuwe string niet gegarandeerd identiek aan de oorspronkelijke, want witruimte verdwijnt en padding wordt genormaliseerd. Vergelijk gedecodeerde bytes wanneer je waarden moet vergelijken, niet de gecodeerde tekst.

De charset kiezen vóórdat je encodeert

Omdat de eerste stap van het encoderen van tekst "string naar bytes" is, beslist de charset die je kiest wat de ontvanger ziet wanneer hij decodeert. Visual Basic-strings zijn UTF-16 binnen de runtime, maar de bytes die je uitzendt moeten passen bij wat de andere kant verwacht te lezen, en het menu aan keuzes is kort:

• Encoding.UTF8: de juiste standaard voor het web, API's en alles wat modern is. Zij rondreist elk Unicode-karakter dat de taal kan dragen.
• Encoding.Unicode: UTF-16 little-endian. Een redelijke keuze wanneer beide uiteinden van de pijp .NET-programma's zijn die expliciet afspraken over UTF-16 maakten, en niets meer.
• Encoding.ASCII: alleen 7-bit, en hij zal alles anders stilletje vervangen door een vraagteken. "Café" als ASCII encoderen geeft je de bytes voor "Caf?", en dat decodeert terug naar precies dat, vraagteken en al.
• Encoding.Default: op .NET Framework was dit de ANSI-codepagina van de machine, maar op .NET (Core) is het altijd UTF-8, ongeacht de locale. Vermijd het ook nog steeds voor data die je uitwisselt - noem de encoding expliciet, meestal UTF-8.

Imports System
Imports System.Text
Module CharsetPacker
    Sub Main()
        Dim text As String = "Café"
        Dim utf8() As Byte = Encoding.UTF8.GetBytes(text)
        Dim ascii() As Byte = Encoding.ASCII.GetBytes(text)
        Console.WriteLine(System.Convert.ToBase64String(utf8))
        ' Q2Fmw6k=
        Console.WriteLine(System.Convert.ToBase64String(ascii))
        ' Q2FmPw==  (het accent werd een vraagteken)
    End Sub
End Module

Twee verschillende Base64-strings, één woord, en slechts één van hen overleeft de rit. De praktische regel: tenzij het protocol die je volgt een ander schema noemt, encodeer tekst als UTF-8 en zeg het ook.

Base64Url: het alfabet dat URLs overleeft

Het standaard alfabet bevat + en /, en beide tekens hebben binnen URLs hun eigen baantjes, dus Base64 gebouwd op dat alfabet breekt zodra het in een query string of een padsegment belandt. De oplossing, gestandaardiseerd in sectie 5 van RFC 4648, vervangt de twee overtreders door - en _, die URL-safe zijn, en haalt doorgaans de padding aan de staart weg omdat de datalengte de decoder al zegt waar de data eindigt. Deze variant, bekend als base64url, is het alfabet van JWTs, API-tokens en een groeiend aantal API's. .NET 9 voegde een toegewijde klasse toe voor dit alfabet, en die is gebouwd met één mening die het weten waard is: hij laat padding met opzet weg:

Imports System.Buffers.Text
Module UrlSafePacker
    Sub Main()
        Dim data() As Byte = {219, 255, 0, 63, 16}
        Dim packed As String = Base64Url.EncodeToString(data)
        Console.WriteLine(packed)
        ' 2_8APxA  (onderstreep, geen padding aan de staart)
    End Sub
End Module

Het voorbeeld hierboven is een goede: de gekozen bytes laten één van de speciale tekens verschijnen - de onderstreep, waar het standaard alfabet een slash heeft - zodat je de swap live kunt zien. Wanneer je op een oudere runtime zit, is hetzelfde alfabet twee karaktersvervellingen plus een trim, en je krijgt een drop-in compatibel resultaat:

Imports System
Module CompatPacker
    Function ToUrlSafe(ByVal packed As String) As String
        Return packed.Replace("+"c, "-"c).Replace("/"c, "_"c).TrimEnd("="c)
    End Function
End Module

Op .NET Framework 4.6.2 of nieuwer geeft het Microsoft.Bcl.Memory-pakket je in plaats daarvan de echte Base64Url-klasse. In beide gevallen: let op de padding-linie in het zand: de uitvoer van .NET's Base64Url heeft geen padding, terwijl sommige bibliotheken in andere ecosystemen hem toevoegen (en een paar strikte decoders eisen hem zelfs). JWT vereist bijvoorbeeld de vorm zonder padding, dus is de .NET-standaard daar precies goed. Wanneer je een ecosysteemgrens oversteekt, controleer dan de verwachting van de andere kant vóórdat je de string verstuurt.

Bestanden inpakken

Bestanden zijn het oorspronkelijke gebruik: maak van een binair bestand een tekstbestand dat e-mail, FTP en configuratiesystemen allemaal met plezier dragen. In Visual Basic is het hele werk drie aanroepen, waarvan er één leest en er één schrijft:

Imports System.IO
Module FilePacker
    Sub Main()
        Dim bytes() As Byte = File.ReadAllBytes("photo.png")
        Dim packed As String = System.Convert.ToBase64String(bytes)
        File.WriteAllText("photo.b64", packed)
    End Sub
End Module

Houd de grootteverhouding in je zak: een foto van 10 megabyte wordt een tekstbestand van zo'n 13,4 megabyte. De bewerking is snel op moderne hardware (meer daaronder), dus de kosten zijn vrijwel altijd opslag en bandbreedte in plaats van CPU, wat de gebruikelijke rekening is voor een 33-procent-belasting. Wanneer het bestand alleen naast de tekst zal wonen die ernaar verwijst, is dit patroon prima; wanneer het bestand groot en langlevend is, vraag je jezelf af of het kanaal de tekstvorm überhaupt nodig heeft.

Afbeeldingen: data-URIs handmatig bouwen

Het data-URI-schema (RFC 2397) embedt de inhoud van een bestand direct in een URL: data:, de media type, de letterlijke marker ;base64, een komma en de gecodeerde bytes. Browsers gebruiken ze om kleine afbeeldingen en lettertypes inline te zetten. WPF kan een data-URI niet direct consumeren - BitmapImage heeft geen handler voor het data:-schema - dus de idiomatische zet is het prefix afstrepen en de bytes aan een MemoryStream te geven. De URI bouwen in Visual Basic is één string-concatenatie, en consumeren is een klein init-blok:

Imports System.IO
Imports System.Windows.Media.Imaging
Module DataUriPacker
    Sub Main()
        Dim bytes() As Byte = File.ReadAllBytes("logo.png")
        Dim dataUri As String = "data:image/png;base64," & System.Convert.ToBase64String(bytes)
        Dim image As New BitmapImage()
        image.BeginInit()
        image.StreamSource = New MemoryStream(System.Convert.FromBase64String(dataUri.Substring(dataUri.IndexOf(","c) + 1)))
        image.EndInit()
        ' de image kan nu worden toegewezen aan een Image-control
    End Sub
End Module

De RFC zelf waarschuwt dat data-URIs alleen nuttig zijn voor korte waarden, en HTML-documenten stellen hun eigen lengtelimieten voor attributes, dus de verstandige omvang is iconen, avatars, thumbnails en kleine achtergrondpatronen. De media type moet matchen met de bytes die je daadwerkelijk encodeerde, want nergens stroomafwaarts wordt hij opnieuw afgeleid uit de inhoud.

HTTP: auth-headers en JSON-payloads

Op de draad zijn de twee plekken waar je handmatig encodeert de HTTP Basic auth-header en JSON-velden die binaire of vooraf gecodeerde data meedragen. Basic auth is het meest zichtbaar: de header is het woord Basic, een spatie, en de Base64 van username:password met een dubbele punt samengevoegd. Die bouwen is één encoding-aanroep:

Imports System
Imports System.Text
Module AuthPacker
    Function MakeBasicHeader(ByVal user As String, ByVal password As String) As String
        Dim raw() As Byte = Encoding.UTF8.GetBytes(user & ":" & password)
        Return "Basic " & System.Convert.ToBase64String(raw)
    End Function
End Module

Het JSON-geval is even routine. Wanneer een API een afbeelding of een certificaat in een request body wil, encodeer je de bytes en laat je de string in de payload vallen, en System.Text.Json (meegeleverd sinds .NET Core 3.0) behandelt de serialisatie eromheen:

Imports System.Text.Json
Module ApiPacker
    Function WidgetPayload(ByVal name As String, ByVal imageBytes() As Byte) As String
        Dim payload = New With {
            .name = name,
            .image = System.Convert.ToBase64String(imageBytes)
        }
        Return JsonSerializer.Serialize(payload)
    End Function
End Module

Twee huishoudregels: verzend credentials alleen over HTTPS, want over plain HTTP is de Base64 een kostuum, geen slot, en log nooit de rauwe auth-header of de credentials waarnaar die decodeert.

E-mailbijlagen en MIME-verpakking

E-mail is waar Base64 zijn brood verdiende. SMTP werd gebouwd voor 7-bit ASCII, dus een binaire bijlage moet eerst tekst worden vóórdat hij kan vliegen, en de MIME-standaard (RFC 2045) maakte de keuze: Base64, verpakt na 76 tekens per regel, aangegeven met een Content-Transfer-Encoding: base64-header. Wanneer je werkt met de System.Net.Mail-klassen, is het hele ritueel twee regels setup, want de mail-bibliotheek verpakt voor je op het moment van verzenden:

Imports System.IO
Imports System.Net.Mail
Imports System.Net.Mime
Module MailPacker
    Sub Main()
        Using message As New MailMessage("me@example.com", "you@example.com")
            message.Subject = "Quarterly report"
            message.Body = "Please find the report attached."
            Using stream As New FileStream("report.bin", FileMode.Open, FileAccess.Read)
                Dim attachment As New Attachment(stream, "report.bin")
                attachment.TransferEncoding = TransferEncoding.Base64
                message.Attachments.Add(attachment)
            End Using
        End Using
    End Sub
End Module

Je hoeft de verpakte vorm zelf alleen te produceren, met Base64FormattingOptions.InsertLineBreaks, wanneer je rauwe MIME-tekst handmatig schrijft: een mailer-testfixture, een legacy gateway, of een tool die .eml-bestanden uit spuwt. De regel van 76 tekens is geen stijlkeuze; sommige ontvangende systemen knippen langere regels, en daarom is de limiet tientallen jaren in de standaard overleefd.

Gecodeerde waarden opslaan: databases, config-bestanden en omgevingsvariabelen

Opslag die alleen tekst accepteert blijft Base64 vragen: een databasekolom getypeerd als tekst, een XML-configuratiewaarde, een omgevingsvariabele. Je encodeert de bytes, slaat de string op, en decodeert hem bij de terugweg. De encoderingskant is altijd dezelfde éénregelaar, maar de opslagkant heeft limieten die de groottebelasting tastbaar maken. Een gewone VARCHAR-kolom in SQL Server stopt bij 8.000 tekens (een NVARCHAR-kolom stopt bij de helft, 4.000 tekens, want elk Unicode-karakter kost twee bytes) - 8.000 tekens is ruimte voor zo'n 6.000 bytes binair voordat de 33-procent-overhead je over de rand duwt, daarboven grijp je naar de MAX-types of, eerlijker gezegd, naar een echte binaire kolom. Op Windows is één door de gebruiker gedefinieerde omgevingsvariabele beperkt tot 32.767 tekens (en op XP-tijdperk-systemen was het hele omgevingsblok ook tot die maat beperkt), dus "de hele licentie-blob in een omgevingsvariabele houden" heeft een hard plafond:

Imports System
Module EnvPacker
    Sub Main()
        Dim blob() As Byte = {1, 2, 3, 4, 5}
        Dim packed As String = System.Convert.ToBase64String(blob)
        Environment.SetEnvironmentVariable("APP_BLOB", packed)
        Console.WriteLine(packed)
        ' AQIDBAU=
    End Sub
End Module

Config-bestanden volgen dezelfde vorm, met de waarde die in XML- of JSON-tekst woont en de decodage die in je startcode gebeurt. Een legacy-notitie voor de enterprise-hoek: WCF en XML-datacontracten serialiseren een byte-array als het XML-schematype base64Binary, dus een groot aantal oudere .NET-services slaat binair precies zo op, en de waarde die je in die XML vindt is simpele ToBase64String-uitvoer.

JWTs: de compacte vorm bouwen

Een JSON Web Token in compacte vorm is drie puntgescheiden stukjes base64url: de header, de payload en een handtekening. De eerste twee zijn gewone JSON, en de derde is een cryptografisch bewijs dat een bezitter van de juiste sleutel dit token heeft gebouwd. De ongetekende vorm handmatig bouwen is twee encodings en een string-samenvoeging, maar een echt JWT heeft de handtekeningstap nodig, en een klein HMAC-SHA256-voorbeeld maakt het hele ding concreet:

Imports System
Imports System.Buffers.Text
Imports System.Security.Cryptography
Imports System.Text
Module JwtPacker
    Function BuildHs256Jwt(ByVal headerJson As String, ByVal payloadJson As String, ByVal secret() As Byte) As String
        Dim header As String = Base64Url.EncodeToString(Encoding.UTF8.GetBytes(headerJson))
        Dim body As String = Base64Url.EncodeToString(Encoding.UTF8.GetBytes(payloadJson))
        Dim signingInput As String = header & "." & body
        Using hmac As New HMACSHA256(secret)
            Dim signature() As Byte = hmac.ComputeHash(Encoding.UTF8.GetBytes(signingInput))
            Return signingInput & "." & Base64Url.EncodeToString(signature)
        End Using
    End Function
End Module

Voer het uit met de header {"alg":"HS256","typ":"JWT"} en een payload naar keuze, en het resultaat is een echt compact JWT: nergens padding, URL-safe tekens in alle drie de delen. Let erop dat de handtekening ook base64url is, want het hele token moet een URL of een HTTP-header overleven. Voor productiesystemen bouwt, tekent en verifieert het System.IdentityModel.Tokens.Jwt-pakket (de IdentityModel-suites van het Microsoft Entra-team) deze tokens voor je, en dat is de laag waar sleutelbeheer, algoritmen-pinnen en vervaldatumchecks thuishoren. De encoding handmatig bouwen is prima om te begrijpen en voor kleine tools; voor alles dat toegang beschermt, laat de bibliotheek het gewicht dragen.

Valkuilen: waar VB-encoders struikelen

De vallen hier zijn een mix van taalgewoonten en verrassingen door de uitvoervormgeving, en de meeste kosten een debugsessie in plaats van een crash:

• Byte versus Byte(). De encoder wil een array. In Visual Basic is één byte Byte en een array Byte(), en het verschil is één paar haakjes. Onder Option Strict On is een verkeerde gok een compileerfout; met die eruit, kun je in plaats daarvan een runtime-verrassing krijgen. Houd de striktheid aan en de haakjes zichtbaar.
• De Encoding.Default-val, in omgekeerde richting. Het verhaal van locale-verschillen is het .NET Framework-verhaal: op moderne .NET is Default altijd UTF-8, dus dezelfde string encodeert op elke machine op dezelfde manier. Voor alles wat machines oversteekt, noem de encoding expliciet, meestal UTF-8 - het advies geldt in beide gevallen.
• CRLF vindt altijd een weg binnen. InsertLineBreaks is wonderbaarlijk voor MIME en vreselijk voor URLs, JSON en database-tekstkolommen, waar het een carriage return en een line feed invoegt die niemand vroeg. Gebruik het alleen wanneer de consument verpakte regels verwacht, en als je twijfelt, gebruik dan de standaard None.
• Padding-onevenkomsten aan de grens. De Base64Url van .NET produceert geen padding, terwijl sommige bibliotheken in andere ecosystemen hem toevoegen (en een paar strikte decoders eisen hem). Wanneer je gecodeerde waarde een ecosysteem oversteekt, bevestig dan de verwachting van de andere kant vóórdat je de string verstuurt; JWT wil de vorm zonder padding, en dat is de .NET-standaard.
• Rondritten zijn geen identiteit. Decodeer een verpakte, gepaddingde string en encodeer hem opnieuw, en je krijgt een nette enkele regel met verse padding, niet de oorspronkelijke tekst. Als je logica gecodeerde waarden op gelijkheid vergelijkt, vergelijk dan in plaats daarvan de gedecodeerde bytes.
• Het grootteplafond is echt. De uitvoerlengteformule, vier tekens per drie bytes afgerond naar boven, laat een 32-bit-teller overlopen bij zo'n 1,5 gigabyte aan input, en de encoder antwoordt met een OutOfMemoryException in plaats van een gedeeltelijke string. Voor inputs in de buurt van die schaal, stream in plaats daarvan (hieronder).
• De span-muur. De span-gebaseerde encoders zijn vanuit VB aanroepbaar op de aanroepplaats: geef je Byte()- of Char()-arrays gewoon door en de compiler zet ze om. Maar je kunt geen variabele, veld of parameter declareren van het type Span of ReadOnlySpan; de compiler weigert met "Types with embedded references are not supported in this version of your compiler". Het VB-idioom is de span-API's aan te roepen met gewone arrays en nooit een span op te slaan.
• BitConverter is geen Base64. BitConverter.ToString(bytes) rendert hex met streepjes tussen de paren, dus het is een verleidelijk maar fout antwoord dat 4D-61-6E oplevert waar het andere systeem TWFu verwacht. Voor Base64 is de klasse System.Convert, elke keer.

Snelheid en grootte: prestatienotities

De reputatie van Base64 als "langzame tekst-codec" overleeft de confrontatie met de moderne runtime niet. De encoder binnen .NET draait hardware-gevectoriseerde code wanneer de machine die ondersteunt, met toegewijde snelle paden voor de AVX-512-, AVX2- en SSE-instructiesets, en het AVX-512-pad kauwt 48 bytes per stap door. Voor gewone payloads is de klassieke ToBase64String-aanroep snel genoeg dat het algoritme zelden de bottleneck is; de kosten die je voelt zijn de 33-procent-groottebelasting en, voor hete paden, de tussentijdse allocaties. Als je miljoenen kleine waarden encodeert, zijn de span-gebaseerde API's de verfijning: TryToBase64Chars schrijft naar een karakterspan die je beheerst en rapporteert succes met een booleaanse waarde, en System.Buffers.Text.Base64 gaat verder, door rechtstreeks te encoderen naar UTF-8-buffers die je reserveert en data zelfs op dezelfde plek op te blazen:

Imports System
Imports System.Buffers
Imports System.Buffers.Text
Imports System.Text
Module BufferPacker
    Sub Main()
        Dim data() As Byte = {1, 2, 3, 4, 5}
        Dim textLength As Integer = Base64.GetMaxEncodedToUtf8Length(data.Length)
        Dim buffer(textLength) As Byte
        Dim written As Integer
        Dim consumed As Integer
        Dim status As OperationStatus = Base64.EncodeToUtf8(data, buffer, consumed, written)
        Dim packed As String = Encoding.ASCII.GetString(buffer, 0, written)
        Console.WriteLine(packed)
        ' AQIDBAU=
    End Sub
End Module

Het patroon dat opvalt is dat je de buffer met de helper mat, daarin encodeert, en alleen het gebruikte prefix naar een string zet, wat het tussentijdse oppervlak zo klein mogelijk houdt. En voor bestanden die groot genoeg zijn om strings ongemakkelijk te maken, houdt het stromende duo het geheugen vlak: de ToBase64Transform-transform, ingepakt in een CryptoStream, leest je input in chunks en schrijft gecodeerde tekst weg, zodat een bestand van twee gigabyte nooit hoeft te worden tot een string van 2,7 gigabyte in één stuk:

Imports System.IO
Imports System.Security.Cryptography
Module StreamPacker
    Sub EncodeFile(ByVal inputPath As String, ByVal packedPath As String)
        Using inputStream As New FileStream(inputPath, FileMode.Open, FileAccess.Read)
            Using packedStream As New CryptoStream(New FileStream(packedPath, FileMode.Create), New ToBase64Transform(), CryptoStreamMode.Write)
                Dim buffer(65535) As Byte
                While True
                    Dim read As Integer = inputStream.Read(buffer, 0, buffer.Length)
                    If read = 0 Then Exit While
                    packedStream.Write(buffer, 0, read)
                End While
            End Using
        End Using
    End Sub
End Module

Eén vooruitblik: de preview .NET 11-bibliotheken voegen nieuwe gemak- en span-overloads toe aan de bestaande Base64-types, dus als je project previews kan volgen, blijft de gereedschapskist groeien; kan het dat niet, dan is alles hierboven stabiel op elke ondersteunde release.

Een korte geschiedenis: van MSXML naar spans

Lang vóór .NET leenden Visual Basic-programma's die Base64 nodig hadden hem uit bij de COM-wereld. De klassieke VB6- en VBA-truc (de macrotaal die nog steeds draait in Excel en Office) gebruikte in plaats daarvan een XML DOM-element: de MSXML-parser laat een node haar DataType declareren als bin.base64, zodat je door je bytes in de nodeTypedValue van de node te schrijven en diens text-eigenschap terug te lezen de gecodeerde string in handen krijgt, met de DOM die het echte Base64-rekensorwerk doet (de eigen Charset-eigenschap van het ADO Stream-object begrijpt alleen echte charset-namen zoals "utf-8" of "iso-8859-1", niet "base64", dus speelt het zelf geen rol in de omzetting). Het was slim, het was overal, en het is de reden waarom "base64 VBA" decennia later nog steeds zoekmachines doet oplichten. Het tijdperk eindigde in 2002, toen de eerste .NET-versie van de taal, Visual Basic 7.0, zich voegde bij de nieuwe Common Language Runtime, en het .NET Framework System.Convert met ToBase64String meebracht, alles al ingebouwd. Vanaf .NET Framework 1.1 in 2003 kon elk VB-programma Base64 encoderen met één aanroep en zonder componenten die geregistreerd moesten worden.

De moderne hoofdstukken zijn kort. In 2018 voegde .NET Core 2.1 de allocatie-luchtige TryToBase64Chars-methode en de laaggevoegde span-gebaseerde System.Buffers.Text.Base64-klasse toe. In 2024 standaardiseerde .NET 9 het URL-safe alfabet als Base64Url, en daarmee was een decennium van handgeroelde Replace-aanroepen voorbij. Per 2026 is .NET 10 - uitgebracht in november 2025 - de long-term-support-lijn die al dit draagt, en de preview .NET 11-bibliotheken voegen een nieuwe generatie gemaksmethoden toe, dus de encoder van de éénregelaar van 2003 tot het span-tijdperk is een verhaal over dezelfde klasse die sneller en preciezer wordt, nooit over opnieuw beginnen.

Leuke weetjes, VB-editie

• InsertLineBreaks reproduceert de MIME-regel van 76 tekens exact, CRLF en al, wat betekent dat de regelafbrekingen die je encoder in 2026 schrijft byte voor byte dezelfde vorm hebben als de regels die een e-mailstandaard in de jaren 1990 definieerde.
• De IsNot-operator, toegevoegd met Visual Basic 2005, kwam ooit in het nieuws als onderwerp van een Microsoft-patentaanvraag. Zeer weinig taaloperators mogen die onderscheiding claimen.
• Het allereerste Visual Basic werd in 1991 uitgebracht, vóórdat het World Wide Web bestond. Toen in 1998 het data-URI-schema verscheen, had Base64 al vijf jaar e-mailbijlagen gedragen, en was VB drie jaar daarvoor uitgegroeid tot een 32-bittaal, met Visual Basic 4 in 1995.
• Op hardware met AVX-512 verwerkt de runtime-encoder 48 bytes per vectorstap, en dat is het verschil tussen een tabelzoekje in een museum en een lopende band in een fabriek.
• De My-namespace, de beroemde suikerlaag van Visual Basic uit 2005, hoefde nooit een Base64-helper toe te voegen. System.Convert was altijd op één namespace-import afstand, een zeldzaam geval waarin de VB-runtime niets toevoegde aan een verhaal dat de framework al vertelde.

De andere kant

Dit artikel heeft de encoderingskant van Base64 in Visual Basic behandeld: de gereedschapskist, de beslissingen over de uitvoervormgeving, het URL-safe alfabet, en de toepassingen van bestanden tot JWTs. De tegenovergestelde richting, een binnenkomende string nemen en hem weer omzetten naar de bytes die hij verbergt, heeft zijn eigen set gedragingen, nadenigheidsregels en valkuilen, en die wordt in volle diepte behandeld in het bijbehorende decoderingsartikel op de zustersite. De link ernaartoe zit net onder deze regel, en het gereedschap op de startpagina blijft de snelste manier om een kleine payload in handen te encoderen.

Laatst bijgewerkt: 2026-10-06

Gerelateerd artikel: Base64-decodering in Visual Basic: een complete gids