src/WpfEditor/base64.cs

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

namespace WpfEditor
{
    public static class Base64
    {
        // Base64编码表
        private static readonly string Base64Chars =
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

        // 检查字符是否是base64字符
        private static bool IsBase64(char c)
        {
            return (char.IsLetterOrDigit(c) || (c == '+') || (c == '/'));
        }

        /// <summary>
        /// 将图片文件转换为base64字符串
        /// </summary>
        /// <param name="imagePath">图片文件路径</param>
        /// <returns>Base64编码的字符串</returns>
        public static string Base64Encode(string imagePath)
        {
            try
            {
                // 读取文件内容到字节数组
                byte[] data = File.ReadAllBytes(imagePath);

                // 使用.NET内置的Convert类进行Base64编码
                return Convert.ToBase64String(data);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"无法打开文件: {imagePath}, 错误: {ex.Message}");
                return string.Empty;
            }
        }
        public static string Base64Encode(byte[] data)
        {
            try
            {
                return Convert.ToBase64String(data);
            }
            catch (Exception ex)
            {
                return string.Empty;
            }
        }
        /// <summary>
        /// 手动实现Base64编码（类似原C++版本的实现方式）
        /// </summary>
        /// <param name="imagePath">图片文件路径</param>
        /// <returns>Base64编码的字符串</returns>
        public static string Base64EncodeManual(string imagePath)
        {
            try
            {
                // 读取文件内容到字节数组
                byte[] data = File.ReadAllBytes(imagePath);

                StringBuilder ret = new StringBuilder();
                int i = 0;
                int j = 0;
                byte[] char_array_3 = new byte[3];
                byte[] char_array_4 = new byte[4];
                int data_size = data.Length;
                int data_index = 0;

                while (data_index < data_size)
                {
                    char_array_3[i++] = data[data_index++];
                    if (i == 3)
                    {
                        char_array_4[0] = (byte)((char_array_3[0] & 0xfc) >> 2);
                        char_array_4[1] = (byte)(((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4));
                        char_array_4[2] = (byte)(((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6));
                        char_array_4[3] = (byte)(char_array_3[2] & 0x3f);

                        for (i = 0; i < 4; i++)
                            ret.Append(Base64Chars[(int)char_array_4[i]]);
                        i = 0;
                    }
                }

                if (i > 0)
                {
                    for (j = i; j < 3; j++)
                        char_array_3[j] = 0;

                    char_array_4[0] = (byte)((char_array_3[0] & 0xfc) >> 2);
                    char_array_4[1] = (byte)(((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4));
                    char_array_4[2] = (byte)(((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6));
                    char_array_4[3] = (byte)(char_array_3[2] & 0x3f);

                    for (j = 0; j < i + 1; j++)
                        ret.Append(Base64Chars[(int)char_array_4[j]]);

                    while (i++ < 3)
                        ret.Append('=');
                }

                return ret.ToString();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"无法打开文件: {imagePath}, 错误: {ex.Message}");
                return string.Empty;
            }
        }

        /// <summary>
        /// 将base64字符串转换回二进制数据
        /// </summary>
        /// <param name="input">Base64编码的字符串</param>
        /// <returns>解码后的字节数组</returns>
        public static byte[] Base64Decode(string input)
        {
            try
            {
                // 使用.NET内置的Convert类进行Base64解码
                return Convert.FromBase64String(input);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Base64解码错误: {ex.Message}");
                return new byte[0];
            }
        }

        /// <summary>
        /// 手动实现Base64解码（类似原C++版本的实现方式）
        /// </summary>
        /// <param name="input">Base64编码的字符串</param>
        /// <returns>解码后的字节数组</returns>
        public static byte[] Base64DecodeManual(string input)
        {
            // 构建解码表
            int[] decode_table = new int[256];
            for (int i = 0; i < 256; i++)
                decode_table[i] = -1;

            for (int i = 0; i < 64; i++)
                decode_table[Base64Chars[i]] = i;

            List<byte> decoded = new List<byte>();
            int val = 0, bits = -8; // val:24位缓冲区, bits:当前有效位数

            foreach (char c in input)
            {
                if (c == '=') break;               // 遇填充符终止
                if (decode_table[c] == -1) continue; // 跳过非法字符

                val = (val << 6) + decode_table[c]; // 合并6位数据
                bits += 6;
                if (bits >= 0)                      // 每凑够8位输出1字节
                {
                    decoded.Add((byte)((val >> bits) & 0xFF));
                    bits -= 8;
                }
            }

            return decoded.ToArray();
        }

        /// <summary>
        /// 将Base64字符串解码并保存为文件
        /// </summary>
        /// <param name="base64Data">Base64编码的字符串</param>
        /// <param name="outputFile">输出文件路径</param>
        public static void SaveBase64ToFile(string base64Data, string outputFile)
        {
            byte[] binaryData = Base64Decode(base64Data);
            File.WriteAllBytes(outputFile, binaryData);
        }
    }
}