.NET开发不可不知、不可不用的辅助类（二）

/// <summary>
/// 序列化及反序列化的辅助类
/// </summary>
public sealed class SerializeUtil
{
    private SerializeUtil()
    {
    }

    //序列化操作函数
    #region 序列化操作函数

    /// <summary>
    /// 将对象序列化为二进制字节
    /// </summary>
    /// <param name="obj">待序列化的对象</param>
    /// <returns></returns>
    public static byte[] SerializeToBinary(object obj)
    {
        byte[] bytes = new byte[2500];
        using (MemoryStream memoryStream = new MemoryStream())
        {
            BinaryFormatter bformatter = new BinaryFormatter();
            bformatter.Serialize(memoryStream, obj);
            memoryStream.Seek(0, 0);

            if (memoryStream.Length > bytes.Length)
            {
                bytes = new byte[memoryStream.Length];
            }
            bytes = memoryStream.ToArray();
        }
        return bytes;
    }

    /// <summary>
    /// 将文件对象序列化到文件中
    /// </summary>
    /// <param name="obj">待序列化的对象</param>
    /// <param name="path">文件路径</param>
    /// <param name="fileMode">文件打开模式</param>
    public static void SerializeToBinary(object obj, string path, FileMode fileMode)
    {
        using (FileStream fs = new FileStream(path, fileMode))
        {
            // Construct a BinaryFormatter and use it to serialize the data to the stream.
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(fs, obj);
        }
    }

    /// <summary>
    /// 将文件对象序列化到文件中
    /// </summary>
    /// <param name="obj">待序列化的对象</param>
    /// <param name="path">文件路径</param>
    public static void SerializeToBinary(object obj, string path)
    {
        SerializeToBinary(obj, path, FileMode.Create);
    }

    /// <summary>
    /// 将对象序列化为Soap字符串
    /// </summary>
    /// <param name="obj">待序列化的对象</param>
    /// <returns>Soap字符串</returns>
    public static string SerializeToSoap(object obj)
    {
        string soap = string.Empty;
        using (MemoryStream memoryStream = new MemoryStream())
        {
            SoapFormatter sformatter = new SoapFormatter();
            sformatter.Serialize(memoryStream, obj);
            memoryStream.Seek(0, 0);
            soap = Encoding.ASCII.GetString(memoryStream.ToArray());
        }

        return soap;
    }

    /// <summary>
    /// 将对象序列化为Soap字符串，并保存到文件中
    /// </summary>
    /// <param name="obj">待序列化的对象</param>
    /// <param name="path">文件路径</param>
    /// <param name="fileMode">文件打开模式</param>
    public static void SerializeToSoap(object obj, string path, FileMode fileMode)
    {
        FileStream fs = new FileStream(path, fileMode);

        // Construct a BinaryFormatter and use it to serialize the data to the stream.
        SoapFormatter formatter = new SoapFormatter();
        try
        {
            formatter.Serialize(fs, obj);
        }
        catch (SerializationException e)
        {
            Console.WriteLine("Failed to serialize. Reason: " + e.Message);
            throw;
        }
        finally
        {
            fs.Close();
        }
    }

    /// <summary>
    /// 将对象序列化为Soap字符串，并保存到文件中
    /// </summary>
    /// <param name="obj">待序列化的对象</param>
    /// <param name="path">文件路径</param>
    public static void SerializeToSoap(object obj, string path)
    {
        SerializeToSoap(obj, path, FileMode.Create);
    }

    /// <summary>
    /// 将对象序列化为XML字符串
    /// </summary>
    /// <param name="obj">待序列化的对象</param>
    /// <returns>XML字符串</returns>
    public static string SerializeToXml(object obj)
    {
        string xml = "";
        using (MemoryStream memoryStream = new MemoryStream())
        {
            XmlSerializer serializer = new XmlSerializer(obj.GetType());
            serializer.Serialize(memoryStream, obj);
            memoryStream.Seek(0, 0);
            xml = Encoding.ASCII.GetString(memoryStream.ToArray());
        }

        return xml;
    }

