2019年4月24日 By mikel 分类: C#
http://baa.im/847971

来源: C#使用log4net记录日志 – 水墨晨诗 – 博客园

一、下载log4net.dll(百度云里面有)文件,然后再在项目中添加引用。

二、在AssemblyInfo.cs文件中添加log4net.dll的参数。

[assembly: log4net.Config.XmlConfigurator(ConfigFile = "log4net.config", ConfigFileExtension = "config", Watch = true)]

 

三、右击项目→添加→新建项→xxx配置文件(web或者winform……)并修改名字叫:log4net.config→右击生成出来的log4net.config→属性→将 “复制到输出目录” 的值改为 如果较新则复制。

在configuration节点下添加下面这段

 

复制代码
<log4net>
  <!--错误日志类-->
  <logger name="logerror"><!--日志类的名字-->
    <level value="ALL" /><!--定义记录的日志级别-->
    <appender-ref ref="ErrorAppender" /><!--记录到哪个介质中去-->
  </logger>
  <!--信息日志类-->
  <logger name="loginfo">
    <level value="ALL" />
    <appender-ref ref="InfoAppender" />
  </logger>
  <!--错误日志附加介质-->
  <appender name="ErrorAppender" type="log4net.Appender.RollingFileAppender"><!-- name属性指定其名称,type则是log4net.Appender命名空间的一个类的名称,意思是,指定使用哪种介质-->
    <param name="File" value="Log\\LogError\\" /><!--日志输出到exe程序这个相对目录下-->
    <param name="AppendToFile" value="true" /><!--输出的日志不会覆盖以前的信息-->
    <param name="MaxSizeRollBackups" value="100" /><!--备份文件的个数-->
    <param name="MaxFileSize" value="10240" /><!--当个日志文件的最大大小-->
    <param name="StaticLogFileName" value="false" /><!--是否使用静态文件名-->
    <param name="DatePattern" value="yyyyMMdd&quot;.htm&quot;" /><!--日志文件名-->
    <param name="RollingStyle" value="Date" /><!--文件创建的方式,这里是以Date方式创建-->
    <!--错误日志布局-->
    <layout type="log4net.Layout.PatternLayout">
      <param name="ConversionPattern" value="&lt;HR COLOR=red&gt;%n异常时间:%d [%t] &lt;BR&gt;%n异常级别:%-5p &lt;BR&gt;%n异 常 类:%c [%x] &lt;BR&gt;%n%m &lt;BR&gt;%n &lt;HR Size=1&gt;"  />
    </layout>
  </appender>
  <!--信息日志附加介质-->
  <appender name="InfoAppender" type="log4net.Appender.RollingFileAppender">
    <param name="File" value="Log\\LogInfo\\" />
    <param name="AppendToFile" value="true" />
    <param name="MaxFileSize" value="10240" />
    <param name="MaxSizeRollBackups" value="100" />
    <param name="StaticLogFileName" value="false" />
    <param name="DatePattern" value="yyyyMMdd&quot;.htm&quot;" />
    <param name="RollingStyle" value="Date" />
    <!--信息日志布局-->
    <layout type="log4net.Layout.PatternLayout">
      <param name="ConversionPattern" value="&lt;HR COLOR=blue&gt;%n日志时间:%d [%t] &lt;BR&gt;%n日志级别:%-5p &lt;BR&gt;%n日 志 类:%c [%x] &lt;BR&gt;%n%m &lt;BR&gt;%n &lt;HR Size=1&gt;"  />
    </layout>
  </appender>
</log4net>
复制代码

 

下面是其他的一些配置

 

复制代码
//这种配置,是将日志写入到文本文件当中,若是需要将日志已其他形式保存,可以看 http://www.cnblogs.com/qianlifeng/archive/2011/04/22/2024856.html
        
<param name="File" value="Logger/"/>//日志存放位置(这里的value值是一个Logger,表示在项目文件夹中创建一个名叫Logger的文件。也可以是value="c:\log.txt")
<param name="AppendToFile" value="true"/>//是否追加到文件
<param name="RollingStyle" value="Date"/>//变换的形式为日期
<param name="DatePattern" value="&quot;Logs_&quot;yyyyMMdd&quot;.txt&quot;"/>//生成格式;每天生成一个日志
<param name="StaticLogFileName" value="false"/>//日志文件名,是否固定不变
<layout type="log4net.Layout.PatternLayout,log4net">
<param name="ConversionPattern" value="%d [%t] %-5p %c - %m%n"/>//这3行表示日志输出的格式,若不喜欢这样的样式,可以查看下面的输出样式,自行修改
<param name="Header" value="&#xA;----------------------header--------------------------&#xA;"/>
<param name="Footer" value="&#xA;----------------------footer--------------------------&#xA;"/>
复制代码

输出样式:

%m(message):输出的日志消息,如ILog.Debug(…)输出的一条消息
%n(new line):换行
%d(datetime):输出当前语句运行的时刻
%r(run time):输出程序从运行到执行到当前语句时消耗的毫秒数
%t(thread id):当前语句所在的线程ID
%p(priority): 日志的当前优先级别,即Debug、INFO、WARN…等
%c(class):当前日志对象的名称,例如:
%f(file):输出语句所在的文件名。
%l(line):输出语句所在的行号。
%数字:表示该项的最小长度,如果不够,则用空格填充,如“%-5level”表示level的最小宽度是5个字符,如果实际长度不够5个字符则以空格填充。

通过这些东西,你可以任意组合你喜欢的输出格式内容。

四、使用log4net记录日志

1添加一个帮助类LogHelper

复制代码
    public class LogHelper
    {
        public static readonly log4net.ILog loginfo = log4net.LogManager.GetLogger("loginfo");
        public static readonly log4net.ILog logerror = log4net.LogManager.GetLogger("logerror");
        public static void WriteLog(string info)
        {
            if (loginfo.IsInfoEnabled)
            {
                loginfo.Info(info);
            }
        }

        public static void WriteLog(string info, Exception ex)
        {
            if (logerror.IsErrorEnabled)
            {
                logerror.Error(info, ex);
            }
        }
    }
复制代码

2、在代码中记录错误

复制代码
        protected void Page_Load(object sender, EventArgs e)
        {
            try
            {
                string a = "FF";
                int b = Convert.ToInt32(a);
            }
            catch (Exception ex){
                LogHelper.WriteLog(ex.Message.ToString(), ex);
            }
        }
复制代码

 

如何是在web中,可以创建global.asax页面,

右击项目→添加→新建项目→选择web中的全局应用程序类。

在global.asax.cs文件中,找到application_error方法中,增加写入错误日志的代码。

Exception ex = Server.GetLastError().GetBaseException(); //获取异常源 
然后使用上面的方法记录就可以了

如果项目使用的框架是 client profile版本的是不能使用log4net的,请将框架修改相对应的完整版的  项目→XXX属性→修改目标框架。

