Base64 Decode i C# — Convert.FromBase64String() Guide

Varje .NET-projekt jag arbetat med behöver förr eller senare avkoda Base64 — hämta anslutningssträngar från Kubernetes-secrets, läsa binära nyttolaster från webhooks eller granska JWT-tokens under en felsökningssession. För att avkoda Base64 i C# är den primära metoden Convert.FromBase64String(), som returnerar en byte[] som du sedan skickar till Encoding.UTF8.GetString() för att få läsbar text. För en snabb kontroll utan att skriva kod hanterar ToolDecks Base64-avkodare det direkt i webbläsaren. Den här guiden täcker Convert.FromBase64String(), den span-baserade TryFromBase64String() för .NET 5+, det högpresterande System.Buffers.Text.Base64 API:et, JWT-nyttolastextrahering, fil- och API-svarsavkodning, streaming med CryptoStream och de fyra misstag som oftast snubblar C#-utvecklare.

Vad är Base64-avkodning?

Base64-kodning konverterar binärdata till ett 64-teckens ASCII-alfabet så att den överlever textbaserad transport — JSON-fält, HTTP-huvuden, e-postmeddelanden, XML- attribut. Varje 3 bytes indata blir 4 Base64-tecken, vilket är anledningen till att Base64-utdata alltid är ungefär 33% större än originalet. Avkodning vänder på den här transformationen. =-utfyllnaden i slutet talar om för avkodaren hur många bytes som ska trimmas från den sista gruppen. En ensam = betyder att det sista blocket hade 2 bytes; == betyder att det hade 1 byte. Base64 är inte kryptering — vem som helst kan återskapa det. Syftet är säker transport genom kanaler som förstör rå binärdata, inte konfidentialitet.

cmVkaXM6Ly9jYWNoZS1wcm9kLmludGVybmFsOjYzNzkvc2Vzc2lvbi1zdG9yZQ==

redis://cache-prod.internal:6379/session-store

Convert.FromBase64String() — Standardmetoden för avkodning

Metoden Convert.FromBase64String() har funnits i .NET sedan Framework 1.1-dagarna. Inga NuGet-paket, inga extra importer utöver System — anropa den bara och få tillbaka en byte[]. Det tvåstegs-pipeline för att avkoda Base64 till en C#-sträng är alltid detsamma: Convert.FromBase64String() för att få bytes, sedan Encoding.UTF8.GetString() för att tolka dessa bytes som text. Fångsten är att metoden returnerar råa bytes, inte en sträng. Du behöver välja rätt Encoding för att konvertera dessa bytes tillbaka till text, och valet spelar större roll än de flesta förväntar sig. En felmatchad kodning producerar tyst mojibake — förvirrade tecken utan något undantag som varnar dig.

Minimalt fungerande exempel

using System;
using System.Text;

// Anslutningssträng lagrad som Base64 i ett Kubernetes-secret
string encoded = "cmVkaXM6Ly9jYWNoZS1wcm9kLmludGVybmFsOjYzNzkvc2Vzc2lvbi1zdG9yZQ==";

byte[] decodedBytes = Convert.FromBase64String(encoded);
string connectionString = Encoding.UTF8.GetString(decodedBytes);

Console.WriteLine(connectionString);
// redis://cache-prod.internal:6379/session-store

Använd alltid Encoding.UTF8 om du inte har ett specifikt skäl att inte göra det. .NET-körmiljön representerar strängar som UTF-16 internt, men de flesta data som passerar systemgränser (API-svar, konfigurationsfiler, secrets) är kodade som UTF-8. Att använda Encoding.ASCII på data som innehåller flerbyte-tecken ersätter dem tyst med ? — inget undantag, bara korrumperat utdata.

Tur-och-retur-verifiering

using System;
using System.Text;

string original = "postgres://db-admin:Kx8!mQ@db-prod.us-east-1.internal:5432/orders";

// Koda
string encoded = Convert.ToBase64String(Encoding.UTF8.GetBytes(original));
Console.WriteLine(encoded);
// cG9zdGdyZXM6Ly9kYi1hZG1pbjpLeDghbVFAZGItcHJvZC51cy1lYXN0LTEuaW50ZXJuYWw6NTQzMi9vcmRlcnM=

// Avkoda
byte[] decoded = Convert.FromBase64String(encoded);
string recovered = Encoding.UTF8.GetString(decoded);

Console.WriteLine(recovered == original); // True