    /// <summary>
    /// 将对象序列化为XML字符串并保存到文件
    /// </summary>
    /// <param name="obj">待序列化的对象</param>
    /// <param name="path">保存的文件路径</param>
    /// <param name="fileMode">文件打开模式</param>
    public static void SerializeToXmlFile(object obj, string path, FileMode fileMode)
    {
        using (FileStream fileStream = new FileStream(path, fileMode))
        {
            // Construct a BinaryFormatter and use it to serialize the data to the stream.
            XmlSerializer serializer = new XmlSerializer(obj.GetType());
            serializer.Serialize(fileStream, obj);
        }
    }

    /// <summary>
    /// 将对象序列化为XML字符串并保存到文件
    /// </summary>
    /// <param name="obj">待序列化的对象</param>
    /// <param name="path">保存的文件路径</param>
    public static void SerializeToXmlFile(object obj, string path)
    {
        SerializeToXmlFile(obj, path, FileMode.Create);
    }

    #endregion

    //反序列化操作函数

    #region 反序列化操作函数

    /// <summary>
    /// 从XML文件中反序列化为Object对象
    /// </summary>
    /// <param name="type">对象的类型</param>
    /// <param name="path">XML文件</param>
    /// <returns>反序列化后得到的对象</returns>
    public static object DeserializeFromXmlFile(Type type, string path)
    {
        object result = new object();
        using (FileStream fileStream = new FileStream(path, FileMode.Open))
        {
            XmlSerializer serializer = new XmlSerializer(type);
            result = serializer.Deserialize(fileStream);
        }

        return result;
    }

    /// <summary>
    /// 从XML文件中反序列化为对象
    /// </summary>
    /// <param name="type">对象的类型</param>
    /// <param name="xml">XML字符串</param>
    /// <returns>反序列化后得到的对象</returns>
    public static object DeserializeFromXml(Type type, string xml)
    {
        object result = new object();
        XmlSerializer serializer = new XmlSerializer(type);
        result = serializer.Deserialize(new StringReader(xml));

        return result;
    }

    /// <summary>
    /// 从Soap字符串中反序列化为对象
    /// </summary>
    /// <param name="type">对象的类型</param>
    /// <param name="soap">soap字符串</param>
    /// <returns>反序列化后得到的对象</returns>
    public static object DeserializeFromSoap(Type type, string soap)
    {
        object result = new object();
        using (MemoryStream memoryStream = new MemoryStream(new UTF8Encoding().GetBytes(soap)))
        {
            SoapFormatter serializer = new SoapFormatter();
            result = serializer.Deserialize(memoryStream);
        }

        return result;
    }

    /// <summary>
    /// 从二进制字节中反序列化为对象
    /// </summary>
    /// <param name="type">对象的类型</param>
    /// <param name="bytes">字节数组</param>
    /// <returns>反序列化后得到的对象</returns>
    public static object DeserializeFromBinary(Type type, byte[] bytes)
    {
        object result = new object();
        using (MemoryStream memoryStream = new MemoryStream(bytes))
        {
            BinaryFormatter serializer = new BinaryFormatter();
            result = serializer.Deserialize(memoryStream);
        }

        return result;
    }

    /// <summary>
    /// 从二进制文件中反序列化为对象
    /// </summary>
    /// <param name="type">对象的类型</param>
    /// <param name="path">二进制文件路径</param>
    /// <returns>反序列化后得到的对象</returns>
    public static object DeserializeFromBinary(Type type, string path)
    {
        object result = new object();
        using (FileStream fileStream = new FileStream(path, FileMode.Open))
        {
            BinaryFormatter serializer = new BinaryFormatter();
            result = serializer.Deserialize(fileStream);
        }

        return result;
    }

    #endregion

    /// <summary>
    /// 获取对象的转换为二进制的字节大小
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static long GetByteSize(object obj)
    {
        long result;
        BinaryFormatter bFormatter = new BinaryFormatter();
        using (MemoryStream stream = new MemoryStream())
        {
            bFormatter.Serialize(stream, obj);
            result = stream.Length;
        }
        return result;
    }

