fork(2) download
copy 
  1. // ===++===
  2. //
  3. //    OrtizOL
  4. //
  5. // ===--===
  6. /*============================================================
  7. //
  8. // Clase: CodificadorBase64.cs
  9. //
  10. // Propósito: Demostrar las capacidadese del esquema de
  11. // codificación Base64.
  12. //
  13. ============================================================*/
  14.  
  15. using System;
  16. using System.Text;
  17.  
  18. namespace Recetas.Ch02
  19. {
  20.     internal class CodificadorBase64
  21.     {
  22.         ///<summary>
  23.         /// Punto de entrada a la aplicación
  24.         ///</summary>
  25.         public static void Main()
  26.         {
  27.             // arreglo de datos binarios
  28.             byte[] datosBinarios = { 0x04, 0x43, 0x5F, 0xFF, 0x0, 0xF0, 0x2D, 0x62, 0x78, 
  29.                 0x22, 0x15, 0x51, 0x5A, 0xD6, 0x0C, 0x59, 0x36, 0x63, 0xBD, 0xC2, 0xD5, 
  30.                 0x0F, 0x8C, 0xF5, 0xCA, 0x0C};
  31.  
  32.             // Asegura la divisilidad entre 4.
  33.             char[] datosEnBase64 = new char[(int)(Math.Ceiling((double) datosBinarios.Length / 3) * 4)];
  34.  
  35.             // Presenta resultados en la salida estándar
  36.             Console.WriteLine("\nCodificación de datos binarios:");
  37.             Convert.ToBase64CharArray(datosBinarios, 0, datosBinarios.Length, datosEnBase64, 0);
  38.             Console.WriteLine(new String(datosEnBase64));
  39.             Console.WriteLine("Decodificación de datos binarios:");
  40.             Console.WriteLine(BitConverter.ToString(Convert.FromBase64CharArray(datosEnBase64, 0, datosEnBase64.Length)));
  41.  
  42.             // Codificación de una cadena de caracteres
  43.             Console.WriteLine("\n\nCodificación de cadena caracteres:");
  44.             Console.WriteLine("{0} (Cadena caracteres) -> {1} (Base64)", "\"Experiencias Construcción Software (xCSw)\"\n", CadenaCaracteresABase64("Experiencias Construcción Software (xCSw)"));
  45.             Console.WriteLine("Decodificación de cadena caracteres:");
  46.             Console.WriteLine("{0} (Base64) -> \"{1}\" (cadena de caracteres)", "RQB4AHAAZQByAGkAZQBuAGMAaQBhAHMAIABDAG8AbgBzAHQAcgB1AGMAYwBpAPMAbgAgAFMAbwBmAHQAdwBhAHIAZQAgACgAeABDAFMAdwApAA==", Base64ACadenaCaracteres("RQB4AHAAZQByAGkAZQBuAGMAaQBhAHMAIABDAG8AbgBzAHQAcgB1AGMAYwBpAPMAbgAgAFMAbwBmAHQAdwBhAHIAZQAgACgAeABDAFMAdwApAA=="));
  47.  
  48.             // Codificación de un número decimal
  49.             Console.WriteLine("\n\nCodificación de un número decimal:");
  50.             Console.WriteLine("{0} (decimal) -> \"{1}\" (Base64)\n", 3.14159265358979M, DecimalABase64(3.14159265358979M));
  51.             Console.WriteLine("Decodificación de un número decimal:");
  52.             Console.WriteLine("\"{0}\" (Base64) -> {1}\n (decimal)", "gyRq57kdAQAAAAAAAAAOAA==", Base64ADecimal("gyRq57kdAQAAAAAAAAAOAA=="));
  53.  
  54.             // Codificación de un número decimal
  55.             Console.WriteLine("\nCodificación de un número entero:");
  56.             Console.WriteLine("{0} (entero) -> \"{1}\" (Base64)\n", 1313, EnteroABase64(13213));
  57.             Console.WriteLine("Decodificación de un número entero:");
  58.             Console.WriteLine("\"{0}\" (Base64) -> {1} (entero)", "nTMAAA==", Base64AEntero("nTMAAA=="));
  59.         }
  60.  
  61.         ///<summary>
  62.         /// Codifica una cadena de caracteres usando Base64
  63.         ///<summary>
  64.         ///<param name="cadena">Cadena de caracteres a codificar</param>
  65.         ///<returns>La cadena de caracteres codificada con Base64.<returns>
  66.         public static string CadenaCaracteresABase64(string cadena)
  67.         {
  68.             // Obtención binaria de la cadena
  69.             byte[] bytesCadena = Encoding.Unicode.GetBytes(cadena);
  70.  
  71.             // Codificación usando Base64
  72.             return Convert.ToBase64String(bytesCadena);
  73.         }
  74.  
  75.         ///<summary>
  76.         /// Decodificación de una cadena de caracteres
  77.         ///<summary>
  78.         ///<param name="cadena">Cadena basada en Base64 a decodificar</param>
  79.         ///<returns>Cadena de caracteres decodificada.<returns>
  80.         public static string Base64ACadenaCaracteres(string cadena)
  81.         {
  82.             // Representación binaria de la cadena basada en Base64
  83.             byte[] bytes = Convert.FromBase64String(cadena);
  84.  
  85.             // Decodificación
  86.             return Encoding.Unicode.GetString(bytes);
  87.         }
  88.  
  89.         ///<summary>
  90.         /// Codificación número decimal usando Base64
  91.         ///<summary>
  92.         ///<param name="valor">Valor numérico punto flotante</param>
  93.         ///<returns>Número punto flotante codificado en Base64.<returns>
  94.         public static string DecimalABase64(decimal valor)
  95.         {
  96.             // Representación binaria del número decimal
  97.             byte[] bytes = DecimalAArregloBytes(valor);
  98.  
  99.             // Codificación
  100.             return Convert.ToBase64String(bytes);
  101.         }
  102.  
  103.         ///<summary>
  104.         /// Decodificación de un número decimal a Base64
  105.         ///<summary>
  106.         ///<param name="cadena">Cadena que representa el número decimal codificado en Base64</param>
  107.         ///<returns>Número decimal decodificado.<returns>
  108.         public static decimal Base64ADecimal(string cadena)
  109.         {
  110.             // Decodificación
  111.             byte[] bytes = Convert.FromBase64String(cadena);
  112.  
  113.             // Cadena decodificada en decimal
  114.             return ArregloBytesADecimal(bytes);
  115.         }
  116.  
  117.         ///<summary>
  118.         /// Codificación número entero usando Base64
  119.         ///<summary>
  120.         ///<param name="valor">Valor numérico entero.</param>
  121.         ///<returns>Número entero codificado en Base64.<returns>
  122.         public static string EnteroABase64(int valor)
  123.         {
  124.             // Representación binaria
  125.             byte[] bytes = BitConverter.GetBytes(valor);
  126.  
  127.             // Codificación
  128.             return Convert.ToBase64String(bytes);
  129.         }
  130.  
  131.         ///<summary>
  132.         /// Decodificación de un número entero a Base64
  133.         ///<summary>
  134.         ///<param name="cadena">Cadena que representa el número entero codificado en Base64</param>
  135.         ///<returns>Número entero decodificado.<returns>
  136.         public static int Base64AEntero(string cadena)
  137.         {
  138.             // Decodificación
  139.             byte[] bytes = Convert.FromBase64String(cadena);
  140.  
  141.             // Entero
  142.             return BitConverter.ToInt32(bytes, 0);
  143.         }
  144.  
  145.         ///<summary>
  146.         /// Crea un arreglo de bytes a partir de un valor numérico de punto flotante
  147.         ///<summary>
  148.         ///<param name="valor">Valor numérico punto flotante</param>
  149.         ///<returns>Arreglo de bytes que representa el valor numérico.<returns>
  150.         public static byte[] DecimalAArregloBytes(decimal valor)
  151.         {
  152.             using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
  153.             {
  154.                 using (System.IO.BinaryWriter bw = new System.IO.BinaryWriter(ms))
  155.                 {
  156.                     // Escribe el valor punto flotante sobre el BinaryWriter
  157.                     bw.Write(valor);
  158.  
  159.                     return ms.ToArray();
  160.                 }
  161.             }
  162.         }
  163.  
  164.         ///<summary>
  165.         /// Convierte un arreglo de bytes a un valor punto flotante
  166.         ///<summary>
  167.         ///<param name="bytes">Arreglo de bytes</param>
  168.         ///<returns>Valor punto flotante.<returns>
  169.         public static decimal ArregloBytesADecimal(byte[] bytes)
  170.         {
  171.             using(System.IO.MemoryStream ms = new System.IO.MemoryStream(bytes))
  172.             {
  173.                 using(System.IO.BinaryReader br = new System.IO.BinaryReader(ms))
  174.                 {
  175.                     return br.ReadDecimal();
  176.                 }
  177.             }
  178.         }
  179.     }
  180. }
