月度归档： 2015 年 12 月

关于C#中转换绝对路径和相对路径的说明

一、将绝对路径转换成相对路径：

// 需要转换的绝对路径
string targetPath = "C:/test.txt";
// 相对路径对应的基准绝对路径
string sourcePath = Application.ExecutablePath;
// 构造Uri对象
Uri sourceUri = new Uri(sourcePath);
Uri targetUri = new Uri(targetPath);
// 获取绝对路径对应的相对路径
targetUri = sourceUri.MakeRelativeUri(targetUri);
targetPath = targetUri.ToString();
// 将相对路径反编码为本地路径格式
targetPath = HttpUtility.UrlDecode(targetPath);
// 返回相对路径
return targetPath;

二、将相对路径转换成绝对路径：

// 需要转换的相对路径
string targetPath = "./../test.txt";
// 相对路径对应的基准绝对路径
string sourcePath = Application.ExecutablePath;
// 获取当前工作目录
string tempPath = Environment.CurrentDirectory;
// 设置当前工作目录为基准绝对路径所在目录
Environment.CurrentDirectory = Path.GetDirectoryName(sourcePath);
// 获取相对路径对应的绝对路径
targetPath = Path.GetFullPath(targetPath);
// 还原当前工作目录
Environment.CurrentDirectory = tempPath;
// 返回绝对路径
return targetPath;

关于编程生成MD5字符串的说明

一、在C#中生成MD5字符串：

// 要生成MD5的字符串
string text = "MD5";
// 获取字符串对应字符集的字节缓存数组
byte[] buffer = Encoding.UTF8.GetBytes(text);
// 创建MD5构造器
MD5 md5 = MD5.Create();
// 生成MD5字节缓存数组
buffer = md5.ComputeHash(buffer);
// 将MD5字节缓存数组构造成MD5字符串
StringBuilder stringBuilder = new StringBuilder();
foreach (byte item in buffer)
{
    stringBuilder.Append(item.ToString("x2"));
}
// 获取MD5字符串
return stringBuilder.ToString();

二、在Java中生成MD5字符串：

// 要生成MD5的字符串
String text = "MD5";
// 获取字符串对应字符集的字节缓存数组
byte[] buffer = text.getBytes("UTF-8");
// 创建MD5构造器
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
messageDigest.reset();
// 生成MD5字节缓存数组
messageDigest.update(buffer);
buffer = messageDigest.digest();
// 将MD5字节缓存数组构造成MD5字符串
StringBuffer md5Buffer = new StringBuffer();
for (int i = 0, length = buffer.length; i < length; i++) {
    if (Integer.toHexString(0xFF & buffer[i]).length() == 1) {
        md5Buffer.append("0").append(Integer.toHexString(0xFF & buffer[i]));
    } else {
        md5Buffer.append(Integer.toHexString(0xFF & buffer[i]));
    }
}
// 获取MD5字符串
return md5Buffer.toString();

三、在PHP中生成MD5字符串：

// 要生成MD5的字符串
$text = 'MD5';
// 获取MD5字符串
return md5($text);

四、在JavaScript中生成MD5字符串：