    /// <summary>
    /// 克隆一个对象
    /// </summary>
    /// <param name="obj">待克隆的对象</param>
    /// <returns>克隆的一个新的对象</returns>
    public static object Clone(object obj)
    {
        object cloned = null;
        BinaryFormatter bFormatter = new BinaryFormatter();
        using (MemoryStream memoryStream = new MemoryStream())
        {
            try
            {
                bFormatter.Serialize(memoryStream, obj);
                memoryStream.Seek(0, SeekOrigin.Begin);
                cloned = bFormatter.Deserialize(memoryStream);
            }
            catch //(Exception e)
            {
                ;
            }
        }

        return cloned;
    }

    /// <summary>
    /// 从文件中读取文本内容
    /// </summary>
    /// <param name="path">文件路径</param>
    /// <returns>文件的内容</returns>
    public static string ReadFile(string path)
    {
        string content = string.Empty;
        using (StreamReader reader = new StreamReader(path))
        {
            content = reader.ReadToEnd();
        }

        return content;
    }

    /// <summary>
    /// 读取嵌入资源的文本内容
    /// </summary>
    /// <param name="fileWholeName">包含命名空间的嵌入资源文件名路径</param>
    /// <returns>文件中的文本内容</returns>
    public static string ReadFileFromEmbedded(string fileWholeName)
    {
        string result = string.Empty;

        Assembly assembly = Assembly.GetEntryAssembly();
        using (TextReader reader = new StreamReader(assembly.GetManifestResourceStream(fileWholeName)))
        {
            result = reader.ReadToEnd();
        }

        return result;
    }
}

/// <summary>
/// 序列化及反序列化的辅助类SerializeUtil测试代码
/// </summary>
public class TestSerializeUtil
{
    public static string Execute()
    {
        string result = string.Empty;
        result += "使用SerializeUtil序列化及反序列化的辅助类：" + "\r\n";

        Person person = new Person();
        person.Name = "wuhuacong";
        person.Age = 20;

        byte[] bytes = SerializeUtil.SerializeToBinary(person);
        Person person2 = SerializeUtil.DeserializeFromBinary(typeof(Person), bytes) as Person;
        result += ReflectionUtil.GetProperties(person2) + "\r\n";

        string xml = SerializeUtil.SerializeToXml(person);
        Person person3 = SerializeUtil.DeserializeFromXml(typeof(Person), xml) as Person;
        result += "person3:\r\n" + ReflectionUtil.GetProperties(person3) + "\r\n";

        result += "SerializeUtil.GetByteSize(person3):" + SerializeUtil.GetByteSize(person3) + "\r\n";

        Person person4 = SerializeUtil.Clone(person3) as Person;
        result += "person4:\r\n" + ReflectionUtil.GetProperties(person4) + "\r\n";

        result += "Util.AreObjectsEqual(person3, person4):" + Util.AreObjectsEqual(person3, person4) + "\r\n";

        SerializeUtil.SerializeToXmlFile(person3, Util.CurrentPath + "person3.xml", FileMode.Create);
        Person person5 = SerializeUtil.DeserializeFromXmlFile(typeof(Person), Util.CurrentPath + "person3.xml") as Person;
        result += "person5:\r\n" + ReflectionUtil.GetProperties(person5) + "\r\n\r\n";

        result += SerializeUtil.ReadFile(Util.CurrentPath + "person3.xml") + "\r\n\r\n";
        result += SerializeUtil.ReadFileFromEmbedded("TestUtilities.EmbedFile.xml") + "\r\n\r\n";

        return result;
    }
}

///////////////////////////////////////////////////////

 

/// <summary>
/// 用来转换含有NULL值的字段为合适值的辅助类
/// </summary>
public sealed class SmartDataReader
{
    private DateTime defaultDate;

    public SmartDataReader(IDataReader reader)
    {
        defaultDate = Convert.ToDateTime("01/01/1900");
        this.reader = reader;
    }

