下面实现了简单的用户名、密码验证：

using System;
using System.Collections.Generic;
using System.Text;
using System.DirectoryServices.Protocols;
using System.Net;

namespace com.hetaoos.Authenticator
{
    /// <summary>
    /// Ldap 验证
    /// http://blog.hetaoos.com
    /// </summary>
    public class LdapAuthenticator
    {
        /// <summary>
        /// Ldap 验证
        /// </summary>
        /// <param name="domain">服务器</param>
        /// <param name="username">帐号</param>
        /// <param name="pwd">密码</param>
        /// <returns>是否验证成功</returns>
        public static bool ValidateUser(string domain, string userName, string password)
        {
            bool validation = false;
            LdapConnection ldc = null;
            try
            {
                ldc = new LdapConnection(domain);
                //ou=Users,ou=tempusers,ou=staff,dc=guet,dc=org  这串玩意要改为自己的
                NetworkCredential nc = new NetworkCredential(string.Format("uid={0},ou=Users,ou=tempusers,ou=staff,dc=guet,dc=org", userName), password);
                ldc.AuthType = AuthType.Basic;
                ldc.SessionOptions.ProtocolVersion = 3;
                ldc.Bind(nc);
                validation = true;
            }
            catch { }
            finally
            {
                if (ldc != null)
                {
                    ldc.Dispose();
                }
            }
            return validation;
        }

    }
}

PS：
需要添加以下引用：
1,System.DirectoryServices
2,System.DirectoryServices.Protocols

调用很简单：

bool authenticated = LdapAuthenticator.ValidateUser("ldap.hetaoos.com", "null", "hetaoos.com");

无觅猜您也喜欢：