// 定义MD5构造器
(function (window, undefined) {
    // 判断MD5构造器是否已经定义
    if (typeof (window.md5) == "function") {
        return;
    }
    // 定义MD5构造器相关function
    function safe_add(x, y) {
        var lsw = (x & 0xFFFF) + (y & 0xFFFF), msw = (x >> 16) + (y >> 16) + (lsw >> 16);
        return (msw << 16) | (lsw & 0xFFFF);
    }
    function bit_rol(num, cnt) {
        return (num << cnt) | (num >>> (32 - cnt));
    }
    function md5_cmn(q, a, b, x, s, t) {
        return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b);
    }
    function md5_ff(a, b, c, d, x, s, t) {
        return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
    }
    function md5_gg(a, b, c, d, x, s, t) {
        return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
    }
    function md5_hh(a, b, c, d, x, s, t) {
        return md5_cmn(b ^ c ^ d, a, b, x, s, t);
    }
    function md5_ii(a, b, c, d, x, s, t) {
        return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
    }
    function binl_md5(x, len) {
        x[len >> 5] |= 0x80 << (len % 32);
        x[(((len + 64) >>> 9) << 4) + 14] = len;
        var i, olda, oldb, oldc, oldd, a = 1732584193, b = -271733879, c = -1732584194, d = 271733878;
        for (i = 0; i < x.length; i += 16) {
            olda = a;
            oldb = b;
            oldc = c;
            oldd = d;
            a = md5_ff(a, b, c, d, x[i], 7, -680876936);
            d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
            c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
            b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
            a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
            d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
            c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
            b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
            a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
            d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
            c = md5_ff(c, d, a, b, x[i + 10], 17, -42063);
            b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
            a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
            d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
            c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
            b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);
            a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
            d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
            c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
            b = md5_gg(b, c, d, a, x[i], 20, -373897302);
            a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
            d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
            c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
            b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
            a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
            d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
            c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
            b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
            a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
            d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
            c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
            b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);
            a = md5_hh(a, b, c, d, x[i + 5], 4, -378558);
            d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
            c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
            b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
            a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
            d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
            c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
            b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
            a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
            d = md5_hh(d, a, b, c, x[i], 11, -358537222);
            c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
            b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
            a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
            d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
            c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
            b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651);
            a = md5_ii(a, b, c, d, x[i], 6, -198630844);
            d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
            c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
            b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
            a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
            d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
            c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
            b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
            a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
            d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
            c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
            b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
            a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
            d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
            c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
            b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551);
            a = safe_add(a, olda);
            b = safe_add(b, oldb);
            c = safe_add(c, oldc);
            d = safe_add(d, oldd);
        }
        return [a, b, c, d];
    }
    function binl2rstr(input) {
        var i, output = '';
        for (i = 0; i < input.length * 32; i += 8) {
            output += String.fromCharCode((input[i >> 5] >>> (i % 32)) & 0xFF);
        }
        return output;
    }
    function rstr2binl(input) {
        var i, output = [];
        output[(input.length >> 2) - 1] = undefined;
        for (i = 0; i < output.length; i += 1) {
            output[i] = 0;
        }
        for (i = 0; i < input.length * 8; i += 8) {
            output[i >> 5] |= (input.charCodeAt(i / 8) & 0xFF) << (i % 32);
        }
        return output;
    }
    function rstr_md5(s) {
        return binl2rstr(binl_md5(rstr2binl(s), s.length * 8));
    }
    function rstr_hmac_md5(key, data) {
        var i, bkey = rstr2binl(key), ipad = [], opad = [], hash;
        ipad[15] = opad[15] = undefined;
        if (bkey.length > 16) {
            bkey = binl_md5(bkey, key.length * 8);
        }
        for (i = 0; i < 16; i += 1) {
            ipad[i] = bkey[i] ^ 0x36363636;
            opad[i] = bkey[i] ^ 0x5C5C5C5C;
        }
        hash = binl_md5(ipad.concat(rstr2binl(data)), 512 + data.length * 8);
        return binl2rstr(binl_md5(opad.concat(hash), 512 + 128));
    }
    function rstr2hex(input) {
        var hex_tab = '0123456789abcdef', output = '', x, i;
        for (i = 0; i < input.length; i += 1) {
            x = input.charCodeAt(i);
            output += hex_tab.charAt((x >>> 4) & 0x0F) + hex_tab.charAt(x & 0x0F);
        }
        return output;
    }
    function str2rstr_utf8(input) {
        return unescape(encodeURIComponent(input));
    }
    function raw_md5(s) {
        return rstr_md5(str2rstr_utf8(s));
    }
    function hex_md5(s) {
        return rstr2hex(raw_md5(s));
    }
    function raw_hmac_md5(k, d) {
        return rstr_hmac_md5(str2rstr_utf8(k), str2rstr_utf8(d));
    }
    function hex_hmac_md5(k, d) {
        return rstr2hex(raw_hmac_md5(k, d));
    }
    /**
    * text：要生成MD5的字符串
    * return：返回生成的MD5字符串
    */
    window.md5 = function (text, key, raw) {
        if (!key) {
            if (!raw) {
                return hex_md5(text);
            }
            return raw_md5(text);
        }
        if (!raw) {
            return hex_hmac_md5(key, text);
        }
        return raw_hmac_md5(key, text);
    };
})(window);

// 要生成MD5的字符串
var text = "MD5";
// 获取MD5字符串
return md5(text);

更多信息请参阅：MD5_百度百科

关于C#中设置程序开机启动的说明

在Windows系统中我们可以通过修改启动项注册表“HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run”的方法来设置程序是否开机启动：