    public int GetInt32(String column)
    {
        int data = (reader.IsDBNull(reader.GetOrdinal(column))) ? (int)0 : (int)reader[column];
        return data;
    }

    public short GetInt16(String column)
    {
        short data = (reader.IsDBNull(reader.GetOrdinal(column))) ? (short)0 : (short)reader[column];
        return data;
    }

    public byte GetByte(String column)
    {
        byte data = (reader.IsDBNull(reader.GetOrdinal(column))) ? (byte)0 : (byte)reader[column];
        return data;
    }

    public float GetFloat(String column)
    {
        float data = (reader.IsDBNull(reader.GetOrdinal(column))) ? 0 : float.Parse(reader[column].ToString());
        return data;
    }

    public double GetDouble(String column)
    {
        double data = (reader.IsDBNull(reader.GetOrdinal(column))) ? 0 : double.Parse(reader[column].ToString());
        return data;
    }

    public decimal GetDecimal(String column)
    {
        decimal data = (reader.IsDBNull(reader.GetOrdinal(column))) ? 0 : decimal.Parse(reader[column].ToString());
        return data;
    }

    public Single GetSingle(String column)
    {
        Single data = (reader.IsDBNull(reader.GetOrdinal(column))) ? 0 : Single.Parse(reader[column].ToString());
        return data;
    }

    public bool GetBoolean(String column)
    {
        bool data = (reader.IsDBNull(reader.GetOrdinal(column))) ? false : (bool)reader[column];
        return data;
    }

    public String GetString(String column)
    {
        String data = (reader.IsDBNull(reader.GetOrdinal(column))) ? null : reader[column].ToString();
        return data;
    }

    public byte[] GetBytes(String column)
    {
        String data = (reader.IsDBNull(reader.GetOrdinal(column))) ? null : reader[column].ToString();
        return Encoding.UTF8.GetBytes(data);
    }

    public Guid GetGuid(String column)
    {
        String data = (reader.IsDBNull(reader.GetOrdinal(column))) ? null : reader[column].ToString();
        Guid guid = Guid.Empty;
        if (data != null)
        {
            guid = new Guid(data);
        }
        return guid;
    }

    public DateTime GetDateTime(String column)
    {
        DateTime data = (reader.IsDBNull(reader.GetOrdinal(column))) ? defaultDate : (DateTime)reader[column];
        return data;
    }

    public bool Read()
    {
        return reader.Read();
    }

    private IDataReader reader;
}

/// <summary>
/// 数据库字段NULL值转换辅助类SmartDataReader测试代码
/// </summary>
public class TestSmartDataReader
{
    public static string Execute()
    {
        string result = string.Empty;
        result += "使用SmartDataReader辅助类：" + "\r\n";

        try
        {
            TestInfo person = SelectOne();
            result += ReflectionUtil.GetProperties(person) + "\r\n \r\n";
        }
        catch (Exception ex)
        {
            result += string.Format("发生错误:{0}！\r\n \r\n", ex.Message);
        }
        return result;
    }

    /// <summary>
    /// 将DataReader的属性值转化为实体类的属性值，返回实体类
    /// </summary>
    /// <param name="dataReader">有效的DataReader对象</param>
    /// <returns>实体类对象</returns>
    private static TestInfo DataReaderToEntity(IDataReader dataReader)
    {
        TestInfo testInfo = new TestInfo();
        SmartDataReader reader = new SmartDataReader(dataReader);

        testInfo.ID = reader.GetInt32("ID");
        testInfo.Name = reader.GetString("Name");
        testInfo.Age = reader.GetInt32("Age");
        testInfo.Man = reader.GetBoolean("Man");
        testInfo.Birthday = reader.GetDateTime("Birthday");

        return testInfo;
    }

    public static TestInfo SelectOne()
    {
        TestInfo testInfo = null;
        string sqlCommand = " Select top 1 * from Test";

        string connectionString = "Server=localhost;Database=Test;uid=sa;pwd=123456";
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();
            SqlCommand com = new SqlCommand(sqlCommand, connection);
            using (IDataReader reader = com.ExecuteReader())
            {
                if (reader.Read())
                {
                    testInfo = DataReaderToEntity(reader);
                }
            }
        }
        return testInfo;
    }
}

