escribir en consola "Desde: 0 hasta: 15" 
    Bucle para k desde 0 a 255
        escribir en consola en misma linea (k xor 10)  + ", "
        Si (((k+1) and 15) = 0) 
               escribir en consola nueva linea
               escribir en consola "Desde: " + k + " hasta: " + (k+15) 
        Fin si
    Fin bucle 

 
            string s = "En un lugar de 'La Mancha', de cuyo nombre no quiero acordarme.";
            string r, t;
 
            s = "las matematicas son muy utiles";
            int k;
            int j = s.Length;
 
            //1- Convertir un string a un array de bytes:
            byte[] Cifrado = Encoding.Default.GetBytes(s);   //o también  ASCIIEncoding.ASCII.GetBytes(s) 
 
            // 2- Cifrar el byte[k] con Xor 10:
            for (k = 0; k < j; k++){
                Cifrado[k] = (byte) ( Cifrado[k] ^ 10);
            }
 
            // 3 - Convertir el array de bytes en un string, de nuevo.
            r = Encoding.Default.GetString(Cifrado);  
 

Console.Title = Console.Title.Decode

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
 
namespace Encriptar_variable_Consola_01{
    using CustomExtensions;
    class Program{
        static void Main(string[] args){
            string Key = "QWERTYUIOP";
            string s = "En un lugar de 'La Mancha', de cuyo nombre no quiero acordarme.";
            string r, t;
 
            r = s.Code(Key);
            System.Console.WriteLine("El texto original {0} cifrado con la clave {1}, da por resultado {2}", s, Key, r);
            Console.WriteLine(); 
            t = r.Decode(Key);
            System.Console.WriteLine("...y vuelta atrás, el texto cifrado {0} con la clave {1}, nos devuelve al origen {2}", r, Key, t);
 
            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.Yellow;
            System.Console.WriteLine("Se comprueba que 's' = 't' {0} = {1}", s, t);
            Console.ForegroundColor = ConsoleColor.White;
 
 
 
 
 
            Console.WriteLine();  
            //Console.Title = "Ocultar variable"; // Título de la pantalla.
            Console.Title = "Ocultar variable".Code(Key) ;  
            //string variable = "Esto es una prueba.";
            string variable = "Esto es una prueba.".Code(Key) ;
            Console.WriteLine(variable);
            //Console.WriteLine("Otra prueba.");
            Console.WriteLine("Otra prueba.".Code(Key) );
 
            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Pulse una tecla y observa como cambia el título de la consola a su estado decodificado...");
            Console.ReadKey();
            Console.Title = Console.Title.Decode(Key);
 
            Console.WriteLine("Pulse cualquier tecla para salir.");
            Console.ReadKey(); 
        }
    }
}
 
 
namespace CustomExtensions{
    //Los métodos extendidos, deben ser definidos como una clase estática.
    public static class StringExtension    {        
        public static string Code(this String ElTexto, String LaClave){
            byte[] Cifrado = Encoding.UTF8.GetBytes(ElTexto);
            byte[] Key = Encoding.UTF8.GetBytes(Ampliar(LaClave, Cifrado.Length));
            byte k; 
 
            for (k=0; k< Cifrado.Length; k++){
                Cifrado[k] = (byte)(Cifrado[k] ^ Key[k]);
            }
 
            return Convert.ToBase64String(Cifrado);
        }
 
        public static string Decode(this string Cifrado, String LaClave){
            byte[] Cif = Convert.FromBase64String(Cifrado);             
            byte[] Key = Encoding.UTF8.GetBytes(Ampliar(LaClave, Cif.Length));
            byte k;
 
            for (k = 0; k < Cif.Length; k++){
                Cif[k] = (byte)(Cif[k] ^ Key[k]);
            }
            return Encoding.UTF8.GetString(Cif);
        }
 
        private static string Ampliar(string Key, int Minimo){
            int k, j, i;
 
            byte[] yeK = Encoding.UTF8.GetBytes(Key);
            k = yeK.Length; 
            j = (k-1);
            byte[] tmp= new byte[k];
 
            while (k < Minimo){
                k = (k * 2);
                Array.Resize(ref tmp, k); //redimensionar tmp(0 a k)
                //' El byte primero es la media de los extremos, luego entre el 2ª y el penúltimo, luego entre el 3º y el antepenúltimo... 
                //' el byte último es un xor entre los extremos, luego entre el 2ª y el penúltimo, luego entre el 3º y el antepenúltimo... 
                //' es muy simple, pero puede complicarse todo lo que quieras... y para lo que necesitas es suficiente.
                for (i = 0; i < j; i++) {
                    tmp[i] = (byte) ((yeK[i] + yeK[j-i] ) >> 1) ;
                    tmp[k-1-i] = (byte) (yeK[i] ^ yeK[j-i]);
                }
                //' Se puede complicar más con otras fases: 2,3,4 alterando la forma o la forma en que los índices se conjugan.
 
                yeK = tmp; //' asignamos un array al otro...
                j = (k - 1);
            }
            return Encoding.UTF8.GetString(yeK);
        }
    }
}