// 开机启动程序路径
string file = Application.ExecutablePath;
// 开机启动程序注册表键名
string key = Path.GetFileNameWithoutExtension(file);
// 打开启动项注册表
RegistryKey localMachine = Registry.LocalMachine;
RegistryKey runRegistryKey = localMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run", true);

// 通过以下三种方法设置程序是否开机启动
// 1.删除开机启动程序注册表值，取消程序开机启动
runRegistryKey.DeleteValue(key);
// 2.将开机启动程序注册表值设置为程序路径，允许程序开机启动
runRegistryKey.SetValue(key, file);
// 3.获取开机启动程序注册表值，如果程序开机启动，将返回开机启动程序路径，否则返回null
object value = runRegistryKey.GetValue(key);

// 关闭启动项注册表
runRegistryKey.Close();

关于C#中读写INI配置文件的说明

INI配置文件由若干个节（section）组成，每个节又分成若干个键（key）和值（value），在C#程序中我们可以通过引入非托管的Windows API函数来进行读写。

一、引入非托管的Windows API函数：

/// <summary>
/// 读取INI配置信息
/// </summary>
/// <param name="section">节</param>
/// <param name="key">键</param>
/// <param name="def">默认值</param>
/// <param name="retVal">值缓冲区</param>
/// <param name="size">大小</param>
/// <param name="filePath">INI配置文件路径</param>
/// <returns>返回取得字符串缓冲区的长度</returns>
[DllImport("kernel32")]
private static extern long GetPrivateProfileString(string section, string key, string def, StringBuilder retVal, int size, string filePath);

/// <summary>
/// 写入INI配置信息
/// </summary>
/// <param name="section">节</param>
/// <param name="key">键</param>
/// <param name="val">值</param>
/// <param name="filePath">INI配置文件路径</param>
/// <returns>返回0表示失败，非0表示成功</returns>
[DllImport("kernel32")]
private static extern long WritePrivateProfileString(string section, string key, string val, string filePath);

二、读取INI配置信息：

// 值缓冲区大小
int capacity = 1024;
// 配置项所在节
string section = "Section";
// 配置项所在键
string key = "Key";
// 配置项默认值
string defaultValue = "Value";
// INI配置文件路径
string file = "C:/config.ini";
// 创建值缓冲区
StringBuilder stringBuilder = new StringBuilder(capacity);
// 读取配置值
GetPrivateProfileString(section, key, defaultValue, stringBuilder, capacity, file);
return stringBuilder.ToString();

三、写入INI配置信息：

// 配置项所在节
string section = "Section";
// 配置项所在键
string key = "Key";
// 配置项值
string value = "Value";
// INI配置文件路径
string file = "C:/config.ini";
// 写入配置信息
long result = WritePrivateProfileString(section, key, value, file);
// 返回写入是否成功
return result != 0;

更多信息请参阅：配置 Ini 文件项目、WritePrivateProfileString function (Windows)、GetPrivateProfileString function (Windows)

关于C#中转换16进制颜色值的说明

我们可以直接使用ColorTranslator类的静态方法ToHtml和FromHtml将大部分Color对象和16进制颜色值之间进行相互转换。

// 将html中表示的颜色值转换为Color对象，其中包括了24位（#FFFFFF）和32位（#FFFFFFFF）的16进制颜色值
Color color = ColorTranslator.FromHtml("#FFFFFFFF");
// 将Color对象转换为html中表示的颜色值，该方法会将已知名称的Color对象直接转换成颜色的名称（如“Red”），而将非已知名称的颜色转换成24位的16进制颜色值（只有rgb值，没有alpha值）
string html = ColorTranslator.ToHtml(Color.Red);

可以看出“ColorTranslator.FromHtml”方法足以满足我们将16进制颜色值转换为Color对象，但是“ColorTranslator.ToHtml”方法虽然可以将Color对象转换成16进制颜色值，但其转换是不全面的，它针对的是HTML颜色值，丢失了alpha值，而且会将已知名称的Color对象直接转换成颜色的名称，不符合16进制的要求，因此我们可以使用以下方法进行转换：

// 要转换的颜色
Color color = Color.FromArgb(255, 255, 255, 255);
// 颜色的argb值
byte[] buffer = new byte[] { color.A, color.R, color.G, color.B };
// 将每个颜色值分别转换为8位16进制字符串
string html = "#";
foreach (byte item in buffer)
{
    html += string.Format("{0:X2}", item);
}
// 获取32位16进制颜色值
return html;
 ©  LuYutao