参考:https://www.cnblogs.com/xuxuzhaozhao/p/6640623.html

C#使用log4net记录日志 – 水墨晨诗 – 博客园已关闭评论
2019年4月21日 By mikel 分类: C#
http://baa.im/847971

来源: 一个项目引用不同版本dll – 养家心法 – CSDN博客

问题描述

一个项目引用不同版本的同一dll,会引发以下报错:

未能加载文件或程序集“xxx, Version=x.x.x.x, Culture=neutral, PublicKeyToken=xxxxxxxxxxxx”或它的某一个依赖项。系统找不到指定的文件

这里来解决项目中同一dll的多版本问题。

解决方式

通过配置web.config配置文件(app.config或web.config)增加配置节点

不同场景有不同的解决方式,下面说明

1. 场景一   以高版本兼容

例如:新旧项目都引用Newtonsoft.Json,但是不同版本。需要以最高版本兼容。

  1. <runtime>
  2.   <assemblyBinding xmlns=“urn:schemas-microsoft-com:asm.v1”>
  3.     <dependentAssembly>
  4.       <assemblyIdentity name=“Newtonsoft.Json” publicKeyToken=“30AD4FE6B2A6AEED” culture=“neutral”/>
  5.       <bindingRedirect oldVersion=“0.0.0.0-6.0.0.0” newVersion=“6.0.0.0”/>
  6.     </dependentAssembly>
  7.   </assemblyBinding>
  8. </runtime>

 

2. 场景二   同一dll两种版本共存

例如:项目自己引用log4net.dll 版本1.2.13.0 。添加第三方某个dll,第三方依赖log4net.dll版本1.2.9.0,项目中需要两种版本共存。
这里还分两种情况,dll的publicKeyToken相同还是不同 (publicKeyToken查询见说明1)
publicKeyToken相同,配置方法:
  1. <runtime>
  2.   <assemblyBinding xmlns=“urn:schemas-microsoft-com:asm.v1”>
  3.     <dependentAssembly>
  4.       <assemblyIdentity name=“log4net” publicKeyToken=“669e0ddf0bb1aa2a” />
  5.       <codeBase version=“1.2.13.0” href=“bin\log4netdll\1_2_13\log4net.dll” />
  6.       <codeBase version=“1.2.9.0” href=“bin\log4netdll\1_2_9\log4net.dll” />
  7.     </dependentAssembly>
  8.   </assemblyBinding>
  9. </runtime>

publicKeyToken不同,配置方法:

  1. <runtime>
  2.   <assemblyBinding xmlns=“urn:schemas-microsoft-com:asm.v1”>
  3.     <dependentAssembly>
  4.       <assemblyIdentity name=“log4net” publicKeyToken=“669e0ddf0bb1aa2a” />
  5.       <codeBase version=“1.2.13.0” href=“bin\log4netdll\1_2_13\log4net.dll” />
  6.     </dependentAssembly>
  7.     <dependentAssembly>
  8.       <assemblyIdentity name=“log4net” publicKeyToken=“b32731d11ce58905” />
  9.       <codeBase version=“1.2.9.0” href=“bin\log4netdll\1_2_9\log4net.dll” />
  10.     </dependentAssembly>
  11.   </assemblyBinding>
  12. </runtime>

说明

1.publicKeyToken获取方式:使用vs的Tools Command Prompt命令行工具,输入:SN -T “path”,例如:

  1. C:\Program Files (x86)\Microsoft Visual Studio 11.0>SN -T “D:\project\liberary\External\log4net.dll”
  2. Microsoft(R) .NET Framework 强名称实用工具 版本 4.0.30319.17929
  3. 版权所有(C) Microsoft Corporation。保留所有权利。
  4. 公钥标记为 b32731d11ce58905

注意:href的路径要保证正确。

参考文献

msdn对配置详解:  点击打开链接

参考文章

http://blog.csdn.net/dang13579/article/details/72956684

一个项目引用不同版本dll – 养家心法 – CSDN博客已关闭评论
2019年4月18日 By mikel 分类: C#
http://baa.im/847971

来源: Asp.Net MVC 中的 Cookie(译) – JoeSnail – 博客园

  • Cookie是请求服务器或访问Web页面时携带的一个小的文本信息。

Cookie为Web应用程序中提供了一种存储特定用户信息的方法。Cookie的值是字符串类型,且对用户是可见的。

  • Cookie随着每次RequestResponse在浏览器和服务器之间交换数据。

如果一个用户请求服务器上的一个页面,服务器除了返回请求的页面,也返回了一个包含日期和时间的Cookie。这个Cookie存储在用户硬盘上的一个文件夹上。稍后,如果用户再次访问服务器,当用户输入URL时,浏览器会在本地硬盘上查看与该URL相关联的Cookie。如果Cookie存在,浏览器会将Cookie随着请求一起发送。然后,服务器可以读取发送过来的Cookie信息,用户上次访问该站点的日期和时间。您可以使用这些信息向用户显示一条消息,或者检查一个过期日期。

  • Cookie与特定的站点关联

Cookie与一个Web站点相关联,而不是特定的页面,因此不管用户请求你服务器的什么页面,浏览器和服务器都会交换cookie信息。 浏览器会为每个不同的Web站点分别存储Cookie,保证每个Cookie对应特定的Web站点。

  • Cookie保持会话状态

Cookie可以帮助服务器存储访问者的信息。通俗的说,Cookie是保持Web应用程序连续性的一种方式,即会话状态管理。因为Http请求是无状态的,一些列请求中服务器并不知道请求来自哪些用户,所以可以使用Cookie来唯一标识用户,维护会话状态。

Cookie用于许多目的,所有这些都与帮助网站记住用户有关。例如,一个进行投票的站点可能会使用Cookie作为布尔值来指示用户的浏览器是否已经参与投票,这样用户就不能进行两次投票。一个要求用户登录的网站可能会使用Cookie来记录用户已经登录的情况,这样用户就不必继续输入凭证了。


Cookie限制

大多数浏览器支持最多4096字节的Cookie。由于这个限制,cookie最好用于存储少量数据,或者更好的是,像用户ID这样的标识符。

浏览器也会限制Web网站在用户的电脑上可以存储多少Cookie。大多数浏览器只允许每个站点提供20个Cookie。如果你想储存更多,那么之前老的Cookie就会被丢弃。一些浏览器还会限制Cookie的总数量(不区分站点)。

尽管Cookie对Web应用程序非常有用,但是应用程序不应该依赖于Cookie。不要使用Cookie来支持关键敏感数据。


写Cookie

浏览器负责管理用户电脑上的Cookie。Cookie通过HttpResonse对象被发送到浏览器,该对象公开了一个名为Cookies的集合。想要发送到浏览器的任何Cookie都必须添加到这个集合中。在创建Cookie时,指定一个名称和值。每个Cookie都必须有一个惟一的名称,以便浏览器读取时可以识别它。因为Cookie是按名称存储的,因此多个Cookie名称相同时,新的Cookie值会覆盖掉之前的。