/////////////////////////////////////////////////////////

 /// <summary>
    /// 字符串操作辅助类
    /// </summary>
public class StringUtil
{
    // 一些基本的符号常量
    #region 一些基本的符号常量

    /// <summary>
    /// 点符号 .
    /// </summary>
    public const string Dot = ".";

    /// <summary>
    /// 下划线 _
    /// </summary>
    public const string UnderScore = "_";

    /// <summary>
    /// 逗号加空格 ,
    /// </summary>
    public const string CommaSpace = ", ";

    /// <summary>
    /// 逗号 ,
    /// </summary>
    public const string Comma = ",";

    /// <summary>
    /// 左括号 (
    /// </summary>
    public const string OpenParen = "(";

    /// <summary>
    /// 右括号 )
    /// </summary>
    public const string ClosedParen = ")";

    /// <summary>
    /// 单引号 '
    /// </summary>
    public const string SingleQuote = "\'";

    /// <summary>
    /// 斜线 \
    /// </summary>
    public const string Slash = @"\";

    #endregion

    private StringUtil()
    {
    }

    /// <summary>
    /// 移除空格并首字母小写的Camel样式
    /// </summary>
    /// <param name="name"></param>
    /// <returns></returns>
    public static string ToCamel(string name)
    {
        string clone = name.TrimStart('_');
        clone = RemoveSpaces(ToProperCase(clone));
        return String.Format("{0}{1}", Char.ToLower(clone[0]), clone.Substring(1, clone.Length - 1));
    }

    /// <summary>
    /// 移除空格并首字母大写的Pascal样式
    /// </summary>
    /// <param name="name"></param>
    /// <returns></returns>
    public static string ToCapit(string name)
    {
        string clone = name.TrimStart('_');
        return RemoveSpaces(ToProperCase(clone));
    }

    /// <summary>
    /// 移除最后的字符
    /// </summary>
    /// <param name="s"></param>
    /// <returns></returns>
    public static string RemoveFinalChar(string s)
    {
        if (s.Length > 1)
        {
            s = s.Substring(0, s.Length - 1);
        }
        return s;
    }

    /// <summary>
    /// 移除最后的逗号
    /// </summary>
    /// <param name="s"></param>
    /// <returns></returns>
    public static string RemoveFinalComma(string s)
    {
        if (s.Trim().Length > 0)
        {
            int c = s.LastIndexOf(",");
            if (c > 0)
            {
                s = s.Substring(0, s.Length - (s.Length - c));
            }
        }
        return s;
    }

    /// <summary>
    /// 移除字符中的空格
    /// </summary>
    /// <param name="s"></param>
    /// <returns></returns>
    public static string RemoveSpaces(string s)
    {
        s = s.Trim();
        s = s.Replace(" ", "");
        return s;
    }

    /// <summary>
    /// 字符串首字母大写
    /// </summary>
    /// <param name="s"></param>
    /// <returns></returns>
    public static string ToProperCase(string s)
    {
        string revised = "";
        if (s.Length > 0)
        {
            if (s.IndexOf(" ") > 0)
            {
                revised = Strings.StrConv(s, VbStrConv.ProperCase, 1033);
            }
            else
            {
                string firstLetter = s.Substring(0, 1).ToUpper(new CultureInfo("en-US"));
                revised = firstLetter + s.Substring(1, s.Length - 1);
            }
        }
        return revised;
    }

    /// <summary>
    /// 判断字符是否NULL或者为空
    /// </summary>
    public static bool IsNullOrEmpty(string value)
    {
        if (value == null || value == string.Empty)
        {
            return true;
        }

        return false;
    }
}