Välja rätt Encoding

Den Encoding du skickar till GetString() måste matcha det som användes när data ursprungligen kodades. Väljer du fel får du skräptecken utan undantag — avkodaren producerar glatt nonsens. Här är den praktiska sammanfattningen:

• Encoding.UTF8 — säkert standardval. Hanterar ASCII och all Unicode. Använd detta om du inte vet bättre.
• Encoding.ASCII — endast för ren 7-bitars ASCII-data. Flerbyte-tecken blir ?.
• Encoding.Unicode — detta är UTF-16LE i .NET. Vissa Windows-interna strängar och PowerShell-exporter använder detta.
• Encoding.Latin1 — äldre västeuropeisk kodning. Förekommer i gamla SOAP-tjänster och mainframe-integrationer.

using System;
using System.Text;

// Samma bytes, olika kodningar — olika resultat
byte[] decoded = Convert.FromBase64String("w7bDvMOk");

Console.WriteLine(Encoding.UTF8.GetString(decoded));    // öüä  (korrekt)
Console.WriteLine(Encoding.ASCII.GetString(decoded));   // ??????  (förlorat)
Console.WriteLine(Encoding.Latin1.GetString(decoded));  // öüä  (mojibake)

En återanvändbar avkodningshjälpare med felhantering

Eftersom Convert.FromBase64String() kastar undantag vid felaktigt indata och blankstegsrensningen händer konstant, håller jag en liten hjälpare i de flesta projekt:

using System;
using System.Text;