可以设置Cookie的日期和过期时间。当用户访问写Cookie的站点时,浏览器会删除过期的Cookie。Cookie的有效期可以是50年。

如果没有设置Cookie的过期时间,就创建了Cookie,那么它并不会存储在用户的硬盘上。这种Cookie是作为用户会话信息的一部分来维护的。当用户关闭浏览器时,cookie就会被丢弃。像这样的非持久cookie对于需要在短时间内存储的信息非常有用,或者出于安全原因,不应该将其写入到客户机计算机上的磁盘上。例如,如果用户正在使用公共计算机,而不希望将cookie写入磁盘,则非持久性cookie非常有用。

您可以通过多种方式将Cookie添加到Cookie集合中。下面的例子展示了两个编写Cookie的方法:

//第一种
Response.Cookies["userName"].Value = "patrick";
Response.Cookies["userName"].Expires = DateTime.Now.AddDays(1);
//第二种
HttpCookie aCookie = new HttpCookie("lastVisit");
aCookie.Value = DateTime.Now.ToString();
aCookie.Expires = DateTime.Now.AddDays(1);
Response.Cookies.Add(aCookie);

该示例将两个Cookie添加到Cookie集合中,其中一个名为用户名,另一个为上次访问时间。对于第一种方法,Cookie集合的值可以直接读写。因为Cookie继承自NameObjectCollectionBase集合类型,所以可以直接获取Cookie。

对于第二种方法,创建一个HttpCookie对象的实例,设置它的属性,然后通过Add方法将其添加到cookie集合中。Cookie的名称通过构造函数添加。

这两个示例都完成了相同的任务,将Cookie写入浏览器。在这两种方法中,过期值必须为DateTime类型。因为所有的Cookie值都以字符串形式存储,所以日期时间值会转换为字符串。

多个值的Cookie

Cookie可以存储一个值,比如用户名或最后一次访问。也可以在一个Cookie中存储多个键值对。键值对被称为子键。(子键的布局非常类似于URL中的查询字符串。)例如,您可以创建一个名为userInfo的cookie,它具有子健userName和lastVisit,而不是创建两个单独的Cookie。

子健可以将相关的或类似的信息放入一个Cookie中。如果所有信息都在一个Cookie中,Cookie属性如过期将应用于所有信息。(相反,如果您想为不同类型的信息分配不同的过期日期,则应该将信息存储在单独的cookie中。)

带有子键的Cookie也可以帮助限制Cookie文件的大小。之前提到,Cookie通常被限制为4096字节,并且每个站点能存储20多个Cookie。通过使用一个带有子键的Cookie,可以降低站点Cookie数量的限制。此外,一个Cookie自身就占用了大约50个字符(过期信息,等等),加上您存储在其中的值的长度,所有这些值都指向4096字节的限制。如果您存储5个子键而不是5个单独的cookie,您可以节省单个Cookie的开销,并且还可以节省大约200个字节。

创建有子键的Cookie:

//第一种
Response.Cookies["userInfo"]["userName"] = "patrick";
Response.Cookies["userInfo"]["lastVisit"] = DateTime.Now.ToString();
Response.Cookies["userInfo"].Expires = DateTime.Now.AddDays(1);
//第二种
HttpCookie aCookie = new HttpCookie("userInfo");
aCookie.Values["userName"] = "patrick";
aCookie.Values["lastVisit"] = DateTime.Now.ToString();
aCookie.Expires = DateTime.Now.AddDays(1);
Response.Cookies.Add(aCookie);

Cookie作用域

默认情况下,一个站点的有过期时间的所有Cookie都存储在客户硬盘上,请求该网站时所有的Cookie都被发送到服务器。换句话说,网站上的每一个页面都能获得该站点的所有Cookie。但是,您可以通过两种方式来限制Cookie的范围:

  • 将Cookie的范围限制在服务器上的一个文件夹中,这允许您将Cookie限制在站点上的一个应用程序中。
  • 将范围设置为域,允许您指定域中的哪些子域可以访问cookie。

要将cookie限制在服务器上的一个文件夹中,可以设置cookie的路径属性,如下面的例子:

HttpCookie appCookie = new HttpCookie("AppCookie");
appCookie.Value = "written " + DateTime.Now.ToString();
appCookie.Expires = DateTime.Now.AddDays(1);
appCookie.Path = "/Application1";
Response.Cookies.Add(appCookie);

路径既可以是站点根下的物理路径,也可以是虚拟路径。这样做的效果是,Cookie只可用于Application1文件夹或虚拟根目录中的页面。例如,如果你的网站是www.contoso.com,在前面的示例中创建的Cookie可以与路径http://www.contoso.com/Application1/页面,该文件夹下任何页面。然而,Cookie不会在其他应用程序中可用的页面,比如http://www.contoso.com/Application2/或者http://www.contoso.com/

Cookie的限制和作用域

默认情况下,Cookie与特定的域相关联。
例如,如果您的站点是www.contoso.com,那么当用户请求该站点的任何页面时,您所写的Cookie将被发送到服务器。
(这可能不包括带有特定路径值的cookie。)
如果你的站点有子域名,例如,contoso.com,sales.contoso.com,以及support.contoso.com,那么你就可以把Cookies与特定的子域名联系起来。

代码示例:

Response.Cookies["domain"].Value = DateTime.Now.ToString();
Response.Cookies["domain"].Expires = DateTime.Now.AddDays(1);
Response.Cookies["domain"].Domain = "support.contoso.com";

当域以这种方式设置时,Cookie将只在指定子域中的页面可用。您还可以使用域属性来创建一个可以在多个子域中共享的Cookie,如下面的示例所示:

Response.Cookies["domain"].Value = DateTime.Now.ToString();
Response.Cookies["domain"].Expires = DateTime.Now.AddDays(1);
Response.Cookies["domain"].Domain = "contoso.com";

此时Cookie既可以主域,也可以用于sales.contoso.com和support.contoso.com等子域。


读取Cookie

当浏览器向服务器发出请求时,Cookie会随着请求一起发送到服务器上。在你的应用程序,您可以使用HttpRequest来读取cookie。

代码示例:

if(Request.Cookies["userName"] != null)
{
    HttpCookie aCookie = Request.Cookies["userName"];
    var cookiText = Server.HtmlEncode(aCookie.Value);
}

在尝试获取Cookie的值之前,应该确保Cookie存在;如果Cookie不存在,将得到NullReferenceException异常。还要注意,HtmlEncode方法被调用来对Cookie的内容进行编码。这确保了恶意用户没有将可执行脚本添加到Cookie中。

在Cookie中读取子键的值也类似于设置它。下面的代码示例展示了获取子键值的一种方法

if(Request.Cookies["userInfo"] != null)
{
    var name = 
        Server.HtmlEncode(Request.Cookies["userInfo"]["userName"]);

    var visit =
        Server.HtmlEncode(Request.Cookies["userInfo"]["lastVisit"]);
}

