ahui .NET 历程

var data = new Comments();
data.ArticleId = 1;
data.AuditStatus = 2;
data.Company = 5;
data.Content = "测试";
data.CreateTime = DateTime.Now;
data.IP = "192.168.1.2";
data.NickName = "张三";
data.ReplyContent = string.Empty;
data.ReplyId = 0;
data.ReplyNickName = string.Empty;
data.ReplyTime = DateTime.Now;
data.Tel = "887964645";
data.UserId = 10;

int[] source = { 5, -3, 6, -7, -6, 1, 8, -4, 0, 0 };
int toRightIdx = 0;
int toLeftIdx = source.Length - 1;
int leftIdx = 0;
int rightIdx = source.Length - 1;
int[] result = new int[source.Length];

while (true)
{
    if (toLeftIdx >= 0)
    {
        int left = source[toRightIdx++];
        if (left < 0) result[leftIdx++] = left;

        int right = source[toLeftIdx--];
        if (right > 0) result[rightIdx--] = right;
    }
    else
    {
        result[rightIdx--] = 0;
    }
    if (leftIdx > rightIdx) break;
}

        /// <summary>
        /// 自定义Ext Ajax请求结果
        /// </summary>
        /// <param name="success">是否成功</param>
        /// <param name="value">结果</param>
        /// <returns></returns>
        protected ActionResult ExtJson(bool success)
        {
            return ExtJson(success, 0, string.Empty);
        }

        /// <summary>
        /// 自定义Ext Ajax请求结果
        /// </summary>
        /// <param name="success">是否成功</param>
        /// <param name="value">结果</param>
        /// <returns></returns>
        protected ActionResult ExtJson(bool success, object value)
        {
            return ExtJson(success, 0, value);
        }

        /// <summary>
        /// 自定义Ext Ajax请求结果
        /// </summary>
        /// <param name="success">是否成功</param>
        /// <param name="value">结果</param>
        /// <returns></returns>
        protected ActionResult ExtJson(bool success, int code, object value)
        {
            return Json(new { success = success, code = code, value = value }, "text/html", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet);
        }

        /// <summary>
        /// 返回服务器端Model验证错误
        /// </summary>
        /// <returns></returns>
        protected ActionResult ModelError()
        {
            List<object> errors = new List<object>();
            foreach (var key in ModelState.Keys)
            {
                var state = ModelState[key];
                foreach (var error in state.Errors)
                {
                    errors.Add(new { id = key, msg = error.ErrorMessage });
                }
            }

            if (errors.Count > 0)
            {
                return ExtJson(false, errors);
            }

            return ExtJson(false, "未知错误，请检查输入！");
        }

if (!ModelState.IsValid)
{
        return ModelError();
}

handler: function() {
    var form = theForm.getForm();
    if (form.isValid()) {
        form.submit({
            waitMsg: '正在提交...',
            success: function(form, action) {
                Ext.Msg.alert('成功', '保存成功!', function() {
                    win.hide();
                    store.loadPage();
                });
            },
            failure: function(form, action) {
                if (action.result) {
                    if (typeof(action.result.value) == 'string') Ext.Msg.alert('失败', action.result.value);
                    else if (action.result.value.constructor == Array) theForm.getForm().markInvalid(action.result.value);
                } else {
                    Ext.Msg.alert('失败', '未知错误');
                }
            }
        });
    }
}

public static class ByteHexHelper
{
    private static char[] _buffedChars = null;
    private static byte[] _buffedBytes = null;

    static ByteHexHelper()
    {
        _buffedChars = new char[(byte.MaxValue - byte.MinValue + 1) * 2];
        int idx = 0;
        byte b = byte.MinValue;
        while (true)
        {
            string hexs = b.ToString("X2");
            _buffedChars[idx++] = hexs[0];
            _buffedChars[idx++] = hexs[1];

            if (b == byte.MaxValue) break;
            ++b;
        }

        _buffedBytes = new byte[0x67];
        idx = _buffedBytes.Length;
        while (--idx >= 0)
        {
            if ((0x30 <= idx) && (idx <= 0x39))
            {
                _buffedBytes[idx] = (byte)(idx - 0x30);
            }
            else
            {
                if ((0x61 <= idx) && (idx <= 0x66))
                {
                    _buffedBytes[idx] = (byte)((idx - 0x61) + 10);
                    continue;
                }
                if ((0x41 <= idx) && (idx <= 70))
                {
                    _buffedBytes[idx] = (byte)((idx - 0x41) + 10);
                }
            }
        }
    }

    /// <summary>
    /// 字节数组转16进制字符串
    /// </summary>
    /// <param name="bytes"></param>
    /// <returns></returns>
    public static string ByteToHex(byte[] bytes)
    {
        if (bytes == null)
        {
            return null;
        }

        char[] result = new char[bytes.Length * 2];
        for (int i = 0; i < bytes.Length; ++i)
        {
            int startIndex = (bytes[i] - byte.MinValue) * 2;
            result[i * 2] = _buffedChars[startIndex];
            result[i * 2 + 1] = _buffedChars[startIndex + 1];
        }

        return new string(result);
    }

    /// <summary>
    /// 16进制字符串转字节数组
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static byte[] HexToByte(string str)
    {
        if (str == null || (str.Length & 1) == 1)
        {
            return null;
        }

        byte[] result = new byte[str.Length / 2];
        int charIndex = 0;
        int byteIndex = 0;
        int length = result.Length;
        while (--length >= 0)
        {
            int first = 0;
            int second = 0;
            try
            {
                first = _buffedBytes[str[charIndex++]];
                second = _buffedBytes[str[charIndex++]];
            }
            catch
            {
                return null;
            }
            result[byteIndex++] = (byte)((first << 4) + second);
        }
        return result;
    }
}