/// <summary>
/// 字符串操作辅助类测试代码
/// </summary>
public class TestStringUtil
{
    public static string Execute()
    {
        string value = "test String,";

        string result = string.Empty;
        result += "使用StringUtil字符串操作辅助类：" + "\r\n";
        result += "原字符串为:" + value + "\r\n";
        result += "StringUtil.IsNullOrEmpty:" + StringUtil.IsNullOrEmpty(value) + "\r\n";
        result += "StringUtil.ToCamel:" + StringUtil.ToCamel(value) + "\r\n";
        result += "StringUtil.ToCapit:" + StringUtil.ToCapit(value) + "\r\n";
        result += "StringUtil.RemoveSpaces:" + StringUtil.RemoveSpaces(value) + "\r\n";
        result += "StringUtil.RemoveFinalChar:" + StringUtil.RemoveFinalChar(value) + "\r\n";
        result += "StringUtil.ToProperCase:" + StringUtil.ToProperCase(value) + "\r\n";

        result += "\r\n\r\n";
        return result;
    }
}

//////////////////////////////////////////////////////////////////////////

/// <summary>
/// Web界面层操作的辅助类
/// </summary>
public sealed class UIHelper
{
    private static ILog logger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

    private UIHelper()
    {
    }

    /// <summary>
    /// 提示信息，如果异常为HWException类型，则记录到日志
    /// </summary>
    /// <param name="page">当前的页面</param>
    /// <param name="ex">异常对象</param>
    /// <param name="Close">是否关闭</param>
    public static void ShowError(Page page, Exception ex, bool Close)
    {
        logger.Error("Exception:" + page.ID, ex);

        string errorMsg = ex.Message;
        errorMsg = errorMsg.Replace("\n", " ");
        if (Close)
        {
            AlertAndClose(page, errorMsg);
        }
        else
        {
            Alerts(page, errorMsg);
        }
    }

    /// <summary>
    /// 提示信息
    /// </summary>
    /// <param name="control">当前的页面</param>
    /// <param name="message">提示信息</param>
    public static void Alerts(Control control, string message)
    {
        string script = string.Format("<script>javascript:alert(\"{0}\");</script>", message).Replace("\r\n", "");
        control.Page.RegisterStartupScript("", script);
    }

    /// <summary>
    /// 提示信息并关闭窗口
    /// </summary>
    /// <param name="control">当前的页面</param>
    /// <param name="message">提示信息</param>
    public static void AlertAndClose(Control control, string message)
    {
        string script =
            string.Format("<script>javascript:alert(\"{0}\");window.close();</script>", message).Replace("\r\n", "");
        control.Page.RegisterStartupScript("", script);
    }

    /// <summary>
    /// 将错误信息记录到事件日志中
    /// </summary>
    /// <param name="errorMessage">文本信息</param>
    public static void LogError(string errorMessage)
    {
        logger.Error(errorMessage);
    }

    /// <summary>
    /// 将错误信息记录到事件日志中
    /// </summary>
    /// <param name="ex">错误对象</param>
    public static void LogError(Exception ex)
    {
        try
        {
            logger.Error(ex.Message + "\n" + ex.Source + "\n" + ex.StackTrace);
        }
        catch
        {
        }
    }

    /// <summary>
    /// 弹出提示信息
    /// </summary>
    /// <param name="key">key</param>
    /// <param name="message">提示信息</param>
    /// <param name="page">当前请求的page</param>
    public static void Alert(string key, string message, Page page)
    {
        string msg = string.Format("<script language=\"javascript\">alert(\"{0}\");</script>", message);

        page.RegisterStartupScript(key, msg);
    }

    /// <summary>
    /// 弹出提示信息
    /// </summary>
    /// <param name="message"></param>
    /// <param name="page"></param>
    public static void Alert(string message, Page page)
    {
        Alert("message", message, page);
    }

    /**/
    /// <summary>
    /// 定位到指定的页面
    /// </summary>
    /// <param name="GoPage">目标页面</param>
    public static void GoTo(string GoPage)
    {
        HttpContext.Current.Response.Redirect(GoPage);
    }

