Comment puis-je encoder et de décoder une chaîne base64?

Comment puis-je retourner une chaîne encodée en base64 donné une chaîne de caractères?
Comment puis-je décode une chaîne encodée en base64 dans une chaîne de caractères?

Si c'est un "partage de la connaissance" question et réponse, je pense que nous sommes à la recherche de quelque chose d'un peu plus en profondeur. Aussi une recherche rapide de virages jusqu': stackoverflow.com/a/7368168/419
Toute chaîne de caractère est codé par un certain sous-jacent bits-schéma d'encodage. Soit ASCII, UTF7, UTF8 .... La question posée est, au mieux, incomplète.
Demandez-vous avez-vous vraiment besoin de faire cela? Rappelez-vous base64 est principalement conçu pour la représentation binaire des données en ASCII, pour le stockage dans un champ char dans une base de données ou l'envoi par e-mail (où de nouvelles lignes pourrait être injecté). Voulez-vous vraiment prendre les données de caractères, de les convertir en octets, puis de le convertir en arrière à des données de caractère, cette fois illisible et sans préjuger de ce que le codage d'origine a été ?
Pourquoi devrions-nous nous préoccuper de l'origine de l'encodage? On encode la chaîne dans les octets à l'aide de l'UTF8 représentation, ce qui peut représenter tous les caractères de la chaîne. Nous avons ensuite sérialiser des données et à l'autre extrémité, nous désérialiser des données et de nous reconstruire la même chaîne que nous avions à l'origine (objet de type string n'a pas les informations sur l'encodage utilisé de toute façon). Alors, pourquoi est-il tout problème lié à l'encodage utilisé? Nous pouvons le considérer comme un propriétaire manière de représenter les données sérialisées, qui ne devrait pas nous être intéressés de toute façon.

InformationsquelleAutor Kevin Driedger | 2012-07-31

1418

Encoder
```
public static string Base64Encode(string plainText) {
  var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
  return System.Convert.ToBase64String(plainTextBytes);
}
```
Décoder
```
public static string Base64Decode(string base64EncodedData) {
  var base64EncodedBytes = System.Convert.FromBase64String(base64EncodedData);
  return System.Text.Encoding.UTF8.GetString(base64EncodedBytes);
}
```
- Null vérifie les chaînes d'entrée dans les deux fonctions et la solution est parfait 🙂
- Que ou de les rendre les méthodes d'extension.
- Pourquoi faire un null vérifier? Il n'est pas une référence à la chaîne d'entrée. Null vérifie doit empêcher NullReferenceException dans votre propre code, pas de quelqu'un d'autre.
- Suggestion: les Contrats (Contract.Requires(plainText != null)) et votre code est parfait 🙂
- Et quelqu'un d'autre va dire "vous ne devez exposer les erreurs dans votre propre code, pas de quelqu'un d'autre", en invoquant le principe de moindre surprise, agrémenté de "l'échec précoce" et "bonne encapsulation". Parfois, cela signifie emballage erreurs de composants de niveau inférieur, parfois, quelque chose d'autre entièrement. Dans ce cas, je suis d'accord que l'enveloppant d'un deref erreur est certainement douteux (en plus nous sommes tous lentement acceptant le fait que la valeur null comme un concept est un peu un hack pour commencer), mais on peut encore en voir quelques-uns des effets autrement: le paramètre nom donné à l'exception peut ne pas être correcte que si on les laissait faire.
- un Système de retour.Texte.L'encodage.UTF8.GetString(base64EncodedBytes, 0, base64EncodedBytes.La longueur); pour windows phone 8
- Connaissez-vous l'équivalent de ceci en javascript?
- En javaScript utiliser atob() (alpha-à-binaire) pour l'encodage et btoa() pour le décodage
- Je pense qu'une bonne solution de compromis consiste à retourner la valeur null si la valeur null est reçu et que documenté
- pourquoi ne peut-décodage se fait en une ligne? c'est à dire l'Encodage.UTF8.GetString(Convertir.FromBase64String(base64EncodedData))
- Il peut. Pourquoi ne pas le rendre plus facile à lire, bien que?
- Tatiana), il y a une question distincte pour ça: stackoverflow.com/q/246801/1739000
- Que faire si le sous-jacent de la mise en œuvre de System.Convert.FromBase64String a la manière d'encoder la chaîne null? Faire le nul de vérifier dans votre propre code de l'emporterait sur la norme de comportement, non? Le point ici est que, dans ce cas, nous n'avons pas vraiment utiliser (déréférencement) la chaîne donnée en paramètre, mais nous sommes plutôt juste de passer à l'implémentation sous-jacente, essentiellement habillage de certaines fonctionnalités, la création d'une méthode de convenance. Est-il judicieux de vérifier les valeurs null dans ce cas?
InformationsquelleAutor Kevin Driedger

Je suis le partage de mon application avec quelques fonctionnalités intéressantes:

utilise des Méthodes d'Extension pour le Codage de la classe. La justification est que quelqu'un a besoin de l'appui de différents types de codages (pas seulement UTF8).
Une autre amélioration est à défaut gracieusement avec un résultat null null entrée - c'est très utile dans des scénarios de vie réelle et prend en charge l'équivalence pour X=decode(coder(X)).

Remarque: n'oubliez pas que l'utilisation de la Méthode d'Extension vous ont pour (!) importer l'espace de noms avec using mot clé (dans ce cas 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);
        }
    }
}

Exemple d'utilisation:

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);
        }
    }
}

De retour null en cas de null est un très comportements incohérents. Aucun autre .net API travaille avec des chaînes de fait.
n'hésitez pas à ajuster à vos besoins. Comme la façon dont il est ici présenté a été ajustée à la nôtre. Ce n'est pas une API publique 😉
Ne vous devez maintenant envoyer 2 variables à l'autre partie dans le cadre de votre communication (à qui vous envoyez des données encodées en base64)? Vous devez envoyer à la fois le codage utilisé et le nombre réel de données base64? N'est-il pas plus facile si vous utilisez une convention sur les deux côtés d'utiliser le même encodage? De cette façon, vous n'avez qu'à envoyer des données base64, droit?

InformationsquelleAutor andrew.fox

Sur la base des réponses par Andrew Fox et Cebe, je l'ai tourné autour et a fait d'eux chaîne extensions au lieu de Base64String extensions.

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;
        }
    }
}

InformationsquelleAutor j2associates

Une légère variation sur andrew.fox réponse, comme la chaîne à décoder pourrait ne pas être une bonne chaîne encodée en base64:

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;   
            }
        }
    }
}

InformationsquelleAutor Cebe

    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);
        }
    }

Utilisation

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

InformationsquelleAutor Sameera R.

Pour ceux qui veulent tout simplement pour encoder/décoder personne base64 chiffres:

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;
}

Il y a les différentes versions de Base64 qui sont en désaccord à propos de ce qu'il faut utiliser pour les chiffres 62 et 63, donc DecodeBase64Digit peut tolérer plusieurs de ces.

InformationsquelleAutor Qwertie

Vous devez vous connecter pour publier un commentaire.

Encoder

Décoder