文件转字符串、字符串还原为byte数据

1、文件转字符串 File2Str.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace Sci
{
    /// <summary>
    /// 将任意文件转化为字符串（适用于小文件）
    /// 调用如： Sci.File2Str.Process("D:\1.txt")
    /// </summary>
    public class File2Str
    {
        /// <summary>
        /// 将文件转化为字符串
        /// </summary>
        /// <param name="filePath">待处理的文件</param>
        /// <param name="shrink">是否压缩字符串长度</param>
        /// <returns></returns>
        public static string Process(string filePath, bool shrink = true)
        {
            if (!filePath.EndsWith(".data"))
            {
                string data = getFileData(filePath, shrink);
                filePath += ".data";

                File.WriteAllText(filePath, data, Encoding.UTF8);
            }
            return filePath;
        }

        /// <summary>
        /// 获取文件对应的编码字符串
        /// </summary>
        private static string getFileData(string file, bool shrink = true)
        {
            byte[] bytes = File2Bytes(file);
            string data = ToStr(bytes);
            if (shrink) data = Shrink(data);

            return data;
        }

        /// <summary>  
        /// 将文件转换为byte数组  
        /// </summary>  
        /// <param name="path">文件地址</param>  
        /// <returns>转换后的byte数组</returns>  
        private static byte[] File2Bytes(string path)
        {
            if (!File.Exists(path)) return new byte[0];
            else return File.ReadAllBytes(path);
        }

        /// <summary>  
        /// 每个字节转化为两个字母  
        /// </summary>  
        private static string ToStr(byte[] B)
        {
            StringBuilder Str = new StringBuilder();
            foreach (byte b in B)
            {
                Str.Append(ToStr(b));
            }
            return Str.ToString();
        }
        
        /// <summary>
        /// 每个字节转化为两个字符
        /// </summary>
        private static string ToStr(byte b)
        {
            return "" + ToChar(b / 16) + ToChar(b % 16);
        }

        /// <summary>
        /// 0-15依次转化为字符
        /// </summary>
        /// <param name="n">0-15</param>
        private static char ToChar(int n)
        {
            return (char)('c' + n);
        }

        /// <summary>
        /// 重复字符压缩
        /// enfkjaaaadaaaaaaaeaaaaaappppaaaaliaaaaaaaaaaaaaaeaaaaaaaaaaa -> 
        /// enfkja4da6p4a4lia14ea11
        /// </summary>
        /// <param name="alphaStr"></param>
        /// <returns></returns>
        private static string Shrink(string alphaStr)
        {
            StringBuilder builder = new StringBuilder();
            int count = 0;

            char C = ' ';
            foreach (char c in alphaStr)
            {
                if (c == C) count++;
                else
                {
                    if (count <= 2)
                    {
                        if (C != ' ') builder.Append(C.ToString() + (count == 2 ? C.ToString() : ""));
                    }
                    else builder.Append(C + count.ToString());

                    C = c;
                    count = 1;
                }
            }

            if (count <= 2)
            {
                if (C != ' ') builder.Append(C.ToString() + (count == 2 ? C.ToString() : ""));
            }
            else builder.Append(C + count.ToString());

            return builder.ToString();
        }
    }

}

2、字符串还原为byte数据 Str2Bytes.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace Sci
{
    /// <summary>
    /// 将File2Str生成的字符串，还原为byte[]数据
    /// 调用如： Sci.Str2Bytes.Process("gphmlc4fc7gc6r4c4nkc14gc71k")
    /// </summary>
    public class Str2Bytes
    {
        /// <summary>
        /// 还原File2Str生成字符串为byte[]数据
        /// </summary>
        /// <param name="file2strData">由File2Str生成的字符串</param>
        /// <returns></returns>
        public static byte[] Process(string file2strData)
        {
            string data = Restore(file2strData);
            byte[] B = ToBytes(data);
            return B;
        }

        /// <summary>
        /// 还原为原有串信息
        /// enfkja4da6p4a4lia14ea11 -> 
        /// enfkjaaaadaaaaaaaeaaaaaappppaaaaliaaaaaaaaaaaaaaeaaaaaaaaaaa
        /// </summary>
        /// <param name="shrinkStr"></param>
        /// <returns></returns>
        private static string Restore(string shrinkStr)
        {
            char C = ' ';
            StringBuilder builder = new StringBuilder();
            string numStr = "";

            foreach (char c in shrinkStr)
            {
                if ('a' <= c && c <= 'z')
                {
                    if (!numStr.Equals(""))
                    {
                        int n = Int32.Parse(numStr);
                        while (n-- > 1) builder.Append(C.ToString());
                        numStr = "";
                    }

                    builder.Append(c.ToString());
                    C = c;
                }
                else if ('0' <= c && c <= '9')
                {
                    numStr += c.ToString();
                }
            }

            if ('a' <= C && C <= 'z')
            {
                if (!numStr.Equals(""))
                {
                    int n = Int32.Parse(numStr);
                    while (n-- > 1) builder.Append(C.ToString());
                    numStr = "";
                }
            }

            return builder.ToString();
        }

        /// <summary>  
        /// 解析字符串为Bytes数组
        /// </summary>  
        private static byte[] ToBytes(string data)
        {
            byte[] B = new byte[data.Length / 2];
            char[] C = data.ToCharArray();

            for (int i = 0; i < C.Length; i += 2)
            {
                byte b = ToByte(C[i], C[i + 1]);
                B[i / 2] = b;
            }

            return B;
        }

        /// <summary>  
        /// 每两个字母还原为一个字节  
        /// </summary>  
        private static byte ToByte(char a1, char a2)
        {
            return (byte)((a1 - 'c') * 16 + (a2 - 'c'));
        }
    }

}