读取键值对lastVisit的值,该值之前被设置为DateTime类型。但是Cookie将值存储为字符串,因此如果您想使用lastVisit的值作为日期,则必须将其转换为适当的类型。

DateTime dt= DateTime.Parse(Request.Cookies["userInfo"]["lastVisit"]);

Cookie中的子键是NameValueCollection类型。因此,获取子键的另一种方法是获取子键集合,然后按名称提取子键值,如下面的示例所示:

if(Request.Cookies["userInfo"] != null)
{
    System.Collections.Specialized.NameValueCollection  UserInfoCookieCollection;
    UserInfoCookieCollection = Request.Cookies["userInfo"].Values;
   var name = 
        Server.HtmlEncode(UserInfoCookieCollection["userName"]);
    var visit =
        Server.HtmlEncode(UserInfoCookieCollection["lastVisit"]);
}

Cookie的过期时间

浏览器负责管理Cookie,Cookie的过期时间和日期帮助浏览器管理其存储的Cookie。因此,虽然您可以读取Cookie的名称和值,但是您不能读取cookie的过期日期和时间。当浏览器向服务器发送Cookie信息时,浏览器不包含过期信息。(Cookie的过期属性总是返回一个日期时间值为0。)如果您担心cookie的过期日期,您必须重新设置它。

读取Cookie集合

获取所有的Cookie

代码示例;

System.Text.StringBuilder output = new System.Text.StringBuilder();
HttpCookie aCookie;
for(int i=0; i<Request.Cookies.Count; i++)
{
    aCookie = Request.Cookies[i];
    output.Append("Cookie name = " + Server.HtmlEncode(aCookie.Name) 
        + "<br />");
    output.Append("Cookie value = " + Server.HtmlEncode(aCookie.Value)
        + "<br /><br />");
}

上一个示例的有一个不足的地方,如果cookie有子键,会将子键作为单个name/value字符串显示。您可以读取cookie的haskey属性,以确定cookie是否有子键。如果有,您可以读取子键集合以获得单独的子键名和值。
您也可以通过索引值直接从值集合中读取子键值。相应的子键名可以在值集合的AllKeys成员中找到,它返回一个字符串数组。您还可以使用值集合的键值。但是,AllKeys属性在第一次被访问时被缓存。相反,键属性在每次访问时都构建一个数组。由于这个原因,在相同页面请求的上下文中,AllKeys属性要快得多。

下面的例子显示了前面的示例的修改。它使用HasKeys属性来测试子键,如果检测到子键,那么这个示例将从值集合中获得子键:

for(int i=0; i<Request.Cookies.Count; i++)
{
    aCookie = Request.Cookies[i];
    output.Append("Name = " + aCookie.Name + "<br />");
    if(aCookie.HasKeys)
    {
        for(int j=0; j<aCookie.Values.Count; j++)
        {
            subkeyName = Server.HtmlEncode(aCookie.Values.AllKeys[j]);
            subkeyValue = Server.HtmlEncode(aCookie.Values[j]);
            output.Append("Subkey name = " + subkeyName + "<br />");
            output.Append("Subkey value = " + subkeyValue + 
                "<br /><br />");
        }
    }
    else
    {
        output.Append("Value = " + Server.HtmlEncode(aCookie.Value) +
            "<br /><br />");
    }
}

或者,您可以将子键提取为NameValueCollection对象,如下面的例子所示:

System.Text.StringBuilder output = new System.Text.StringBuilder();
HttpCookie aCookie;
string subkeyName;
string subkeyValue;

for (int i = 0; i < Request.Cookies.Count; i++)
{
    aCookie = Request.Cookies[i];
    output.Append("Name = " + aCookie.Name + "<br />");
    if (aCookie.HasKeys)
    {
        System.Collections.Specialized.NameValueCollection CookieValues = 
            aCookie.Values;
        string[] CookieValueNames = CookieValues.AllKeys;
        for (int j = 0; j < CookieValues.Count; j++)
        {
            subkeyName = Server.HtmlEncode(CookieValueNames[j]);
            subkeyValue = Server.HtmlEncode(CookieValues[j]);
            output.Append("Subkey name = " + subkeyName + "<br />");
            output.Append("Subkey value = " + subkeyValue + 
                "<br /><br />");
        }
    }
    else
    {
        output.Append("Value = " + Server.HtmlEncode(aCookie.Value) +
            "<br /><br />");
    }
}

Cookie的删除和修改

修改Cookie

不能直接在获取到Cookie后就修改Cookie的值,因为Cookie存储在用户的硬盘上(Request.Cookies[“Key”].Value=”some”,在这里是不起作用的),必须在Response.Cookies[“Key”].Value=”SomeNew”中修改才可以。其实就是服务器中设置的Cookie新值,覆盖了用户浏览地上的Cookie的旧值。

代码示例:

int counter;
if (Request.Cookies["counter"] == null)
    counter = 0;
else
{
    counter = int.Parse(Request.Cookies["counter"].Value);
}
counter++;

Response.Cookies["counter"].Value = counter.ToString();
Response.Cookies["counter"].Expires = DateTime.Now.AddDays(1);

删除Cookie

将Cookie从用户的硬磁盘上删除,和修改Cookie原理是一样的。不能直接删除Cookie,因为Cookie在用户的硬盘上。但是,可以创建一个新Cookie,其名称与要删除的Cookie相同,但要将Cookie的过期时间设置为比今天更早的日期。当浏览器检查Cookie的过期时间,浏览器将丢弃已经过时的Cookie。

代码示例:

HttpCookie aCookie;
string cookieName;
int limit = Request.Cookies.Count;
for (int i=0; i<limit; i++)
{
    cookieName = Request.Cookies[i].Name;
    aCookie = new HttpCookie(cookieName);
    aCookie.Expires = DateTime.Now.AddDays(-1);
    Response.Cookies.Add(aCookie);
}

子键的修改和删除

修改一个单独的子键与创建它是一样的

如:

Response.Cookies["userInfo"]["lastVisit"] = DateTime.Now.ToString();
Response.Cookies["userInfo"].Expires = DateTime.Now.AddDays(1);

要删除一个单独的子键,您可以操作Cookie的值集合,该集合包含子键。
首先从Cookie集合中获取一个指定的Cookie,然后调用该cookie值集合的remove方法,参数即为要删除的子键名称,再把该Cookie添加到集合中。

如下代码示例:

string subkeyName;
subkeyName = "userName";
HttpCookie aCookie = Request.Cookies["userInfo"];
aCookie.Values.Remove(subkeyName);
aCookie.Expires = DateTime.Now.AddDays(1);
Response.Cookies.Add(aCookie);

Cookies安全性

Cookie的安全性问题类似于从客户端获取数据。对于应用程序来说,可以把Cookie看作是另一种形式的用户输入。因为Cookie是保存在用户自己的硬盘上,所以Cookie对用户来说是可见的,也是可以修改的。

