一些踩过的坑

1）关于特性过滤器

    这个我们经常用到，一般用在捕捉异常还有权限控制等方面，这个用着比较方便，但是这个确隐藏着一个坑，就是呢，特性过滤器会在被第一次访问的时候创建一次，仅仅会被创建一次，然后就被aspnet缓存下来，之后就是取缓存了。

所以说如果我们要定义特性类的话，必须要注意一点就是里面不能包含状态可变的局部变量，因为会存在线程安全问题

2）关于nuget程序集版本

我们程序里面用到nuget的地方有很多，但是有的时候我们会出现不同程序集引用的nuget包版本不一样，但是程序编译完成之后web目录下只会有一个版本的dll，这样如果是强名称的包的话就会抛出版本异常，所以这种情况我建议是尽量保持所有程序集版本相同。

当然还有一个应急解决方案，就是webconfig下会有这么个节点

这个节点的作用就是程序集重定向，做程序集版本检查的时候对old版本的引用会被重定向到新版本

3）关于集合的线程安全

Dictionary<,>，List<>：

线程非安全:

添加删除操作都会维护一个version字段，每次+1

然后生成的迭代器的时候会传入version版本号，然后呢，迭代的时候会判断迭代器的version是否和version相同，如果不同则抛出异常

所以说如果发生并发操作，一个线程正在查询dic的时候另一个线程对这个dic做了修改则会抛出异常

ConcurrentDictionary

线程安全

采用了 volatile 来设置和取值

没有维护version字段

4）关于Https

目前由于我们需要使用https，所以页面也会针对请求内容来进行兼容，http的请求需要返回http后缀的静态内容，https的要返回带https后缀的静态内容，所以我们就会想到通过请求方式来判断，在程序中获取用户的请求方式，从而达到目的

但是上面的方式是有问题的，而且这个问题只有在生产环境草会被发现：

由于生产环境的证书是配置在nginx服务器上的，所以https只会到达nginx，nginx转发到我们web服务器的时候依旧是http请求，所以这种方式在生产环境始终是http的

所以推荐的解决方案就是配置静态地址的时候不要加上协议头，src可以直接写成"//res.rongzi.com....."这样浏览器就会根据具体的请求来识别使用哪种协议

5）关于HttpClient

目前我们项目里面的代码都习惯于使用using(HttpClient client = new HttpClient){}

但是这么写是有问题的：

1、就是HttpClient自己本身会维护一个连接池，所以说其实这个HttpClient只要实例化一个即可满足所有要求

2、以上调用方法使用完成会调用client的DIspose方法来释放这个池子，但是呢，这个池子的完全释放需要4分钟左右的时间，所以呢，这个会导致一个问题，就是这个如果4分钟之内请求到达 一定程度就会耗尽套接字，从而抛出一个异常（主站曾经出现过这样的问题）

具体文章链接：

http://www.infoq.com/cn/news/2016/09/HttpClient

所以针对这种情况我封装了一个HttpHelper的类来处理请求：

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Platform.Facilitys
{
    public static class HttpHelper
    {
        

        static readonly HttpClient _client;
        static HttpHelper()
        {
            _client = new HttpClient();
        }
        
        public static TOut PostSync<TIn, TOut>(ApiHost host, TIn postData)
           where TIn : class
           where TOut : class
        {
            var uri = new Uri(host.Domain);
            var url = new Uri(uri, host.ApiName);
            var response = _client.PostAsync(url, new StringContent(JsonConvert.SerializeObject(postData),Encoding.UTF8,host.DataMimeType)).Result;
            response.EnsureSuccessStatusCode();
            return response.Content.DesObj<TOut>();

        }

        public static Task<TOut> PostAsync<TIn, TOut>(ApiHost host, TIn postData)
           where TIn : class
           where TOut : class
        {
            var uri = new Uri(host.Domain);
            var url = new Uri(uri, host.ApiName);
            return _client.PostAsync(url, new StringContent(JsonConvert.SerializeObject(postData), Encoding.UTF8, host.DataMimeType)).GetResult<TOut>();
        }

        public static Task<TOut> GetAsync<TOut>(ApiHost host)
           where TOut : class
        {
            var uri = new Uri(host.Domain);
            var url = new Uri(uri, host.ApiName);
            return _client.GetAsync(url).GetResult<TOut>();
        }

        static Task<TOut> GetResult<TOut>(this Task<HttpResponseMessage> tsk)
           where TOut : class
        {
            return tsk.ContinueWith(
                res =>
                {
                    return res
                            .Result
                            .EnsureSuccessStatusCode()
                            .Content
                            .DesObj<TOut>();
                }, TaskContinuationOptions.OnlyOnRanToCompletion);
        }

        static TOut DesObj<TOut>(this HttpContent content)
           where TOut : class
        {
            var strJson = content.ReadAsStringAsync().Result;
            if (!string.IsNullOrWhiteSpace(strJson))
            {
                if (strJson.IndexOf("k__BackingField") > 0)
                {
                    DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(TOut));
                    using (var mStream = new MemoryStream(Encoding.Default.GetBytes(strJson)))
                    {
                        return ser.ReadObject(mStream) as TOut;
                    }

                }
                else
                {
                    return JsonConvert.DeserializeObject<TOut>(strJson);
                }
            }
            return default(TOut);
        }
    }


    /// <summary>
    /// WebApi配置
    /// </summary>
    public class ApiHost
    {
        #region
        public ApiHost()
        {
            DataMimeType = "application/json";
        }
        public ApiHost(string domain, string apiName, string inputQueryString, string dataMimeType)
        {
            Domain = domain;
            ApiName = apiName;
            InputQueryString = inputQueryString;
            DataMimeType = dataMimeType;
        }
        #endregion
        #region
        /// <summary>
        /// 主域名(比如http://api.rongzi.com or http://127.0.0.1)
        /// </summary>
        public string Domain { get; set; }

        /// <summary>
        /// Api名称(api/v1/studentinfotest)
        /// </summary>
        public string ApiName { get; set; }

        /// <summary>
        /// 传入参数名称
        /// </summary>
        public string InputQueryString { get; set; }

        /// <summary>
        /// 返回数据类型
        /// </summary>
        public string DataMimeType { get; set; }

        /// <summary>
        /// 重写ToString()
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return string.Format("{0}|{1}|{2}|{3}",
                this.ApiName,
                this.Domain,
                this.DataMimeType,
                this.InputQueryString);
        }
        #endregion
    }

}