    /// <summary>
    /// 定位到指定的页面
    /// </summary>
    /// <param name="control">当前请求的page</param>
    /// <param name="page">目标页面</param>
    public static void Location(Control control, string page)
    {
        string js = "<script language='JavaScript'>";
        js += "top.location='" + page + "'";
        js += "</script>";
        control.Page.RegisterStartupScript("", js);
    }
   
   
    /// <summary>
    /// 提示信息并定位到指定的页面
    /// </summary>
    /// <param name="control">当前请求的page</param>
    /// <param name="page">目标页面</param>
    /// <param name="message">提示信息</param>
    public static void AlertAndLocation(Control control, string page, string message)
    {
        string js = "<script language='JavaScript'>";
        js += "alert('" + message + "');";
        js += "top.location='" + page + "'";
        js += "</script>";
        control.Page.RegisterStartupScript("", js);
    }

    /// <summary>
    /// 关闭页面，并返回指定的值
    /// </summary>
    /// <param name="control"></param>
    /// <param name="returnValue"></param>
    public static void CloseWin(Control control, string returnValue)
    {
        string js = "<script language='JavaScript'>";
        js += "window.parent.returnValue='" + returnValue + "';";
        js += "window.close();";
        js += "</script>";
        control.Page.RegisterStartupScript("", js);
    }

    /// <summary>
    /// 获取Html的锚点
    /// </summary>
    /// <param name="innerText"></param>
    /// <param name="href"></param>
    /// <returns></returns>
    public static HtmlAnchor GetHtmlAnchor(string innerText, string href)
    {
        HtmlAnchor htmlAnchor = new HtmlAnchor();
        htmlAnchor.InnerText = innerText;
        htmlAnchor.HRef = href;

        return htmlAnchor;
    }

    /// <summary>
    /// 判断输入的字符是否为数字
    /// </summary>
    /// <param name="strValue"></param>
    /// <returns></returns>
    public static bool IsNumerical(string strValue)
    {
        return Regex.IsMatch(strValue, @"^[0-9]*$");
    }

    /// <summary>
    /// 判断字符串是否是NULL或者string.Empty
    /// </summary>
    /// <param name="text"></param>
    /// <returns></returns>
    public static bool IsNullorEmpty(string text)
    {
        return text == null || text.Trim() == string.Empty;
    }

    /// <summary>
    /// 获取DataGrid控件中选择的项目的ID字符串(要求DataGrid设置datakeyfield="ID")
    /// </summary>
    /// <returns>如果没有选择, 那么返回为空字符串, 否则返回逗号分隔的ID字符串(如1,2,3)</returns>
    public static string GetDatagridItems(DataGrid dg)
    {
        string idstring = string.Empty;
        foreach (DataGridItem item in dg.Items)
        {
            string key = dg.DataKeys[item.ItemIndex].ToString();
            bool isSelected = ((CheckBox)item.FindControl("cbxDelete")).Checked;
            if (isSelected)
            {
                idstring += "'" + key + "'" + ","; //前后追加单引号，可以其他非数值的ID
            }
        }
        idstring = idstring.Trim(',');

        return idstring;
    }

    /// <summary>
    /// 设置下列列表控件的SelectedValue
    /// </summary>
    /// <param name="control">DropDownList控件</param>
    /// <param name="strValue">SelectedValue的值</param>
    public static void SetDropDownListItem(DropDownList control, string strValue)
    {
        if (!IsNullorEmpty(strValue))
        {
            control.ClearSelection();
            ListItem item = control.Items.FindByValue(strValue);
            if (item != null)
            {
                control.SelectedValue = item.Value;
            }
        }
    }
}

 

/// <summary>
/// Web界面层操作的辅助类测试代码
/// </summary>
public class UIText
{
    private void btnShowError_Click(object sender, EventArgs e)
    {
        try
        {
            throw new Exception("测试错误");
        }
        catch (Exception ex)
        {
            UIHelper.ShowError(this, ex, false);
            return;
        }
    }

    private void btnAlert_Click(object sender, EventArgs e)
    {
        UIHelper.Alert("这是一个提示信息", this);
    }
}

/////////////////////////////////////////////////////////////////////