因为Cookie对用户是可见的所以不能在Cookie中存储敏感数据,比如用户名、密码、信用卡号等等。

因为Cookie也是可修改的,所以对程序来说从Cookie获取的信息,也需要验证和判断。不能简单的认为Cookie中的数据就和我们预期的数据一样。

Cookie是在浏览器和服务器之间是作为纯文本发送的,任何能够拦截Web流量的人都可以拦截Cookie。但是可以设置Cookie只有在使用安全套接字层(SSL)的情况下才会传输Cookie,这样在传输时会对Cookie加密。但是在用户的硬盘上,Cookie就不受SSL保护了。


确定浏览器是否接受cookie

用户可以设置浏览器拒绝Cookie。如果不能写入Cookie,也不会抛出错误。同样,浏览器也不会向服务器发送关于当前Cookie设置的任何信息。

客户端验证

最简单的是使用JS来判断

  if (navigator.cookieEnabled) {
        alert("Cookie 可用");
    }
    else {
        alert("Cookie 禁用");
    }

服务端验证

cookie属性并不表示是否启用了cookie。它只表明当前浏览器本身是否支持cookie。

在服务端判断Cookie是否被接受的一种方法是尝试写一个Cookie,然后再试着读取该Cookie。如果不能读取所编写的Cookie,那么就可以假定浏览器关闭了Cookie。


如有不对,请多多指教


参考:

Asp.Net MVC 中的 Cookie(译) – JoeSnail – 博客园已关闭评论
2019年4月18日 By mikel 分类: C#
http://baa.im/847971

来源: C# 运行时动态对象创建和动态方法调用 – Joly-Han – 博客园

C# 运行时动态对象创建       
   运行时动态对象创建(我也不知道该叫什么名字,就姑且这么随便称呼了)确实很势大,应该是很有威力的。程序员,贴代码最直接了:

                   int n = System.Activator.CreateInstance<int>();

        这一句没啥可说的,根据类别创建对象。这里要注意的是int型别是编译时可确定的。不是typeof(int)类型。

                   Type type = Type.GetType(“System.Int32”, false, true);

                   object o = System.Activator.CreateInstance(type);

                   Debug.Assert(o.GetType() == typeof(int));

第一句是根据类型名称得到类型Type。对于工厂模式有印象的同学肯定知道该特性是多么有用。注意这里类型名称不能用int,而必须是类型的全写,int之类是C#编译器的关键字,而不是CLR的。

       第二句是根据Type生成对象。这对于有运行时动态生成对象需求的系统非常有用。不过这里的object o声明不能高级到哪去,至多你后面加一个as IYourInterface,不过还是无法在编译代码里直接描述对象类别。

                   Type type = typeof(int);

                   Type listType = typeof(List<>);

                   Type[] typeArgs = { type };

                   Type genericType = listType.MakeGenericType(typeArgs);

                   object o = Activator.CreateInstance(genericType);

                   Debug.Assert(o.GetType() == typeof(List<int>));

       这段代码更奇特了,可以动态的生成泛型对象。如果你只有在运行时才知道泛型容器的类型参数,问题该如何描述呢?上面的解决方案非常直爽,要的就是这感觉。

  

C#动态方法调用

     /// <summary>

     /// 该类将被独立编入Class1.dll汇编

     /// </summary>

     class Class1

     {

         public static string method1()

         {

              return “I am Static method (method1) in class1”;

         }

         public string method2()

         {

              return “I am a Instance Method (method2) in Class1”;

         }

         public string method3(string s)

         {

              return “Hello ” + s;

         }

     }

 

     /// <summary>

     /// 该类独立放入Test.exe汇编

     /// </summary>

     class DynamicInvoke

     {

         public static void Main(string[] args)

         {

              // 动态加载汇编

              string path = “Class1.dll”;

              Assembly assembly = Assembly.Load(path);

 

              // 根据类型名得到Type

              Type type = assembly.GetType(“Class1”);

 

              // 根据方法名动态调用静态方法

              string str = (string)type.InvokeMember(“method1”, BindingFlags.Default | BindingFlags.InvokeMethod, null, null, new object[] { });

              Console.WriteLine(str);

 

              // 根据类型动态创建对象

              object o = Activator.CreateInstance(type);

 

              // 根据方法名动态调用动态对象的成员方法

              str = (string)type.InvokeMember(“method2”, BindingFlags.Default | BindingFlags.InvokeMethod, null, o, new object[] { });

              Console.WriteLine(str);

 

              // 根据方法名动态调用动态对象的有参成员方法

              object[] par = new object[] { “kunal” };

              str = (string)type.InvokeMember(“method3”, BindingFlags.Default | BindingFlags.InvokeMethod, null, o, par);

              Console.WriteLine(str);

 

              // 带out修饰的InvokeMember

              // System.Int32 中 public static bool TryParse(string s, out int result) 方法的调用

              var arguments = new object[] { str, null}; // 注意这里只能将参数写在外面,out参数为null也没有关系

              typeof(int).InvokeMember(“TryParse”, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.InvokeMethod |System.Reflection.BindingFlags.Static,

                   null, null, arguments);

              Console.WriteLine(arguments[1]);

         }

     }

 

 