Success #stdin #stdout 0.04s 33952KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Codificación de datos binarios:
BENf/wDwLWJ4IhVRWtYMWTZjvcLVD4z1ygw=
Decodificación de datos binarios:
04-43-5F-FF-00-F0-2D-62-78-22-15-51-5A-D6-0C-59-36-63-BD-C2-D5-0F-8C-F5-CA-0C


Codificación de cadena caracteres:
"Experiencias Construcción Software (xCSw)"
 (Cadena caracteres) -> RQB4AHAAZQByAGkAZQBuAGMAaQBhAHMAIABDAG8AbgBzAHQAcgB1AGMAYwBpAPMAbgAgAFMAbwBmAHQAdwBhAHIAZQAgACgAeABDAFMAdwApAA== (Base64)
Decodificación de cadena caracteres:
RQB4AHAAZQByAGkAZQBuAGMAaQBhAHMAIABDAG8AbgBzAHQAcgB1AGMAYwBpAPMAbgAgAFMAbwBmAHQAdwBhAHIAZQAgACgAeABDAFMAdwApAA== (Base64) -> "Experiencias Construcción Software (xCSw)" (cadena de caracteres)


Codificación de un número decimal:
3.14159265358979 (decimal) -> "gyRq57kdAQAAAAAAAAAOAA==" (Base64)

Decodificación de un número decimal:
"gyRq57kdAQAAAAAAAAAOAA==" (Base64) -> 3.14159265358979
 (decimal)

Codificación de un número entero:
1313 (entero) -> "nTMAAA==" (Base64)

Decodificación de un número entero:
"nTMAAA==" (Base64) -> 13213 (entero)
https://ideone.com/0FGVeW
language:
C# (gmcs 5.20.1)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!