static class Base64Helper
{
    public static string? DecodeToString(string encoded)
    {
        if (string.IsNullOrWhiteSpace(encoded))
            return null;

        // Ta bort blanksteg som .NETs avkodare avvisar
        string cleaned = encoded
            .Replace("
", "")
            .Replace("
", "")
            .Replace(" ", "")
            .Trim();

        try
        {
            byte[] bytes = Convert.FromBase64String(cleaned);
            return Encoding.UTF8.GetString(bytes);
        }
        catch (FormatException)
        {
            return null; // eller kasta ett domänspecifikt undantag
        }
    }
}

// Användning
string? decoded = Base64Helper.DecodeToString("  cmVkaXM6Ly9jYWNoZQ==  \n");
Console.WriteLine(decoded); // redis://cache

Avkoda Base64 till icke-standardtyper

Avkodaren ger dig alltid byte[]. Vad du gör med dessa bytes beror på originaldata. Ibland är det ett GUID lagrat som 16 råa bytes, ibland ett serialiserat protobuf-meddelande, ibland en tidsstämpel i binärt format. Här är de konverteringar jag oftast använder.

Base64 till GUID

using System;

// Vissa API:er skickar GUIDs som 22-teckens Base64 istället för 36-teckens hex-strängar
string compactGuid = "C0HqetxMckKlZw4CssPUeQ==";
byte[] guidBytes = Convert.FromBase64String(compactGuid);
Guid recovered = new Guid(guidBytes);

Console.WriteLine(recovered);
// 7aea41c0-4cdc-4272-a567-0e02b2c3d479

Base64 till deserialiserad JSON med System.Text.Json

using System;
using System.Text;
using System.Text.Json;

// Base64-kodad JSON-nyttolast från en meddelandekö
string encoded = "eyJzZXJ2aWNlIjoicGF5bWVudC1nYXRld2F5IiwicmVnaW9uIjoiZXUtd2VzdC0xIiwicmVwbGljYXMiOjR9";

byte[] jsonBytes = Convert.FromBase64String(encoded);
string json = Encoding.UTF8.GetString(jsonBytes);
Console.WriteLine(json);
// {"service":"payment-gateway","region":"eu-west-1","replicas":4}

// Deserialisera till ett record
var deployEvent = JsonSerializer.Deserialize<DeployEvent>(jsonBytes);
Console.WriteLine($"{deployEvent!.Service} in {deployEvent.Region}");
// payment-gateway in eu-west-1

record DeployEvent(string Service, string Region, int Replicas);

Base64 till hex-sträng

using System;

// SHA-256-hash lagrad som Base64
string hashBase64 = "n4bQgYhMfWWaL+qgxVrQFaO/TxsrC4Is0V1sFbDwCgg=";
byte[] hashBytes = Convert.FromBase64String(hashBase64);
string hex = Convert.ToHexString(hashBytes);

Console.WriteLine(hex);
// 9F86D081884C7D659A2FEAA0C55AD015A3BF4F1B2B0B822CD15D6C15B0F00A08

Referens för Base64-avkodningsmetoder

.NET erbjuder flera avkodningsmetoder i två namnrymder. Klassen Convert hanterar allmän avkodning, medan System.Buffers.Text.Base64 riktar sig mot scenarier med hög genomströmning där du redan arbetar med råa UTF-8 byte-buffertar.

Convert.TryFromBase64String() — Undantagsfri avkodning

Try-mönstret är standard i .NET för operationer som kan misslyckas med användarindata. Convert.TryFromBase64String(), tillgänglig sedan .NET 5, returnerar en bool istället för att kasta FormatException. Den skriver de avkodade bytes till en anroparisolerad Span<byte>, vilket innebär att du kan använda stackallokerat minne för små nyttolaster och hoppa över heapen helt och hållet.

using System;
using System.Text;

string userInput = "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=";

// Stackallokeera för små nyttolaster (< 1KB är en säker tumregel)
Span<byte> buffer = stackalloc byte[256];

if (Convert.TryFromBase64String(userInput, buffer, out int bytesWritten))
{
    string result = Encoding.UTF8.GetString(buffer[..bytesWritten]);
    Console.WriteLine(result);
    // {"host":"10.0.1.50","port":8443}
}
else
{
    Console.WriteLine("Invalid Base64 input — skipping");
}

Det här tillvägagångssättet lyser i request-mellanprogramvara eller valideringspipelines där felaktigt indata förväntas, inte är exceptionellt. Att kasta och fånga en FormatException på varje felaktigt anrop lägger till mätbart overhead i stor skala — TryFromBase64String() undviker det helt.

Validera Base64-indata utan att avkoda

Ett vanligt mönster i API-kontroller: kontrollera om indata är giltig Base64 innan du skickar det vidare. Du kan använda TryFromBase64String() som en validerare genom att allokera en tillfällig buffert:

using System;

static bool IsValidBase64(string input)
{
    // Beräkna maximal avkodad storlek
    Span<byte> buffer = stackalloc byte[((input.Length + 3) / 4) * 3];
    return Convert.TryFromBase64String(input, buffer, out _);
}

// Användning i en API-kontroller
Console.WriteLine(IsValidBase64("eyJob3N0IjoiMTAuMC4xLjUwIn0=")); // True
Console.WriteLine(IsValidBase64("not!!valid!!base64"));              // False
Console.WriteLine(IsValidBase64(""));                                // True (tomt är giltigt)

Avkoda Base64 från fil och API-svar

Läsa en Base64-kodad fil från disk

Certifikat, krypterade blobbar och dataexportfiler levereras ibland som Base64-text. Det typiska mönstret: läs filen som en sträng, ta bort eventuella blanksteg eller radbrytningar som skulle orsaka FormatException, avkoda till bytes och skriv det binära utdata. Var uppmärksam på felhanteringen — fil-I/O-fel och Base64-formatfel bör fångas separat.

using System;
using System.IO;

string inputPath = "tls-cert.pem.b64";
string outputPath = "tls-cert.pem";

try
{
    string encoded = File.ReadAllText(inputPath).Trim();
    // Ta bort radbrytningar — .NETs avkodare avvisar dem
    encoded = encoded.Replace("
", "").Replace("
", "");

    byte[] decoded = Convert.FromBase64String(encoded);
    File.WriteAllBytes(outputPath, decoded);

    Console.WriteLine($"Decoded {decoded.Length} bytes -> {outputPath}");
}
catch (IOException ex)
{
    Console.Error.WriteLine($"File error: {ex.Message}");
}
catch (FormatException ex)
{
    Console.Error.WriteLine($"Invalid Base64: {ex.Message}");
}

Avkoda ett Base64-fält från ett HTTP API-svar

Moln-API:er (Azure Key Vault, AWS Secrets Manager, GitHub Contents API) returnerar ofta binärdata som Base64-strängar inbäddade i JSON. Arbetsflödet är alltid detsamma: gör HTTP-anropet, tolka JSON-svaret, extrahera Base64-fältet och avkoda det. Exemplet nedan använder HttpClient och System.Text.Json — båda inbyggda i .NET 6+.

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer sk-prod-9f8e7d6c");

try
{
    var response = await client.GetAsync("https://api.example.com/secrets/db-password");
    response.EnsureSuccessStatusCode();

    string body = await response.Content.ReadAsStringAsync();

    // API returnerar: {"name":"db-password","value":"cG9zdGdyZXM6eGs5bVAycVI=","version":3}
    using var doc = JsonDocument.Parse(body);
    string encodedValue = doc.RootElement.GetProperty("value").GetString()!;

    byte[] decoded = Convert.FromBase64String(encodedValue);
    string secret = Encoding.UTF8.GetString(decoded);

    Console.WriteLine($"Secret: {secret}");
    // Secret: postgres:xk9mP2qR
}
catch (HttpRequestException ex)
{
    Console.Error.WriteLine($"HTTP error: {ex.Message}");
}
catch (FormatException ex)
{
    Console.Error.WriteLine($"Base64 decode failed: {ex.Message}");
}

Base64-avkodning från kommandoraden

Du behöver inte alltid ett kompilerat projekt. Verktyget dotnet-scriptoch PowerShell hanterar båda Base64-avkodning med envärdskommandon. För snabb inspektion under felsökning är dessa snabbare än att skapa en konsolapp.

# PowerShell (inbyggt i Windows, tillgängligt på Linux/macOS)
[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String("eyJob3N0IjoiMTAuMC4xLjUwIn0="))
# {"host":"10.0.1.50"}

# Linux / macOS inbyggt base64-kommando
echo "eyJob3N0IjoiMTAuMC4xLjUwIn0=" | base64 --decode
# {"host":"10.0.1.50"}

# macOS använder -D istället för --decode
echo "eyJob3N0IjoiMTAuMC4xLjUwIn0=" | base64 -D

# dotnet-script (installera: dotnet tool install -g dotnet-script)
echo 'Console.WriteLine(System.Text.Encoding.UTF8.GetString(Convert.FromBase64String("eyJob3N0IjoiMTAuMC4xLjUwIn0=")));' | dotnet-script eval

# Avkoda och pretty-printa JSON med jq
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode | jq .

För att klistra in kodade strängar direkt i en webbläsare hanterar ToolDecks Base64-avkodare både standard- och URL-säkra varianter utan någon konfiguration.

Högpresterande alternativ: System.Buffers.Text.Base64

Klassen System.Buffers.Text.Base64, tillgänglig sedan .NET Core 2.1, opererar på råa UTF-8 byte-spans istället för .NET-strängar. Det kringgår overheadet för sträng-till-byte-konvertering helt — ingen mellanliggande strängallokering, inget UTF-16-kodningssteg. Jag använder det i ASP.NET Core-mellanprogramvara där inkommande data redan är en ReadOnlySpan<byte> från request-kroppen. Att skapa en string bara för att skicka den till Convert.FromBase64String() fördubblar allokeringarna i onödan. I BenchmarkDotNet-tester på .NET 8 är den span-baserade vägen ungefär 2-3x snabbare för nyttolaster under 1 KB och gapet ökar med större indata eftersom GC-trycket förblir konstant.

using System;
using System.Buffers.Text;
using System.Text;

// Simulera råa UTF-8 bytes från en HTTP request-kropp
byte[] utf8Input = Encoding.UTF8.GetBytes("eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=");

byte[] output = new byte[Base64.GetMaxDecodedFromUtf8Length(utf8Input.Length)];

OperationStatus status = Base64.DecodeFromUtf8(
    utf8Input, output, out int bytesConsumed, out int bytesWritten);

if (status == OperationStatus.Done)
{
    string result = Encoding.UTF8.GetString(output.AsSpan(0, bytesWritten));
    Console.WriteLine(result);
    // {"host":"10.0.1.50","port":8443}
    Console.WriteLine($"Consumed: {bytesConsumed}, Written: {bytesWritten}");
    // Consumed: 44, Written: 31
}
else
{
    Console.WriteLine($"Decode failed: {status}");
    // Möjliga värden: InvalidData, DestinationTooSmall, NeedMoreData
}

Returtypen är OperationStatus — en enum med fyra värden: Done, InvalidData, DestinationTooSmall, och NeedMoreData. Det sista är användbart för partiell avkodning av strömmande data. För absolut nollallokering, kombinera detta med ArrayPool<byte>.Shared.Rent() istället för new byte[].

DecodeFromUtf8InPlace — skriv över indatabufferten

using System;
using System.Buffers.Text;
using System.Text;

// Indatabufferten skrivs över med avkodade bytes
byte[] data = Encoding.UTF8.GetBytes("c2VydmVyLWNvbmZpZw==");

OperationStatus status = Base64.DecodeFromUtf8InPlace(data, out int bytesWritten);

if (status == OperationStatus.Done)
{
    Console.WriteLine(Encoding.UTF8.GetString(data.AsSpan(0, bytesWritten)));
    // server-config
}

En sak att vara medveten om: System.Buffers.Text.Base64 hanterar inte URL-säker Base64 direkt. Om indata använder - och _ tecken (JWT-tokens, till exempel) måste du fortfarande ersätta dem med + och / innan du anropar dessa metoder. De span-baserade API:erna följer strikt RFC 4648 standardalfabetet. Det finns ingen DecodeFromUtf8Url-variant — en överraskande lucka med tanke på hur vanlig Base64url är i moderna API:er.

Terminalutdata med syntaxmarkering

Biblioteket Spectre.Console ger dig rikt terminalutdata inklusive JSON-markering — användbart när du bygger CLI-verktyg som avkodar Base64 och visar resultatet. Installera det med dotnet add package Spectre.Console.

using System;
using System.Text;
using Spectre.Console;
using Spectre.Console.Json;

string encoded = "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0MywibWF4Q29ubiI6MTAwfQ==";
byte[] decoded = Convert.FromBase64String(encoded);
string json = Encoding.UTF8.GetString(decoded);

// Pretty-printa med syntaxmarkering i terminalen
AnsiConsole.Write(new JsonText(json));
// Skriver ut färgad JSON:
// {
//   "host": "10.0.1.50",
//   "port": 8443,
//   "maxConn": 100
// }

Det här är särskilt praktiskt för CLI-verktyg som hämtar och avkodar konfiguration från fjärrtjänster. Avkoda Base64-konfigurationen, deserialisera till JSON och skriv ut det markerade utdata — allt på några rader. Spectre.Console har också tabellrendering, förloppsindikatorer och trädvyer om du behöver visa mer komplexa avkodade datastrukturer i terminalen.

Strömma stora Base64-filer med CryptoStream

Att ladda en 500 MB Base64-fil med File.ReadAllText() och sedan anropa Convert.FromBase64String() allokerar ungefär 700 MB heap: strängen i sig (UTF-16, alltså dubbla filstorleken) plus den avkodade byte-arrayen. Kombinationen CryptoStream + FromBase64Transform avkodar i bitar och håller minnesanvändningen konstant.

using System.IO;
using System.Security.Cryptography;

string inputPath = "database-export.sql.b64";
string outputPath = "database-export.sql";

using var inputStream = new FileStream(inputPath, FileMode.Open, FileAccess.Read);
using var transform = new FromBase64Transform(FromBase64TransformMode.IgnoreWhiteSpaces);
using var base64Stream = new CryptoStream(inputStream, transform, CryptoStreamMode.Read);
using var outputStream = new FileStream(outputPath, FileMode.Create, FileAccess.Write);

base64Stream.CopyTo(outputStream);

Console.WriteLine($"Decoded {new FileInfo(outputPath).Length} bytes -> {outputPath}");

Flaggan FromBase64TransformMode.IgnoreWhiteSpaces hanterar radbruten Base64 (PEM-filer, e-postexporter) utan manuell rensning. Utan den här flaggan orsakar radbrytningar i indata en FormatException. Det här är .NETs närmaste motsvarighet till Javas getMimeDecoder() — det hoppar tyst över blankstegstecken under avkodning.

Namnet CryptoStream är vilseledande — det finns inget kryptografiskt med Base64. Microsoft lade FromBase64Transform i System.Security.Cryptography-namnrymden eftersom det implementerar ICryptoTransform, samma gränssnitt som används för AES och andra chiffertransformationer. Strömmen i sig pipelar bara data genom en transform i bitar. Tänk på det som en generell streaming-transformpipeline som råkar bo i fel namnrymd.

Asynkron streaming för ASP.NET Core-scenarier

using System.IO;
using System.Security.Cryptography;

async Task DecodeStreamAsync(Stream inputStream, string outputPath)
{
    using var transform = new FromBase64Transform(FromBase64TransformMode.IgnoreWhiteSpaces);
    using var base64Stream = new CryptoStream(inputStream, transform, CryptoStreamMode.Read);
    await using var outputStream = new FileStream(
        outputPath, FileMode.Create, FileAccess.Write, FileShare.None,
        bufferSize: 81920, useAsync: true);

    await base64Stream.CopyToAsync(outputStream);
}

// Användning i en endpoint:
// await DecodeStreamAsync(Request.Body, "uploaded-file.bin");

Hur man avkodar ett Base64 JWT-tokens nyttolast i C#

En JWT har tre Base64url-kodade segment separerade med punkter. Det mittersta segmentet är nyttolasten. Du kan avkoda det utan att dra in ett JWT-bibliotek — dela på ., normalisera Base64url-tecknen, fixa utfyllnaden och anropa Convert.FromBase64String(). Det här snubblar nästan alla första gången eftersom JWT använder - och _ istället för + och /, och tar bort =-utfyllnaden.

using System;
using System.Text;

static string DecodeJwtPayload(string token)
{
    string[] parts = token.Split('.');
    if (parts.Length != 3)
        throw new ArgumentException($"Invalid JWT: expected 3 segments, got {parts.Length}");

    // Ta nyttolasten (andra segmentet)
    string payload = parts[1];

    // Ersätt URL-säkra tecken med standard Base64
    payload = payload.Replace('-', '+').Replace('_', '/');

    // Fyll ut till en multipel av 4
    switch (payload.Length % 4)
    {
        case 2: payload += "=="; break;
        case 3: payload += "=";  break;
    }

    byte[] bytes = Convert.FromBase64String(payload);
    return Encoding.UTF8.GetString(bytes);
}

// Testa med en verklighetstrogen token
string token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9"
    + ".eyJzdWIiOiJ1c3ItNjcyIiwiaXNzIjoiYXV0aC5leGFtcGxlLmNvbSIsImV4cCI6MTc0MTk1NjgwMCwicm9sZXMiOlsiYWRtaW4iLCJiaWxsaW5nIl19"
    + ".SIGNATURE_PLACEHOLDER";

Console.WriteLine(DecodeJwtPayload(token));
// {"sub":"usr-672","iss":"auth.example.com","exp":1741956800,"roles":["admin","billing"]}

Snabb notering: det här läser bara nyttolasten. Det verifierar inte signaturen. För produktionsvalidering av autentisering, använd ett ordentligt bibliotek som Microsoft.IdentityModel.JsonWebTokens. Men för felsökning, loggning och testassertioner är det här manuella tillvägagångssättet allt du behöver.

Tolka den avkodade JWT-nyttolasten till ett typat objekt

När du har JSON-strängen, deserialisera den med System.Text.Json för att komma åt enskilda anspråk utan strängmanipulation:

using System;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;

record JwtPayload(
    [property: JsonPropertyName("sub")] string Subject,
    [property: JsonPropertyName("iss")] string Issuer,
    [property: JsonPropertyName("exp")] long Expiration,
    [property: JsonPropertyName("roles")] string[] Roles
);

// Efter DecodeJwtPayload() ovan
string json = DecodeJwtPayload(token);
var claims = JsonSerializer.Deserialize<JwtPayload>(json)!;

Console.WriteLine($"User: {claims.Subject}");
Console.WriteLine($"Issuer: {claims.Issuer}");
Console.WriteLine($"Expires: {DateTimeOffset.FromUnixTimeSeconds(claims.Expiration):u}");
Console.WriteLine($"Roles: {string.Join(", ", claims.Roles)}");
// User: usr-672
// Issuer: auth.example.com
// Expires: 2025-03-14 12:00:00Z
// Roles: admin, billing

Vanliga misstag

Jag har stött på vart och ett av dessa i C#-tjänster i produktion. De två första är ansvariga för majoriteten av Base64-relaterade buggar jag ser i kodgranskningar. Varje misstag ser uppenbart ut isolerat, men de är lätta att missa när man är djupt inne i en större funktion och Base64-avkodning bara är ett steg i pipelinet.

// Miljövariabeln har en avslutande nyrad
string encoded = Environment.GetEnvironmentVariable("DB_PASS_B64")!;
byte[] decoded = Convert.FromBase64String(encoded);
// FormatException: The input is not a valid Base-64 string

string encoded = Environment.GetEnvironmentVariable("DB_PASS_B64")!;
string cleaned = encoded.Replace("\n", "").Replace("\r", "").Trim();
byte[] decoded = Convert.FromBase64String(cleaned);
Console.WriteLine(Encoding.UTF8.GetString(decoded));

// JWT-nyttolast — använder URL-säker Base64
string payload = "eyJzdWIiOiJ1c3ItNjcyIn0";
byte[] decoded = Convert.FromBase64String(payload);
// FormatException

string payload = "eyJzdWIiOiJ1c3ItNjcyIn0";
payload = payload.Replace('-', '+').Replace('_', '/');
switch (payload.Length % 4)
{
    case 2: payload += "=="; break;
    case 3: payload += "="; break;
}
byte[] decoded = Convert.FromBase64String(payload);
Console.WriteLine(Encoding.UTF8.GetString(decoded));
// {"sub":"usr-672"}

byte[] decoded = Convert.FromBase64String(pngBase64);
string imageStr = Encoding.UTF8.GetString(decoded); // korrumperar binärt
File.WriteAllText("image.png", imageStr); // trasig fil

byte[] decoded = Convert.FromBase64String(pngBase64);
// Skriv bytes direkt — ingen strängkonvertering
File.WriteAllBytes("image.png", decoded);

byte[] decoded = Convert.FromBase64String(encoded);
// Encoding.Default varierar mellan plattformar
string result = Encoding.Default.GetString(decoded);

byte[] decoded = Convert.FromBase64String(encoded);
string result = Encoding.UTF8.GetString(decoded);
// konsekvent på Windows, Linux, macOS

Metodjämförelse

.NET erbjuder fler Base64-avkodningsmetoder än de flesta utvecklare känner till. Tabellen nedan täcker varje inbyggt alternativ plus de två vanligaste tredjepartsalternativen. Kolumnen "Allokering" spelar störst roll i tjänster med hög genomströmning — en metod som allokerar en ny byte[] vid varje anrop belastar GC:n i täta loopar.

För vardagsbruk: Convert.FromBase64String(). För heta kodvägar där du validerar användarindata: TryFromBase64String(). För ASP.NET Core- mellanprogramvara som opererar på råa request-bytes: Base64.DecodeFromUtf8(). För stora filer: CryptoStream + FromBase64Transform. BouncyCastle är bara meningsfullt om det redan finns i ditt beroende för andra kryptografiska operationer.

För snabb verifiering utan att kompilera något är den online Base64-avkodaren snabbare än att skriva en engångskonsolapp.

Vanliga frågor

using System;
using System.Text;

string encoded = "cG9zdGdyZXM6eGs5bVAycVI=";
byte[] bytes = Convert.FromBase64String(encoded);
string result = Encoding.UTF8.GetString(bytes);
Console.WriteLine(result);
// postgres:xk9mP2qR

using System;

string input = "maybe-not-valid-base64!!";
Span<byte> buffer = stackalloc byte[256];

if (Convert.TryFromBase64String(input, buffer, out int written))
    Console.WriteLine($"Decoded {written} bytes");
else
    Console.WriteLine("Invalid Base64 input");

string token = "eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJ1c3ItNjcyIn0.SIG";
string payload = token.Split('.')[1];
payload = payload.Replace('-', '+').Replace('_', '/');
switch (payload.Length % 4)
{
    case 2: payload += "=="; break;
    case 3: payload += "="; break;
}
byte[] bytes = Convert.FromBase64String(payload);
Console.WriteLine(Encoding.UTF8.GetString(bytes));
// {"sub":"usr-672"}

// Fixa blanksteg
string cleaned = rawInput.Replace("\n", "").Replace("\r", "").Trim();
byte[] decoded = Convert.FromBase64String(cleaned);

using System.IO;
using System.Security.Cryptography;

using var input = File.OpenRead("payload.b64");
using var transform = new FromBase64Transform();
using var cryptoStream = new CryptoStream(input, transform, CryptoStreamMode.Read);
using var output = File.Create("payload.bin");
cryptoStream.CopyTo(output);

Relaterade verktyg

• Base64 Encoder — koda text eller binärdata till Base64 i webbläsaren, användbart för att generera testfixtures att klistra in i dina C# enhetstester.
• JWT Decoder — avkoda och inspektera alla tre JWT-segment på en gång, med fält-för-fält nyttolastinspektion — snabbare än att skriva en C#-hjälpare när du bara behöver läsa en token.
• URL Decoder — percent-avkoda URL-kodade strängar, användbart när API-svar blandar Base64url-data med percent-kodade frågeparametrar.
• JSON Formatter — efter att ha avkodat en Base64 JWT-nyttolast eller API-konfiguration, klistra in JSON här för att pretty-printa och validera strukturen.