(原文地址:http://blog.sina.com.cn/dekun1002 )s

C# 运行时动态对象创建和动态方法调用- Joly-Han – 博客园已关闭评论
2019年4月18日 By mikel 分类: C#
http://baa.im/847971

来源: c# 匿名对象增加动态属性 – 金钱 – 博客园

在开发过程中碰到了一个需求,需要动态创建对象及其动态属性。在尝试几种方法后,最后完成了需求,记录下过程,给园友参考下

1.动态创建对象一:匿名对象

object obj1 = new {Name = "金朝钱",Age="31",Birthday =DateTime.Now};

创建的匿名对象:

问题1:无法动态映射对象属性

解决:使用反射的方式获取对象值

object obj1 = new {Name = "金朝钱",Age="31",Birthday =DateTime.Now};
Response.Write(string.Format("Name:{0}", obj1.GetType().GetProperty("Name").GetValue(obj1, null).ToString()));

输出结果

问题2:无法动态创建对象属性

 

2.使用动态对象创建方法二、动态对象

dynamic obj2 = new System.Dynamic.ExpandoObject();
obj2.Name = "金朝钱";
obj2.Age = 31;
obj2.Birthday = DateTime.Now;
Response.Write(string.Format("Name:{0}", obj2.Name));

创建的动态对象:

输出结果:

问题:还是不能动态增加对象

 

3.动态创建对象及其属性

查看ExpandoObject的定义,发现其实质是一个Dictionary存放键值对,是否可以通过该方法来动态处理对象属性呢?

 

复制代码
Dictionary<string, object> temp = new Dictionary<string, object>();
temp.Add("Name", "金朝钱");
temp["Age"] = 31;
temp["Birthday"] = DateTime.Now;

dynamic obj = new System.Dynamic.ExpandoObject();

foreach (KeyValuePair<string, object> item in temp)
{
((IDictionary<string, object>)obj).Add(item.Key, item.Value);
}

Response.Write(string.Format("Name:{0}", obj.GetType().GetProperty("name").GetValue(obj, null).ToString()));
复制代码

 

对象查看:

输出:

输出是发生错误,不能用反射获取对象属性,经查,该对象的Field和Property全部都是null,那么我们和上面一样使用Dictionary进行输出

 

终于搞定收工,有类似需要的朋友可以参考下。

c# 匿名对象增加动态属性 – 金钱 – 博客园已关闭评论
2019年4月18日 By mikel 分类: C#
http://baa.im/847971

来源: C# DynamicObject 动态对象 – MingsonZheng – 博客园

dynamic是FrameWork4.0的新特性。dynamic的出现让C#具有了弱语言类型的特性。编译器在编译的时候不再对类型进行检查,编译期默认dynamic对象支持你想要的任何特性。比如,即使你对GetDynamicObject方法返回的对象一无所知,你也可以像如下那样进行代码的调用,编译器不会报错:

dynamic dynamicObject = GetDynamicObject();
Console.WriteLine(dynamicObject.Name);
Console.WriteLine(dynamicObject.SampleMethod());

dynamic与var关键字本质区别

var只能用作局部变量,不能用于字段,参数;声明的同时必须初始化;初始化时类型就已经确定了,并且不能再被赋值不能进行隐式类型转换的类型的数据。

var实际上是编译期抛给我们的“语法糖”,一旦被编译,编译期会自动匹配var 变量的实际类型,并用实际类型来替换该变量的申明,这看上去就好像我们在编码的时候是用实际类型进行申明的。

dynamic可用于类型的字段,方法参数,方法返回值,可用于泛型的类型参数等;可以赋值给或被赋值任何类型并且不需要显式的强制类型转换,因为这些是运行时执行的,这要得益于dynamic类型的动态特性。

dynamic被编译后,实际是一个object类型,只不过编译器会对dynamic类型进行特殊处理,让它在编译期间不进行任何的类型检查,而是将类型检查放到了运行期。

从visual studio的编辑器窗口就能看出来。以var声明的变量,支持“智能感知”,因为visual studion能推断出var类型的实际类型,而以dynamic声明的变量却不支持“智能感知”,因为编译器对其运行期的类型一无所知。对dynamic变量使用“智能感知”,会提示“此操作将在运行时解析”。

类型转换

Dynamic类型的实例和其他类型的实例间的转换是很简单的,开发人员能够很方便地在dyanmic和非dynamic行为间切换。任何实例都能隐式转换为dynamic类型实例,见下面的例子:

dynamic d1 = 7;
dynamic d2 = "a string";
dynamic d3 = System.DateTime.Today;
dynamic d4 = System.Diagnostics.Process.GetProcesses();

Conversely, an implicit conversion can be dynamically applied to any expression of type dynamic.
反之亦然,类型为dynamic的任何表达式也能够隐式转换为其他类型。

int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;

方法中含有dynamic类型参数的重载问题

如果调用一个方法是传递了dynamic类型的对象,或者被调用的对象是dynamic类型的,那么重载的判断是发生在运行时而不是编译时。
动态语言运行时(dynamic language runtime DLR)动态语言运行时是.NET Framework 4 Beta 1中的一组新的API,它提供了对C#中dynamic类型的支持,也实现了像IronPython和IronRuby之类的动态程序设计语言。

dynamic 简化反射

以前我们这样使用反射:

public class DynamicSample
{
public string Name { get; set; }

public int Add(int a, int b)
{
return a + b;
}
}
DynamicSample dynamicSample = new DynamicSample(); //create instance为了简化演示,我没有使用反射
var addMethod = typeof(DynamicSample).GetMethod("Add");
int re = (int)addMethod.Invoke(dynamicSample, new object[] { 1, 2 });

现在,我们有了简化的写法:

dynamic dynamicSample2 = new DynamicSample();
int re2 = dynamicSample2.Add(1, 2);

var,dynamic,传统确定类型的效率对比

传统类型的效率 >= var动态类型 > dynamic动态类型

编译器对dynamic进行了优化,比没有经过缓存的反射效率高。

参考文章:

https://www.cnblogs.com/qiuweiguo/archive/2011/08/03/2125982.html
https://blog.csdn.net/shanyongxu/article/details/47296033

C# DynamicObject 动态对象 – MingsonZheng – 博客园已关闭评论
2019年4月16日 By mikel 分类: JavaScript
http://baa.im/847971

来源: layui的table单击行勾选checkbox功能方法_javascript技巧_脚本之家

实现原理:找到table的div绑定单击事件到表格的行:

1、取得行的索引data-index,为后面查找checkbox的控件作准备

2、根据是否有固定列查找checkbox所在的表格table(当存在固定列时,固定列是另一个table,checkbox控件就在这上面,因此要优先取这个)

3、通过table和data-index查找checkbox控件”td div.laytable-cell-checkbox div.layui-form-checkbox I”,如果存在,则执行单击

4、对td的单击事件进行拦截停止,防止事件冒泡再次触发上述的单击事件5、将此代码在页面初始化后执行一次即可以。

实现效果:单击行,自动选中或取消勾选。

以上这篇layui的table单击行勾选checkbox功能方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

//单击行勾选checkbox事件
$(document).on(“click”,”.layui-table-body table.layui-table tbody tr”, function () {
var index = $(this).attr(‘data-index’);
var tableBox = $(this).parents(‘.layui-table-box’);
//存在固定列
if (tableBox.find(“.layui-table-fixed.layui-table-fixed-l”).length>0) {
tableDiv = tableBox.find(“.layui-table-fixed.layui-table-fixed-l”);
} else {
tableDiv = tableBox.find(“.layui-table-body.layui-table-main”);
}
var checkCell = tableDiv.find(“tr[data-index=” + index + “]”).find(“td div.laytable-cell-checkbox div.layui-form-checkbox I”);
if (checkCell.length>0) {
checkCell.click();
}
});

$(document).on(“click”, “td div.laytable-cell-checkbox div.layui-form-checkbox”, function (e) {
e.stopPropagation();
});

layui的table单击行勾选checkbox功能方法_javascript技巧_脚本之家已关闭评论
2019年4月1日 By mikel 分类: C#
http://baa.im/847971

来源: C#开发:openfiledialog的使用 – 希格绍尔 – 博客园

C#开发:openfiledialog的使用
文件对话框(FileDialog)

一、打开文件对话框(OpenFileDialog)

1、 OpenFileDialog控件有以下基本属性

InitialDirectory 对话框的初始目录
Filter 要在对话框中显示的文件筛选器,例如,”文本文件(*.txt)|*.txt|所有文件(*.*)||*.*”
FilterIndex 在对话框中选择的文件筛选器的索引,如果选第一项就设为1
RestoreDirectory 控制对话框在关闭之前是否恢复当前目录
FileName 第一个在对话框中显示的文件或最后一个选取的文件
Title 将显示在对话框标题栏中的字符
AddExtension 是否自动添加默认扩展名
CheckPathExists
在对话框返回之前,检查指定路径是否存在
DefaultExt 默认扩展名
DereferenceLinks 在从对话框返回前是否取消引用快捷方式
ShowHelp
启用”帮助”按钮
ValiDateNames 控制对话框检查文件名中是否不含有无效的字符或序列

2、 OpenFileDialog控件有以下常用事件

FileOk 当用户点击”打开”或”保存”按钮时要处理的事件
HelpRequest 当用户点击”帮助”按钮时要处理的事件

 

可以用以下代码来实现上面这个对话框:

private void openFileDialogBTN_Click(object sender, System.EventArgs e){
OpenFileDialog openFileDialog=new OpenFileDialog();
openFileDialog.InitialDirectory=”c:\\”;//注意这里写路径时要用c:\\而不是c:\
openFileDialog.Filter=”文本文件|*.*|C#文件|*.cs|所有文件|*.*”;
openFileDialog.RestoreDirectory=true;
openFileDialog.FilterIndex=1;
if (openFileDialog.ShowDialog()==DialogResult.OK)
{
fName=openFileDialog.FileName;
File fileOpen=new File(fName);
isFileHaveName=true;
richTextBox1.Text=fileOpen.ReadFile();
richTextBox1.AppendText(“”);
}
}

路径的返回用filename是字符串类型

如:openFileDialog1.ShowDialog();
_name1= openFileDialog1.FileName;
Image imge = Image.FromFile(_name1);

C#开发:openfiledialog的使用 – 希格绍尔 – 博客园已关闭评论
2019年3月26日 By mikel 分类: C#
http://baa.im/847971

来源: C#自定义Attribute的定义和获取简例 – 上校 – 博客园

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Configuration;
using System.Reflection;

namespace WebApplication4
{
public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
abc ta = new abc();
Type type = ta.GetType();
GetTableName(type);

PropertyInfo[] propertys = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);

foreach (PropertyInfo p in propertys)
{
//此处用了PropertyInfo.GetCustomAttributes方法,该方法继承至MemberInfo
object[] objs = p.GetCustomAttributes(false);
foreach (object obj in objs)
{
//string PK = GetPrimaryKey(obj);
string ColumnName = GetColumnName(obj);
}
}
}