PAC Maker,代理自动配置文件生成器[C#,Open Source]

C# 类 XML 序列化基类

C# 通过文件头判断图像的类型

C# 中反射获取某类的子类和根据类型名动态创建对象

无觅

关联文章:

1. C# 中利用反射机制拷贝类的字段和属性
2. C# 类 XML 序列化基类
3. C# 获取枚举 Enum 变量值的 Description 属性

下面是要用到的泛型：

    internal interface IStack
    {
    }

    public class Stack<T> : IStack
        where T : new()
    {
        public T Value { get; set; }
    }

    public class IntStack : Stack<int> { }

    public class DoubleStack : Stack<double> { }

• 1、取泛型的 Type

要取泛型的 Type，这个稍微有点特殊：

            //取泛型的 Type
            Type type = typeof(Stack<>);

比普通的类型多了对尖括号。

• 2、判断某类型是否是继承于某泛型

如果是判断是否继承于普通类，或者接口，很简单：

    //接口
    public interface IClass { }
    //类
    public class Class : IClass { }
    //子类
    public class SubClass : Class { }

    class Program
    {
        static void Main(string[] args)
        {
            Type typeIClass = typeof(IClass);
            Type typeClass = typeof(Class);
            Type typeSubClass = typeof(SubClass);

            //判断类型的继承关系
            bool isSubclassOf = typeSubClass.IsSubclassOf(typeClass);//true
            bool isAssignableFrom = typeClass.IsAssignableFrom(typeSubClass);//true
            //判断类型是否拥有该接口
            bool isInterfaceOf = typeSubClass.GetInterfaces().Contains(typeIClass);//true
            bool isSubclassOf2 = typeSubClass.IsSubclassOf(typeIClass);//false,因为 IClass 是接口而不是类
            bool isAssignableFrom2 = typeIClass.IsAssignableFrom(typeSubClass);//true
        }
    }

泛型的关系判断就有所不同了：

            Type typeIStack = typeof(IStack);
            Type typeStack = typeof(Stack<>);
            Type typeDoubleStack = typeof(DoubleStack);

            //判断类型的继承关系
            bool isSubclassOf = typeDoubleStack.IsSubclassOf(typeStack);//false,泛型类似于模板，如用模具生产产品，“模具”和“产品”属于不同的东西，他们不是父子关系
            bool isAssignableFrom = typeStack.IsAssignableFrom(typeDoubleStack);//false，同上
            //判断类型是否拥有该接口
            bool isInterfaceOf = typeDoubleStack.GetInterfaces().Contains(typeIStack);//true
            bool isSubclassOf2 = typeDoubleStack.IsSubclassOf(typeIStack);//false,因为 IStack 是接口而不是类
            bool isAssignableFrom2 = typeIStack.IsAssignableFrom(typeDoubleStack);//true

可以看出，是不能用 Class 的方式判断继承关系的，因为泛型类似于模板，如用模具生产产品，“模具”和“产品”属于不同的东西，他们不是父子关系。

所以呢，要确定继承关系，最好写一个特殊的空接口只让该泛型类继承，然后根据这个接口来确定某个类是否是某个泛型派生的。

PS：
如果在代码中直接使用泛型，如：

            Stack<double> DoubleStack = new Stack<double>();
            DoubleStack.Value = 0.5;
            Console.WriteLine("Double Value:{0}", DoubleStack.Value);

那么，可以用以下方式来判断它的泛型类：

            Type typeStack = typeof(Stack<>);
            Type typeDoubleStack = typeof(Stack<double>);
            bool isGenericOf = typeDoubleStack.IsGenericType && typeDoubleStack.GetGenericTypeDefinition() == typeStack;//true

• 3、运行时创建泛型对象

主要是用 Type 的 MakeGenericType 方法，如：

            Type t = Type.GetType("System.Int32");
            Type typeStack = typeof(Stack<>);
            IStack stack = (IStack)Activator.CreateInstance(typeStack.MakeGenericType(t));

详情，请参见：Type.MakeGenericType 方法
至于动态创建泛型对象后的使用，如果是接口或者继承与某个类，那么可以强制转换过去，直接调用。其他的，只能用反射咯。

无觅猜您也喜欢：
VPN Client For M8 beta	PAC Maker,代理自动配置文件生成器[C#,Open Source]	WordPress 代码高亮
无觅

关联文章:

1. C# 中反射获取某类的子类和根据类型名动态创建对象
2. C# 获取枚举 Enum 变量值的 Description 属性
3. C# 类 XML 序列化基类

因为一些众所周知的原因, 来自中国大陆的网民想要访问非本国资源时总会那么的不方便, 这促使了海外vpn供应商在中国的繁荣. 使用海外vpn访问已经成为一些需要经常访问海外资源的中国网民的必要装备. 但通常这些vpn都是有流量限制的, 除此之外一些中国内部的资源也限制海外的ip访问. 本项目的就是提供一些启动脚本给vpn用户, 在vpn拨号之后修过路由表,让他们在使用vpn访问国外资源的同时, 能用非vpn线路高速访问本国资源.

Due to well-known reasons, it's always inconvenient for Chinese netizens and foreigners who live in China to access information physically outside of China via internet. Timeouts and connection resets are the most common results you will get when you trying to visit websites that are hosted in other countries. That leads to the growth of a new business which is called climb-the-wall or crack-the-wall. That is to use some kind of technologies such as encrypted proxy and VPN to bypass censorship. This project is created for those who uses VPN to combat censorship. It will generate some shell scripts to modify the routing table to split the chinese and non-chinese IPs. This gives VPN users the best experience by keeping domestic traffic efficient and only sending request through the VPN that need to.

上面提到的网站提供了 python 的脚本，本人运行不成功，估计是 python 的版本问题。懒得折腾，就自己写了个生成器。

使用 VS2010 .NET Framework 4.0 编写

RouteGenerator_Bin (405)
RouteGenerator_src (391)

无觅猜您也喜欢：

PAC Maker,代理自动配置文件生成器[C#,Open Source]

C# 中利用反射机制拷贝类的字段和属性

C# 通过文件头判断图像的类型

C# 类 XML 序列化基类

无觅

关联文章:

1. PAC Maker,代理自动配置文件生成器[C#,Open Source]

2011/11/01 V1.1.0
1，增加自定义运营商选项
2，增加自动伪装功能，先设置一个预设运营商，然后点击菜单键选择“启用自动伪装”，即可启用。
3，增加英语

Android Market 电子市场 会根据运营商的不同，而呈现不同的应用列表，身在天朝，有着深刻的体会：
1，搜索”Google”,谷歌地图，Gmail 并未出现在搜索结果中。
2，查看不到没有任何手收费应用。

之前在网上找到个免费的 Market Enabler ，但这个东西有个问题：
1，系统启动后，必须要在电子市场运行之前操作，不能即时切换
2，有广告

后来更具他的源码及帮助，找到了相关的原理 Android market switch简单的说，原理如下：
注：以下操作都需要 root 权限，所以执行前要运行 su
1，设置系统环境变量

 setprop gsm.sim.operator.numeric MCC_MNC
#//setprop gsm.operator.numeric MCC_MNC 不需要设置这个值，看更新

这个 MCC_MNC 可以从这里查询：Mobile Network Code
直接把把两个值拼接起来就行了，不能省略 MNC 的0，比如天朝移不动的值是：46000，天朝连不通的是：46001,貌似电不信的有错误，这个有待求证，没用过。
其他还有比较多的相关环境变量，经过测试，其他的可以不设置，就设置这两个就可以了。

2，杀掉 Android Market 电子市场的进程
杀掉进程才能重新初始化

 busybox killall com.android.vending

这里要说明下，必须要有 busybox ,否则这个命令无法执行

3，清理掉缓存文件
如果缓存没清理，会有些诡异的问题，比如推荐列表显示不出来。
原来的代码是将 电子市场 的全部缓存一起清理，这个对于使用天朝运营商的GPRS用户非常不人道的，简直是把人往破产的边缘推。
后来研究了下，只要删除其中几个文件就可以了

 busybox rm -rf /data/data/com.android.vending/cache/AVMC_UGCR_P_
 busybox rm -rf /data/data/com.android.vending/cache/AVMC_UGCIR_
 busybox rm -rf /data/data/com.android.vending/cache/AVMC_UAR{*
 busybox rm -rf /data/data/com.android.vending/cache/AVMC_PUAR{*

到这里，整个过程就结束了。

2011/04/30 更新
1，取消掉设置 setprop gsm.operator.numeric MCC_MNC 的值，设置该值后会导致 Google Maps 停止纠编，而导致显示位置偏移巨大

下载：
MarketFaker_V1.1.2_Signed.apk (1733)

无觅猜您也喜欢：
IP Client for Android 2.2	VPN Client For M8 beta	WordPress 代码高亮	Hello world！
无觅

关联文章:

1. IP Client for Android 2.2

2012/05/17 V1.2.2
增加广西师范大学版本

2012/02/02 V1.2.2
1，支持 Android 4.0
2，增加待机后退出选项，并移除自动重连选项（内部开启）
3，优化验证码识别
4， 界面支持滚动

2011/10/25 V1.1.0
重写刷新方式，待机也不掉线。

2011/09/19 V1.0.3

与网站同步更新。

2011/03/01 V1.0.2

1，增加掉线重连设置，更稳定
2，后台运行时显示状态栏图标
3，修正几个小错误
4，增加签名

注：由于添加了签名，必须卸载掉老版本才能安装这个。（原来的是测试签名，和现在的个人签名不同，无法覆盖安装）

2010/02/17 V1.0.1

第一次写 Android 的应用，估计会有些问题。

注意：单击“返回”键，程序会在后台运行，如果要退出，需要点击“菜单”键，在弹出菜单中选择“退出”，方可完全退出。

更新内容：
1，完整的功能
2，支持 简体中文/英语
3，免输验证码
下载：
桂电：IP_Client_for_Android_V1.2.2_Signed.apk (618)
师大：IP_Client_for_Android_V1.2.2_GXNU_Signed.apk (6)

无觅猜您也喜欢：
破解 Android Market 的区域限制-Market Faker v1.0.2	PAC Maker,代理自动配置文件生成器[C#,Open Source]	VPN Client For M8 beta
无觅

没有关联文章.

#region Copyright (C) 2010 Null Studio
/*
 * Author:Null hetaoos#gmail.com
 * Blog: http://blog.hetaoos.com
 * Copyright (C) 2010 Null Studio
 *
 *
 * PACMaker is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * PACMaker is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with PACMaker. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

使用 VS2010 .NET Framework 4.0 编写

PacMaker_bin.zip (319)
PacMaker_src.zip (289)

Google Code 托管地址 http://code.google.com/p/pacmaker/（包含最近的更新：自定义规则地址，使用系统代理）

无觅猜您也喜欢：

路由规则生成器[C#,Open Source]

C# 通过文件头判断图像的类型

C# / MVC 中使用 LDAP 验证

C# 中利用反射机制拷贝类的字段和属性

无觅

关联文章:

1. VPN Client For M8 beta
2. C# 中反射获取某类的子类和根据类型名动态创建对象
3. C# 中利用反射机制拷贝类的字段和属性

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;
using System.IO;
using System.Drawing;
using System.Diagnostics;
using System.Net;
using System.Threading;
using System.Net.NetworkInformation;

namespace GUET.OA.Client.ERPClient.Utils
{
    /// <summary>
    /// Http 请求
    /// </summary>
    public class HttpHelper
    {
        /// <summary>
        /// 下载一个页面
        /// </summary>
        /// <param name="uri"></param>
        /// <returns></returns>
        public static string Get(Uri uri)
        {
            return Request(uri, null, 2);
        }
        /// <summary>
        /// 下载一个页面
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static string Get(string url)
        {
            return Request(url, null, 2);
        }
        /// <summary>
        /// Post数据
        /// </summary>
        /// <param name="uri"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public static string Post(Uri uri, string msg)
        {
            return Request(uri, msg, 2);
        }
        /// <summary>
        /// Post数据
        /// </summary>
        /// <param name="url"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public static string Post(string url, string msg)
        {
            return Request(url, msg, 2);
        }

        /// <summary>
        /// 执行请求
        /// </summary>
        /// <param name="url"></param>
        /// <param name="msg"></param>
        /// <param name="tryTimes"></param>
        /// <returns></returns>
        private static string Request(string url, string msg, int tryTimes)
        {
            Uri uri = new Uri(url);
            return Request(uri, msg, tryTimes);
        }
        /// <summary>
        /// 执行请求
        /// </summary>
        /// <param name="uri"></param>
        /// <param name="msg"></param>
        /// <param name="tryTimes"></param>
        /// <returns></returns>
        private static string Request(Uri uri, string msg, int tryTimes)
        {

            if (string.IsNullOrEmpty(msg))
            {
                msg = string.Format(getHeader, uri.PathAndQuery, uri.Host);
            }
            else
            {
                msg = string.Format(postHeader, uri.PathAndQuery, uri.Host, Encoding.UTF8.GetByteCount(msg), msg);
            }
            TcpClient tcp = new TcpClient();
            NetworkStream ns = null;
            MemoryStream ms = null;
            try
            {
                tcp.Connect(uri.Host, uri.Port);
                ns = tcp.GetStream();
                var s = Encoding.UTF8.GetBytes(msg);
                ns.Write(s, 0, s.Length);
                ns.Flush();
                if (GetStateCode(ns) != 200)
                {
                    return string.Empty;
                }
                var headers = ParseHttpHeader(ns);
                ms = new MemoryStream();
                byte[] buf = new byte[20 * 1024];
                int count = 0;
                while (ns.DataAvailable && (count = ns.Read(buf, 0, buf.Length)) > 0)
                {
                    ms.Write(buf, 0, count);
                }
                ms.Position = 0;
                using (StreamReader de = new StreamReader(ms))
                {
                    return de.ReadToEnd();
                }
            }
            catch (Exception ex)
            {
                if (tryTimes <= 0)
                {
                    throw ex;
                }
                else
                {
                    Thread.Sleep(2000);
                    return Request(uri, msg, --tryTimes);
                }
            }
            finally
            {
                if (ns != null)
                {
                    ns.Dispose();
                }
                if (tcp != null)
                {
                    tcp.Close();
                }
                if (ms != null)
                {
                    ms.Dispose();
                }
            }
        }
        /// <summary>
        /// 下载图片
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static Image GetImage(string url)
        {
            Uri uri = new Uri(url);
            return GetImage(uri);
        }
        /// <summary>
        /// 下载图片
        /// </summary>
        /// <param name="uri"></param>
        /// <returns></returns>
        public static Image GetImage(Uri uri)
        {
            //WebClient client = new WebClient();
            //client.Proxy = null;

            //var d = client.DownloadData(url);
            //MemoryStream ms = new MemoryStream(d);
            //return Image.FromStream(ms);

            string msg = string.Format(getHeader, uri.AbsolutePath, uri.Host);

            TcpClient tcp = new TcpClient();
            NetworkStream ns = null;
            MemoryStream ms = null;
            try
            {
                tcp.Connect(uri.Host, uri.Port);
                ns = tcp.GetStream();
                var s = Encoding.UTF8.GetBytes(msg);
                ns.Write(s, 0, s.Length);
                ns.Flush();
                if (GetStateCode(ns) != 200)
                {
                    return null;
                }
                var headers = ParseHttpHeader(ns);

                ms = new MemoryStream();

                var buf = new byte[4096];
                int readCount;
                while ((readCount = ns.Read(buf, 0, buf.Length)) > 0)
                {
                    ms.Write(buf, 0, readCount);
                    if (readCount < buf.Length || ns.DataAvailable == false)
                    {
                        break;
                    }
                }
                ms.Position = 0;
                return Image.FromStream(ms);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (ns != null)
                {
                    ns.Dispose();
                }
                if (tcp != null)
                {
                    tcp.Close();
                }
                if (ms != null)
                {
                    ms.Dispose();
                }
            }
        }
        /// <summary>
        /// 获取状态码
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static int GetStateCode(NetworkStream stream)
        {
            string headerLine = GetNextHeaderLine(stream);
            if (string.IsNullOrEmpty(headerLine))
            {
                return 0;
            }
            var i = headerLine.Split(' ');
            if (i.Length != 3)
            {
                return 0;
            }

            int code = 0;
            if (int.TryParse(i[1], out code))
            {
                return code;
            }
            return 0;
            //HTTP/1.1 302 Found
            //return 1;
        }
        /// <summary>
        /// 获取回应头
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static WebHeaderCollection ParseHttpHeader(NetworkStream stream)
        {
            //string firstLine = GetNextHeaderLine(stream);
            WebHeaderCollection headers = new WebHeaderCollection();
            string headerLine;
            while ((headerLine = GetNextHeaderLine(stream)).Length != 0)
            {
                try
                {
                    headers.Add(headerLine);
                }
                catch { }
            }
            return headers;
        }

        private static byte[] pingData = Encoding.ASCII.GetBytes("012345678901234567890123456789");
        public static bool CanPing(string host)
        {
            try
            {
                using (Ping ping = new Ping())
                {
                    PingReply reply = ping.Send(host, 120, pingData);
                    return reply.Status == IPStatus.Success;
                }
            }
            catch
            {
                return false;
            }
        }

        public static bool CanConnect(string host)
        {
            return CanConnect(host, 80);
        }
        public static bool CanConnect(string host, int port)
        {
            bool connected = false;
            try
            {
                using (TcpClient tc = new TcpClient())
                {
                    tc.SendTimeout = tc.ReceiveTimeout = 2000;
                    tc.Connect(host, port);
                    connected = tc.Connected;
                    tc.Close();
                }
            }
            catch
            {
            }

            return connected;
        }

        /// <summary>
        /// 获取头的下一行
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        private static string GetNextHeaderLine(NetworkStream stream)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                int readByte;
                while ((readByte = stream.ReadByte()) != '\n' && readByte != -1)
                {
                    if (readByte != '\r')
                        ms.WriteByte((byte)readByte);
                }
                if (ms.Length == 0)
                {
                    return string.Empty;
                }
                return Encoding.UTF8.GetString(ms.ToArray());
            }
        }
        //Nokia5700AP23.01/SymbianOS/9.1 Series60/3.0
        private const string postHeader = @"POST {0} HTTP/1.1
Host: {1}
User-Agent: Nokia5700AP23.01/SymbianOS/9.1 Series60/3.0
Accept: */*
Cache-Control: no-cache
Content-Length: {2}
Content-Type: application/x-www-form-urlencoded

{3}";

        private const string getHeader = @"GET {0} HTTP/1.1
Host: {1}
User-Agent: NNokia5700AP23.01/SymbianOS/9.1 Series60/3.0
Accept: */*
Accept-Encoding: gzip,deflate
Cache-Control: no-cache

";
    }
}

1，以上代码的请求头我已经写死了，可以用 WebHeaderCollection 搞成自定义的，或者根据实际情况修改
2，下载文件，就是把其中的 MemoryStream 换成文件流即可
3，Http 请求时，服务器传输数据完毕，并不一定会断开连接，所以获取网页内容时，将 NetworkStream 转换为 StreamReader 再 ReadToEnd 并不保险，正确的做法是，先读到内存流中，读的过程中要判断 NetworkStream.DataAvailable 是否有数据，当为 false 是，就表示读完了。当然，可以考虑用 Content-Length 来判断。
4，Content-Type 头比较麻烦，一般的网页提交，其值为 application/x-www-form-urlencoded，如果与WebService 交互，值要改为 application/soap+xml; charset=utf-8
5，初次请求或者长时间未请求，可以使用 CanConnect 来测试网站是否可用，以减少正式请求过程中长时间的阻塞。
6，至于 Cookies，可以自己解析 Set-Cookies 回复头的解析和发送时添加 Cookies
7，某些 WAP 的数据输出，NetworkStream.DataAvailable 为 False 时也还能读数据。

无觅猜您也喜欢：

C# 中反射获取某类的子类和根据类型名动态创建对象

C# 中利用反射机制拷贝类的字段和属性

C# / MVC 中使用 LDAP 验证

C# 通过文件头判断图像的类型

无觅

关联文章:

1. C# 通过文件头判断图像的类型
2. C# 中利用反射机制拷贝类的字段和属性
3. C# 类 XML 序列化基类

使用说明：
直接填写 服务器地址、用户名、密码，再点“拨号”按钮即可。
拨号后就可以关闭本程序了，需要断开是，再运行本程序，点“断开”按钮即可。

注：
1，创建拨号连接时，内置了大部分选项。可能这些选项并不适合你的网络环境。
2，拨号连接后将影响待机，不用时请断开连接。（系统问题，不关我事）
3，本程序创建的拨号连接名称为“VPN_C2AC6A3C”，可在控制面板中删除。
4，这是个测试版本，如有疑问、问题，请给我发邮件。

附件
VPN Client.zip (315)
VPN Client_0.9.0_20101120.cab (352)

无觅猜您也喜欢：
IP Client for Android 2.2	破解 Android Market 的区域限制-Market Faker v1.0.2	C# 中反射获取某类的子类和根据类型名动态创建对象	路由规则生成器[C#,Open Source]
无觅

没有关联文章.

    public enum LoginResult
    {
        Success,
        WrongPassword,
        UserNotExist,
        Forbidden,
        Unknown
    }

当前段UI获取到登陆方法的返回结果时，就需要告诉用户登录是否成功、什么原因失败的。如果直接使用 ToString() 方式直接返回枚举变量的名称，显然不合适。通常的做法是使用各 switch 来转换，弊端是要写过多的代码；或者构造一个 string[] msg ，再根据 LoginResult 的 int 值来相应的取，弊端是类型的int值必须是连续的或者 string[] msg 的个数大于或等于 枚举类型的最大 int 值 ，一一对应起来也比较麻烦 。

在 枚举类型 Enum 中，不支持 DisplayNameAttribute，但支持 DescriptionAttribute ，所以要从 DescriptionAttribute 入手。写一个通用方法，取出 DescriptionAttribute 即可。当然，为了使用方便，我们使用 .NET 3.5+ 支持的 扩展方法来实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Reflection;

namespace com.hetaoos.Utils.Extensions
{
    public static class Extensions
    {
        /// <summary>
        /// 获取枚举变量值的 Description 属性
        /// </summary>
        /// <param name="obj">枚举变量</param>
        /// <returns>如果包含 Description 属性，则返回 Description 属性的值，否则返回枚举变量值的名称</returns>
        public static string GetDescription(this object obj)
        {
            return GetDescription(obj, false);
        }

        /// <summary>
        /// 获取枚举变量值的 Description 属性
        /// </summary>
        /// <param name="obj">枚举变量</param>
        /// <param name="isTop">是否改变为返回该类、枚举类型的头 Description 属性，而不是当前的属性或枚举变量值的 Description 属性</param>
        /// <returns>如果包含 Description 属性，则返回 Description 属性的值，否则返回枚举变量值的名称</returns>
        public static string GetDescription(this object obj, bool isTop)
        {
            if (obj == null)
            {
                return string.Empty;
            }
            try
            {
                Type _enumType = obj.GetType();
                DescriptionAttribute dna = null;
                if (isTop)
                {
                    dna = (DescriptionAttribute)Attribute.GetCustomAttribute(_enumType, typeof(DescriptionAttribute));
                }
                else
                {
                    FieldInfo fi = _enumType.GetField(Enum.GetName(_enumType, obj));
                    dna = (DescriptionAttribute)Attribute.GetCustomAttribute(
                       fi, typeof(DescriptionAttribute));
                }
                if (dna != null && string.IsNullOrEmpty(dna.Description) == false)
                    return dna.Description;
            }
            catch
            {
            }
            return obj.ToString();
        }
    }
}

使用方法很简单：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.ComponentModel;
using com.hetaoos.Utils.Extensions;//这一句是必须的，否则无法使用扩展方法
using System.Diagnostics;

namespace com.hetaoos
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {
            ProcessedDataResultType resultType = ProcessedDataResultType.BkgrdMap;
            ProcessedDataWaringResult ret = new ProcessedDataWaringResult() { ResultType = ProcessedDataResultType.WaringResult };
            Debug.Print("枚举类型的描述属性：{0}", resultType.GetDescription(true));
            Debug.Print("单个枚举变量的描述属性：{0} --> {1}", resultType, resultType.GetDescription());
            Debug.Print("类类型的描述属性：{0}", ret.GetDescription(true));
            Debug.Print("类类型的属性的描述属性：{0} --> {1}  --> {2}", ret.ResultType, ret.ResultType.GetDescription(), ret.ResultType.GetDescription(true));
        }

        /// <summary>
        /// 处理结果类型
        /// </summary>
        //[TypeConverter(typeof(EnumDescConverter))]
        [Description("处理后的数据类型")]
        public enum ProcessedDataResultType : byte
        {
            [Description("背景地图")]
            BkgrdMap,
            [Description("检测结果")]
            WaringResult
        }

        [Description("报警结果")]
        public class ProcessedDataWaringResult
        {
            [Description("结果类型")]
            public ProcessedDataResultType ResultType { get; set; }
        }
    }
}

输出结果如下：

枚举类型的描述属性：处理后的数据类型
单个枚举变量的描述属性：BkgrdMap --> 背景地图
类类型的描述属性：报警结果
类类型的属性的描述属性：WaringResult --> 检测结果  --> 处理后的数据类型

无觅猜您也喜欢：

C# 中反射获取某类的子类和根据类型名动态创建对象

C# 中利用反射机制拷贝类的字段和属性

C# 通过文件头判断图像的类型

动态填充/修改类属性的 DisplayNameAttribute 属性

无觅

关联文章:

1. C# 通过文件头判断图像的类型
2. C# 中利用反射机制拷贝类的字段和属性
3. C# 中反射获取某类的子类和根据类型名动态创建对象

Activator.CreateInstance(objType);

或者

Assembly.Load(path).CreateInstance(typeName);

或者

Assembly.LoadFile(filePath).CreateInstance(typeName);

创建对象实例。

以下通过一个简单的示例来展示：
1，获取当前程序集中的全部类型；
2，判断某一类型是否是继承与另一类型；
3，根据类型名动态创建对象。

目前还有个疑问，不知道谁能解答：
1，如何判断某个类是否实现了某个接口，目前只能先 new 一个对象，然后再 用 is 判断。

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Diagnostics;

namespace com.hetaoos
{

    class Test
    {
        public Test()
        {
            var types = Assembly.GetExecutingAssembly().GetTypes();
            var baseType = typeof(BaseProcessor);
            List<BaseProcessor> processors = new List<BaseProcessor>();
            foreach (var t in types)
            {
                var tmp = t.BaseType;
                while (tmp != null)
                {
                    if (tmp == baseType)
                    {
                        BaseProcessor obj = MethodMaker.CreateObject(t.FullName) as BaseProcessor;
                        if (obj != null)
                        {
                            processors.Add(obj);
                        }
                        break;
                    }
                    else
                    {
                        tmp = tmp.BaseType;
                    }
                }
            }

            Debug.Print("Processor Count:{0}", processors.Count);
            foreach (var p in processors)
            {
                Debug.Print("{0}\t:{1}", p, p.Calc(2, 5));
            }
        }
    }

    public class MethodMaker
    {

        /// <summary>
        /// 创建对象（当前程序集）
        /// </summary>
        /// <param name="typeName">类型名</param>
        /// <returns>创建的对象，失败返回 null</returns>
        public static object CreateObject(string typeName)
        {
            object obj = null;
            try
            {
                Type objType = Type.GetType(typeName, true);
                obj = Activator.CreateInstance(objType);
            }
            catch (Exception ex)
            {
                Debug.Write(ex);
            }
            return obj;
        }

        /// <summary>
        /// 创建对象(外部程序集)
        /// </summary>
        /// <param name="path"></param>
        /// <param name="typeName">类型名</param>
        /// <returns>创建的对象，失败返回 null</returns>
        public static object CreateObject(string path, string typeName)
        {
            object obj = null;
            try
            {

                obj = Assembly.Load(path).CreateInstance(typeName);
            }
            catch (Exception ex)
            {
                Debug.Write(ex);
            }

            return obj;
        }
    }

    public abstract class BaseProcessor
    {
        public abstract int Calc(int a, int b);
    }

    public class Adder : BaseProcessor
    {
        public override int Calc(int a, int b)
        {
            return a + b;
        }
    }

    public class Multiplier : BaseProcessor
    {
        public override int Calc(int a, int b)
        {
            return a * b;
        }
    }
}

输出结果为：

Processor Count:2
com.hetaoos.Adder	:7
com.hetaoos.Multiplier	:10

PS:
判断某个类是否继承自某个接口、类的方法：

        public static bool IsParent(Type test, Type parent)
        {
            if (test == null || parent == null || test == parent || test.BaseType == null)
            {
                return false;
            }
            if (parent.IsInterface)
            {
                foreach (var t in test.GetInterfaces())
                {
                    if (t == parent)
                    {
                        return true;
                    }
                }
            }
            else
            {
                do
                {
                    if (test.BaseType == parent)
                    {
                        return true;
                    }
                    test = test.BaseType;
                } while (test != null);

            }
            return false;
        }

无觅猜您也喜欢：

C# 获取枚举 Enum 变量值的 Description 属性

C# 中利用反射机制拷贝类的字段和属性

动态填充/修改类属性的 DisplayNameAttribute 属性

PAC Maker,代理自动配置文件生成器[C#,Open Source]

无觅

关联文章:

1. C# 中利用反射机制拷贝类的字段和属性
2. C# 类 XML 序列化基类
3. C# 通过文件头判断图像的类型