Hoe codeer en decodeer ik een base64-tekenreeks?

  • Hoe retourneer ik een met base64 gecodeerde tekenreeks die een tekenreeks heeft gekregen?

  • Hoe decodeer ik een met base64 gecodeerde tekenreeks in een tekenreeks?


  • Antwoord 1, autoriteit 100%

    Coderen

    public static string Base64Encode(string plainText) {
      var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
      return System.Convert.ToBase64String(plainTextBytes);
    }
    

    Decoderen

    public static string Base64Decode(string base64EncodedData) {
      var base64EncodedBytes = System.Convert.FromBase64String(base64EncodedData);
      return System.Text.Encoding.UTF8.GetString(base64EncodedBytes);
    }
    

    Antwoord 2, autoriteit 4%

    Eén lijncode:

    Opmerking: gebruik de richtlijnen Systemen System.Text.

    Coderen:

    string encodedStr = Convert.ToBase64String(Encoding.UTF8.GetBytes("inputStr"));
    

    Decoderen:

    string inputStr = Encoding.UTF8.GetString(Convert.FromBase64String(encodedStr));
    

    Antwoord 3, autoriteit 3%

    Ik deel mijn implementatie met enkele handige functies:

    • gebruikt extensiemethoden voor de coderingsklasse. De reden hiervoor is dat iemand mogelijk verschillende soorten coderingen moet ondersteunen (niet alleen UTF8).
    • Een andere verbetering mislukt gracieus met een null-resultaat voor null-invoer – het is erg handig in real-life scenario’s en ondersteunt equivalentie voor X=decode(encode(X)).

    Opmerking: onthoud dat om de extensiemethode te gebruiken, u moet(!) de naamruimte importeren met usingtrefwoord (in dit geval using MyApplication.Helpers.Encoding).

    Code:

    namespace MyApplication.Helpers.Encoding
    {
        public static class EncodingForBase64
        {
            public static string EncodeBase64(this System.Text.Encoding encoding, string text)
            {
                if (text == null)
                {
                    return null;
                }
                byte[] textAsBytes = encoding.GetBytes(text);
                return System.Convert.ToBase64String(textAsBytes);
            }
            public static string DecodeBase64(this System.Text.Encoding encoding, string encodedText)
            {
                if (encodedText == null)
                {
                    return null;
                }
                byte[] textAsBytes = System.Convert.FromBase64String(encodedText);
                return encoding.GetString(textAsBytes);
            }
        }
    }
    

    Gebruiksvoorbeeld:

    using MyApplication.Helpers.Encoding; // !!!
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                Test1();
                Test2();
            }
            static void Test1()
            {
                string textEncoded = System.Text.Encoding.UTF8.EncodeBase64("test1...");
                System.Diagnostics.Debug.Assert(textEncoded == "dGVzdDEuLi4=");
                string textDecoded = System.Text.Encoding.UTF8.DecodeBase64(textEncoded);
                System.Diagnostics.Debug.Assert(textDecoded == "test1...");
            }
            static void Test2()
            {
                string textEncoded = System.Text.Encoding.UTF8.EncodeBase64(null);
                System.Diagnostics.Debug.Assert(textEncoded == null);
                string textDecoded = System.Text.Encoding.UTF8.DecodeBase64(textEncoded);
                System.Diagnostics.Debug.Assert(textDecoded == null);
            }
        }
    }
    

    Antwoord 4, autoriteit 2%

    Op basis van de antwoorden van Andrew Fox en Cebe heb ik het omgedraaid en er string-extensies van gemaakt in plaats van Base64String-extensies.

    public static class StringExtensions
    {
        public static string ToBase64(this string text)
        {
            return ToBase64(text, Encoding.UTF8);
        }
        public static string ToBase64(this string text, Encoding encoding)
        {
            if (string.IsNullOrEmpty(text))
            {
                return text;
            }
            byte[] textAsBytes = encoding.GetBytes(text);
            return Convert.ToBase64String(textAsBytes);
        }
        public static bool TryParseBase64(this string text, out string decodedText)
        {
            return TryParseBase64(text, Encoding.UTF8, out decodedText);
        }
        public static bool TryParseBase64(this string text, Encoding encoding, out string decodedText)
        {
            if (string.IsNullOrEmpty(text))
            {
                decodedText = text;
                return false;
            }
            try
            {
                byte[] textAsBytes = Convert.FromBase64String(text);
                decodedText = encoding.GetString(textAsBytes);
                return true;
            }
            catch (Exception)
            {
                decodedText = null;
                return false;
            }
        }
    }
    

    Antwoord 5

    Een kleine variatie op het andrew.fox-antwoord, omdat de te decoderen string mogelijk niet de juiste base64-gecodeerde string is:

    using System;
    namespace Service.Support
    {
        public static class Base64
        {
            public static string ToBase64(this System.Text.Encoding encoding, string text)
            {
                if (text == null)
                {
                    return null;
                }
                byte[] textAsBytes = encoding.GetBytes(text);
                return Convert.ToBase64String(textAsBytes);
            }
            public static bool TryParseBase64(this System.Text.Encoding encoding, string encodedText, out string decodedText)
            {
                if (encodedText == null)
                {
                    decodedText = null;
                    return false;
                }
                try
                {
                    byte[] textAsBytes = Convert.FromBase64String(encodedText);
                    decodedText = encoding.GetString(textAsBytes);
                    return true;
                }
                catch (Exception)
                {
                    decodedText = null;
                    return false;   
                }
            }
        }
    }
    

    Antwoord 6

    U kunt onderstaande routine gebruiken om string naar base64-indeling te converteren

    public static string ToBase64(string s)
    {
        byte[] buffer = System.Text.Encoding.Unicode.GetBytes(s);
        return System.Convert.ToBase64String(buffer);
    }
    

    U kunt ook een zeer goede online tool OnlineUtility.ingebruiken om strings in base64-indeling te coderen


    Antwoord 7

    URL-veilige Base64-codering/decodering

    public static class Base64Url
    {
        public static string Encode(string text)
        {
            return Convert.ToBase64String(Encoding.UTF8.GetBytes(text)).TrimEnd('=').Replace('+', '-')
                .Replace('/', '_');
        }
        public static string Decode(string text)
        {
            text = text.Replace('_', '/').Replace('-', '+');
            switch (text.Length % 4)
            {
                case 2:
                    text += "==";
                    break;
                case 3:
                    text += "=";
                    break;
            }
            return Encoding.UTF8.GetString(Convert.FromBase64String(text));
        }
    }
    

    Antwoord 8

       using System;
        using System.Text;
        public static class Base64Conversions
        {
            public static string EncodeBase64(this string text, Encoding encoding = null)
            { 
                if (text == null) return null;
                encoding = encoding ?? Encoding.UTF8;
                var bytes = encoding.GetBytes(text);
                return Convert.ToBase64String(bytes);
            }
            public static string DecodeBase64(this string encodedText, Encoding encoding = null)
            {
                if (encodedText == null) return null;
                encoding = encoding ?? Encoding.UTF8;
                var bytes = Convert.FromBase64String(encodedText);
                return encoding.GetString(bytes);
            }
        }
    

    Gebruik

       var text = "Sample Text";
        var base64 = text.EncodeBase64();
        base64 = text.EncodeBase64(Encoding.UTF8); //or with Encoding
    

    Antwoord 9

    Je kunt het als volgt weergeven:

    var strOriginal = richTextBox1.Text;
    byte[] byt = System.Text.Encoding.ASCII.GetBytes(strOriginal);
    // convert the byte array to a Base64 string
    string strModified = Convert.ToBase64String(byt);
    richTextBox1.Text = "" + strModified;
    

    Nu, terug converteren.

    var base64EncodedBytes = System.Convert.FromBase64String(richTextBox1.Text);
    richTextBox1.Text = "" + System.Text.Encoding.ASCII.GetString(base64EncodedBytes);
    MessageBox.Show("Done Converting! (ASCII from base64)");
    

    Ik hoop dat dit helpt!


    Antwoord 10

    Voor degenen die alleen individuele base64-cijfers willen coderen/decoderen:

    public static int DecodeBase64Digit(char digit, string digit62 = "+-.~", string digit63 = "/_,")
    {
        if (digit >= 'A' && digit <= 'Z') return digit - 'A';
        if (digit >= 'a' && digit <= 'z') return digit + (26 - 'a');
        if (digit >= '0' && digit <= '9') return digit + (52 - '0');
        if (digit62.IndexOf(digit) > -1)  return 62;
        if (digit63.IndexOf(digit) > -1)  return 63;
        return -1;
    }
    public static char EncodeBase64Digit(int digit, char digit62 = '+', char digit63 = '/')
    {
        digit &= 63;
        if (digit < 52)
            return (char)(digit < 26 ? digit + 'A' : digit + ('a' - 26));
        else if (digit < 62)
            return (char)(digit + ('0' - 52));
        else
            return digit == 62 ? digit62 : digit63;
    }
    

    Er zijn verschillende versiesvan Base64 die het niet eens zijn over wat te gebruiken voor de cijfers 62 en 63 , dus DecodeBase64Digitkan er meerdere verdragen.


    Antwoord 11

    // Encoding
    string passw = "tes123";
    var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(passw);
    string pass = System.Convert.ToBase64String(plainTextBytes);
    // Normal
    var encodedTextBytes = Convert.FromBase64String(pass);
    string plainText = Encoding.UTF8.GetString(encodedTextBytes);
    

    Other episodes