6）关于线程存储

我们在开发的过程中，有时候在一个web生命周期内会需要从前到后传递一些对象之类的东西，这个时候可能会用到一个手段CallContext.SetData来设置数据，这个方法是将内容存放到线程中，所以只要在同一个线程中都可以取到这个内容，但是如果这个Action是异步的，async的，就会导致会有多个线程依次处理这个请求，这种情况往往是取不到之前设置的值的，这时候就可以使用CallContext.LogicSetData来设置值，这种方式设置的内容会被拷贝到新线程中

 

7）关于溢出检查

C#中有个关键字叫check，作用是对内部代码执行做溢出检查，看例子

int b = int.MaxValue;
b++;//这里不会抛出异常，b变为-2147483648

unchecked
{
   int a = int.MaxValue;
   a++;//这里也不会抛出异常，a变成-2147483648
}
checked
{
   int a = int.MaxValue;
   a++;//这里抛出异常，超出最大值
}

默认情况下是uncheck，所以有些情况int值到了最大值添加之后返回了错误的值，这个坑也是需要注意的

8）关于ThreadPool设置最大线程数：

ThreadPool是级不建议用户手动设置最大线程数的：

我们之前出现一个问题，就是这个设置了最大线程数导致的，首先我们设置了10个线程来跑某个请求api的任务，当我们取到了10个任务，通过ThreadPool.QueueUserWorkItem方法将任务排到线程池内，

但是呢我们的任务是请求api的任务，而我们的api都是用的HttpClient来访问的，由于HttpClient中的请求方法都是异步的，这就导致了一个问题，假设我们10个任务都排到了线程池队列中，走到Http请求的那一步的时候，由于HttpClient需要启动一个Task来发送Http请求，而Task也是使用的线程池，但是这个时候线程池中的线程已经用完，没有办法再分配线程，所以这就导致了循环等待，但是如果不用这种方式限制的话该怎么限制呢？

可以使用信号量来控制线程数，每开启一个任务，信号量加1，任务完成的时候-1，当信号量到10的时候就不再执行，等待有空闲任务的时候再执行

9）关于使用redis之后出现的问题：

1、CPU，内存消耗量增大：由于数据都是取自Redis，然后序列化为对象集合，所以序列化过程是一个方面，还有一个就是在并发量比较大的时候产生的拷贝会很多，会导致内存消耗激增，还有就是垃圾回收也变得频繁起来，代很快就满了，就导致cpu要不断进行垃圾回收工作，解决方案：

　　1、设置二级缓存，先内存，再Redis，这样可以减少序列化次数

　　2、将缓存细化，将集合按一定的维度分散存储，这样可以减少一次取的数据量减少许多，序列化时间也会大大减小，cpu尖刺也会少了很多 

 2、关于序列化：使用Redis缓存的时候，很多对象需要序列化为二进制存储到Redis中，然后就必须给实体类上加上[Serializerable]标签，但是加上这个标签之后就出现了一个问题，原先的协议都不通了，WebApi没法收到前端MVC发来的数据（反序列化失败），

后来查明加上标签的类的对象反序列化为json的时候，是按照私有变量进行反序列化的，而不是根据属性来的，所以生成的json与之前的大不一样，反序列化的时候也是如此，所以会导致这个问题，解决方案：

就在上面那段代码里，我反序列化的时候判断了"k__BackingField"这个参数，有的话就采用微软的序列化，否则使用newton的

10) 关于Task.Result和Task.GetAwaiter().GetResult()的区别

他们的区别在于对异常的处理上：如果任务执行过程中发生异常，则Task.Result会将异常包装成一个AggregateException返回，而GetAwatiter().GetResult()则是直接返回原始异常信息