public static string GetTableName(Type classType)
{
string strTableName = string.Empty;
string strEntityName = string.Empty;
string strTableTel = string.Empty;

strEntityName = classType.FullName;//类的全名

//此处用了System.Type.GetCustomAttributes 方法,该方法继承至MemberInfo object classAttr = classType.GetCustomAttributes(false)[0];
if (classAttr is TableAttribute)
{
TableAttribute tableAttr = classAttr as TableAttribute;
strTableName = tableAttr.Name;
strTableTel = tableAttr.Tel;
}
if (string.IsNullOrEmpty(strTableName))
{
throw new Exception(“实体类:” + strEntityName + “的属性配置[Table(name=\”tablename\”)]错误或未配置”);
}
if (string.IsNullOrEmpty(strTableTel))
{
throw new Exception(“实体类:” + strEntityName + “的属性配置[Table(tel=\”telname\”)]错误或未配置”);
}

return strTableName;
}

public static string GetPrimaryKey(object attribute)
{
string strPrimary = string.Empty;
IdAttribute attr = attribute as IdAttribute;
switch (attr.Strategy)
{
case GenerationType.INDENTITY:
break;
case GenerationType.SEQUENCE:
strPrimary = System.Guid.NewGuid().ToString();
break;
case GenerationType.TABLE:
break;
}

return strPrimary;
}

public static string GetColumnName(object attribute)
{
string columnName = string.Empty;
if (attribute is ColumnAttribute)
{
ColumnAttribute columnAttr = attribute as ColumnAttribute;
columnName = columnAttr.Name;
}
else if (attribute is IdAttribute)
{
IdAttribute idAttr = attribute as IdAttribute;
columnName = idAttr.Name;
}

return columnName;
}
}

[Table(Name = “Student”,Tel=”ew”)]
public class abc
{
private string _a = string.Empty;
[Id(Name = “studentid”, Strategy = GenerationType.INDENTITY)]
public string a
{
get { return _a; }
set { _a = value; }
}
private string _b = string.Empty;
[Column(Name = “studentno”)]
public string b
{
get { return _b; }
set { _b = value; }
}

public string c = string.Empty;
}

[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
public class TableAttribute : Attribute
{
public TableAttribute() { }

private string _Name = string.Empty;
public string Name
{
get { return _Name; }
set { _Name = value; }
}

private string _Tel = string.Empty;
public string Tel
{
get { return _Tel; }
set { _Tel = value; }
}
}

[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
public class IdAttribute : Attribute
{
private string _Name = string.Empty;
private int _Strategy = GenerationType.INDENTITY;

public string Name
{
get { return _Name; }
set { _Name = value; }
}

public int Strategy
{
get { return _Strategy; }
set { _Strategy = value; }
}
}

public class GenerationType
{
public const int INDENTITY = 1;//自动增长
public const int SEQUENCE = 2;//序列
public const int TABLE = 3;//TABLE

private GenerationType() { }//私有构造函数,不可被实例化对象
}

[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property,
AllowMultiple = false, Inherited = false)]
public class ColumnAttribute : Attribute
{
public ColumnAttribute() { }

private string _Name = string.Empty;//列名
private bool _IsUnique = false;//是否唯一
private bool _IsNull = true;//是否允许为空
private bool _IsInsert = true;//是否插入到表中
private bool _IsUpdate = true;//是否修改到表中

public string Name
{
get { return _Name; }
set { _Name = value; }
}

public bool IsUnique
{
get { return _IsUnique; }
set { _IsUnique = value; }
}

public bool IsNull
{
get { return _IsNull; }
set { _IsNull = value; }
}

public bool IsInsert
{
get { return _IsInsert; }
set { _IsInsert = value; }
}

public bool IsUpdate
{
get { return _IsUpdate; }
set { _IsUpdate = value; }
}
}
}

C#自定义Attribute的定义和获取简例 – 上校 – 博客园已关闭评论
2019年3月26日 By mikel 分类: C#
http://baa.im/847971

来源: C#自定义Attribute值的获取与优化 – junjieok – 博客园

C#自定义Attribute值的获取是开发中会经常用到的,一般我们的做法也就是用反射进行获取的,代码也不是很复杂。

1、首先有如下自定义的Attribute

复制代码
 1     [AttributeUsage(AttributeTargets.All)]
 2     public sealed class NameAttribute : Attribute
 3     {
 4         private readonly string _name;
 5 
 6         public string Name
 7         {
 8             get { return _name; }
 9         }
10 
11         public NameAttribute(string name)
12         {
13             _name = name;
14         }
15     }
复制代码

2、定义一个使用NameAttribute的类

复制代码
1     [Name("dept")]
2     public class CustomAttributes
3     {
4         [Name("Deptment Name")]
5         public string Name { get; set; }
6 
7         [Name("Deptment Address")]
8         public string Address;
9     }
复制代码

3、获取CustomAttributes类上的”dept”也就很简单了

复制代码
 1         private static string GetName()
 2         {
 3             var type = typeof(CustomAttributes);
 4 
 5             var attribute = type.GetCustomAttributes(typeof(NameAttribute), false).FirstOrDefault();
 6 
 7             if (attribute == null)
 8             {
 9                 return null;
10             }
11 
12             return ((NameAttribute)attribute).Name;
13         }
复制代码

以上代码就可以简单的获取,类上的Attribute的值了,但是需求往往不是这么简单的,不仅要获取类头部Attribute上的值,还要获取字段Address头部Attribute上的值。有的同学可能就觉得这还不简单呀,直接上代码

复制代码
 1         private static string GetAddress()
 2         {
 3             var type = typeof (CustomAttributes);
 4 
 5             var fieldInfo = type.GetField("Address");
 6             if (fieldInfo == null)
 7             {
 8                 return null;
 9             }
10 
11             var attribute = fieldInfo.GetCustomAttributes(typeof(NameAttribute), false).FirstOrDefault();
12 
13             if (attribute == null)
14             {
15                 return null;
16             }
17 
18             return ((NameAttribute) attribute).Name;
19         }
复制代码

上面代码就是获取Address字段头部上的Attribute值了。虽然我们是获取到了我们想要的,但是我们发现这样做是不是太累了,如果又扩展一个自定义的Attribute,或者又在一个新的属性或字段上标上Attribute时,我们又要写一段代码来实现我想要的,这些严重代码违反了DRY的设计原则。我们知道获取Attribute是通过反射来取的,Attribute那个值又是不变的,这样就没必要每次都要进行反射来获取了。基于以上两点代码进行了如下的优化,优化后的代码如下:

复制代码
  1     public static class CustomAttributeHelper
  2     { 
  3         /// <summary>
  4         /// Cache Data
  5         /// </summary>
  6         private static readonly Dictionary<string, string> Cache = new Dictionary<string, string>();
  7 
  8         /// <summary>
  9         /// 获取CustomAttribute Value
 10         /// </summary>
 11         /// <typeparam name="T">Attribute的子类型</typeparam>
 12         /// <param name="sourceType">头部标有CustomAttribute类的类型</param>
 13         /// <param name="attributeValueAction">取Attribute具体哪个属性值的匿名函数</param>
 14         /// <returns>返回Attribute的值,没有则返回null</returns>
 15         public static string GetCustomAttributeValue<T>(this Type sourceType, Func<T, string> attributeValueAction) where T : Attribute
 16         {
 17             return GetAttributeValue(sourceType, attributeValueAction, null);
 18         }
 19 
 20         /// <summary>
 21         /// 获取CustomAttribute Value
 22         /// </summary>
 23         /// <typeparam name="T">Attribute的子类型</typeparam>
 24         /// <param name="sourceType">头部标有CustomAttribute类的类型</param>
 25         /// <param name="attributeValueAction">取Attribute具体哪个属性值的匿名函数</param>
 26         /// <param name="name">field name或property name</param>
 27         /// <returns>返回Attribute的值,没有则返回null</returns>
 28         public static string GetCustomAttributeValue<T>(this Type sourceType, Func<T, string> attributeValueAction,
 29             string name) where T : Attribute
 30         {
 31             return GetAttributeValue(sourceType, attributeValueAction, name);
 32         }
 33 
 34         private static string GetAttributeValue<T>(Type sourceType, Func<T, string> attributeValueAction,
 35             string name) where T : Attribute
 36         {
 37             var key = BuildKey(sourceType, name);
 38             if (!Cache.ContainsKey(key))
 39             {
 40                 CacheAttributeValue(sourceType, attributeValueAction, name);
 41             }
 42 
 43             return Cache[key];
 44         }
 45 
 46         /// <summary>
 47         /// 缓存Attribute Value
 48         /// </summary>
 49         private static void CacheAttributeValue<T>(Type type,
 50             Func<T, string> attributeValueAction, string name)
 51         {
 52             var key = BuildKey(type, name);
 53 
 54             var value = GetValue(type, attributeValueAction, name);
 55 
 56             lock (key + "_attributeValueLockKey")
 57             {
 58                 if (!Cache.ContainsKey(key))
 59                 {
 60                     Cache[key] = value;
 61                 }
 62             }
 63         }
 64 
 65         private static string GetValue<T>(Type type,
 66             Func<T, string> attributeValueAction, string name)
 67         {
 68             object attribute = null;
 69             if (string.IsNullOrEmpty(name))
 70             {
 71                 attribute =
 72                     type.GetCustomAttributes(typeof (T), false).FirstOrDefault();
 73             }
 74             else
 75             {
 76                 var propertyInfo = type.GetProperty(name);
 77                 if (propertyInfo != null)
 78                 {
 79                     attribute =
 80                         propertyInfo.GetCustomAttributes(typeof (T), false).FirstOrDefault();
 81                 }
 82 
 83                 var fieldInfo = type.GetField(name);
 84                 if (fieldInfo != null)
 85                 {
 86                     attribute = fieldInfo.GetCustomAttributes(typeof (T), false).FirstOrDefault();
 87                 }
 88             }
 89 
 90             return attribute == null ? null : attributeValueAction((T) attribute);
 91         }
 92 
 93         /// <summary>
 94         /// 缓存Collection Name Key
 95         /// </summary>
 96         private static string BuildKey(Type type, string name)
 97         {
 98             if (string.IsNullOrEmpty(name))
 99             {
100                 return type.FullName;
101             }
102 
103             return type.FullName + "." + name;
104         }
105     }
复制代码

以上优化后的代码:

把不同的代码用泛型T,Fun<T,stirng>来处理来减少重复的代码;
把取过的Attribute值存到一个Dictionary中,下次再来取时,如果有则直接返回Dictionary中的值,如果没有才通过反射来取相应的Attribute值,这样大大的提高效率;

调用方法也更加的简单了,代码如下:

1             var cName=typeof(CustomAttributes).GetCustomAttributeValue<NameAttribute>(x => x.Name);
2             var fName = typeof (CustomAttributes).GetCustomAttributeValue<NameAttribute>(x => x.Name, "Address");

有没有, 是不是很简单,而且调用方式对缓存是完全透明的!

C#自定义Attribute值的获取与优化 – junjieok – 博客园已关闭评论
备案信息冀ICP 0007948