委托：//返回实例上所有筛选值
public delegate IEnumerable<object> GetAllValues(object instance);
    //返回实例上某个值
    public delegate object GetValue(object instance);

//扩展方法 

//bool +结果
  public static Result<Value> Result<Value>(this bool state, Value value)
        {
            return new Result<Value>(state, value);
        }
//属性取值， 反射
 public static object Getter(this PropertyInfo info, object instance)
        {
            return info.GetValue(instance);
        }
//新实例，反射
  public static object New(this Type t, params object[] args)
        {
            return args.IsEmpty() ? Activator.CreateInstance(t) : Activator.CreateInstance(t, args);
        }

 1      public static Result<GetAllValues> MatchType(this Type pattern, Type target) {
 2             var pis = pattern.GetProperties();
 3             var tpis = target.GetProperties();
 4             if (pis.Length < tpis.Length)
 5             {
 6                 7                 var fac = new List<GetValue>();
 8                 for (int i = 0; i < pis.Length; i++)
 9                 {
10                     var pi = pis[i];
11                     var r = pi.MatchProp(tpis);
12                     if (r.OK)
13                     {
14                         fac.Add(r.Value);
15                         continue;
16                     }
17                     return false;
29                 }
30                 return true.Result(new GetAllValues(o => fac.Select(c => c(o))));
31             }
32             return false;
33         }
34           static Result<GetValue> MatchProp(this PropertyInfo pi, IEnumerable<PropertyInfo> target) {
35
36             var npi =  target.FirstOrDefault(c => c.Name == pi.Name)??(pi.Name=="_"?target.FirstOrDefault(c=>c.PropertyType==pi.PropertyType):null);
37             if (npi != null) {
38                 if (pi.PropertyType.IsAnonymous() )
39                 {
40                     var r = pi.PropertyType.MatchType(npi.PropertyType);
41                     if (r.OK) {
42                         return true.Result(new GetValue(o => pi.PropertyType.New(r.Value(npi.Getter(o)).ToArray())));
43                     }
44                 }
45                 else if (  pi.PropertyType == npi.PropertyType)
46                 {
47                     return true.Result(new GetValue(o => npi.Getter(o)));
48
49                 }
50             }
51             return false;
52
53         }

        public static Result<TResult> AsPattern<TPattern, TResult>(this TPattern pattern, object matchobj, Func<TPattern, TResult> then) {
            var matchType = matchobj.GetType();
            var patternType = typeof(TPattern);
            var matchResult = patternType.MatchType(matchType);
            if (matchResult.OK) {
                var patternInstance = patternType.New(matchResult.Value(matchobj).ToArray());
                return true.Result(then((TPattern)patternInstance));
            }
            return false;
        }

1  var result =typeinfo.AsPattern(o, (c) => c).Value;//result 类型为code 04中typeinfo 的类型
2  //result.a;
3  //result.c.a1;
4  //result.c.e.name;

public static bool SignatureEqual(this MethodInfo mi, Type retType, IEnumerable<Type> paramTypes) {
            return mi.ReturnType == retType && paramTypes.SequenceEqual(mi.GetParameters().Select(p => p.ParameterType));
        }        //方法与委托类型的参数和返回值是否一致
        public static bool SignatureEqual(this MethodInfo mi, Type delegateType) {
            var cmi = delegateType.GetMethod("Invoke");
            return mi.SignatureEqual(cmi);
        }
        public static bool SignatureEqual(this MethodInfo mi, MethodInfo nmi) {
            return mi.SignatureEqual(nmi.ReturnType, nmi.GetParameters().Select(p => p.ParameterType));
        }

new GetValue(o => m.CreateDelegate(pi.PropertyType, o))//m MethodInfo

　　//从 XML 中创建数据源
　　//using System.Xml.Linq;
　　var contacts = XElement.Load(@"c:\xxx.xml");

　　在 LINQ to SQL 中，首先需要创建对象关系映射。 针对这些对象编写查询，然后由 LINQ to SQL 在运行时处理与数据库的通信。

1     var  db = new Northwnd(@"c:\northwnd.mdf");
2
3     //查询在伦敦的客户
4     var custQuery =
5         from cust in db.Customers
6         where cust.City == "London"
7         select cust;

1.3 查询

　　查询指定要从数据源中检索的信息。 查询还可以指定在返回这些信息之前如何对其进行排序、分组和结构化。 查询存储在查询变量中，并用查询表达式进行初始化。

1.4 查询执行

　　1.延迟执行

　　　　如前所述，查询变量本身只是存储查询命令。  实际的查询执行会延迟到在 foreach 语句中循环访问查询变量时发生。 此概念称为“延迟执行”。

　　2.强制立即执行

　　　　对一系列源元素执行聚合函数的查询必须首先循环访问这些元素。Count、Max、Average 和 First 就属于此类查询。由于查询本身必须使用 foreach 以便返回结果，因此这些查询在执行时不使用显式 foreach 语句。另外还要注意，这些类型的查询返回单个值，而不是 IEnumerable 集合。

1     var numbers = new int[7] { 0, 1, 2, 3, 4, 5, 6 };
2
3     var evenNumQuery =
4         from num in numbers
5         where (num % 2) == 0
6         select num;
7
8     var evenNumCount = evenNumQuery.Count();

　　若要强制立即执行任意查询并缓存其结果，可以调用 ToList<TSource> 或 ToArray<TSource> 方法。

1     var numQuery2 =
2            (from num in numbers
3             where (num % 2) == 0
4             select num).ToList();
5
6     var numQuery3 =
7           (from num in numbers
8            where (num % 2) == 0
9             select num).ToArray();

　　此外，还可以通过在紧跟查询表达式之后的位置放置一个 foreach 循环来强制执行查询。但是，通过调用 ToList 或 ToArray，也可以将所有数据缓存在单个集合对象中。

二、基本 LINQ 查询操作

2.1 获取数据源：from

　　在 LINQ 查询中，第一步是指定数据源。像在大多数编程语言中一样，必须先声明变量，才能使用它。在 LINQ 查询中，最先使用 from 子句的目的是引入数据源和范围变量。

1     //queryAllCustomers 是 IEnumerable<Cutsomer> 类型
2     //数据源 (customers) 和范围变量 (cust)
3     var queryAllCustomers = from cust in customers
4                                            select cust;

　　范围变量类似于 foreach 循环中的迭代变量，但在查询表达式中，实际上不发生迭代。执行查询时，范围变量将用作对 customers 中的每个后续元素的引用。因为编译器可以推断 cust 的类型，所以您不必显式指定此类型。

2.2 筛选：where

　　也许最常用的查询操作是应用布尔表达式形式的筛选器。此筛选器使查询只返回那些表达式结果为 true 的元素。使用 where 子句生成结果。实际上，筛选器指定从源序列中排除哪些元素。

1     var queryLondonCustomers = from cust in customers
2                 　　　　　　            where cust.City = "London"
3                  　　　　　              select cust;

　　您可以使用熟悉的 C# 逻辑 AND（&&）和 OR（||） 运算符来根据需要在 where 子句中应用任意数量的筛选表达式。

where cust.City = "London" && cust.Name = "Devon"

where cust.City = "London" || cust.Name = "Paris"

2.3 排序：orderby

　　通常可以很方便地将返回的数据进行排序。orderby 子句将使返回的序列中的元素按照被排序的类型的默认比较器进行排序。

1     var queryLondonCustomers = from cust in customers
2                                where cust.City = "London"
3                                orderby cust.Name descending
4                                select cust;

　　因为 Name 是一个字符串，所以默认比较器执行从 A 到 Z 的字母排序。若要按相反顺序（从 Z 到 A）对结果进行排序，请使用 orderby…descending 子句。

2.4 分组：group

　　使用 group 子句，您可以按指定的键分组结果。

 1     var queryLondonCustomers = from cust in customers
 2                     group cust by cust.City;
 3
 4     foreach (var queryLondonCustomer in queryLondonCustomers)
 5     {
 6        Console.WriteLine(queryLondonCustomer.Key);
 7        foreach (var cust in queryLondonCustomer)
 8        {
 9           Console.WriteLine(cust.Name);
10        }
11     }

　　在本例中，cust.City 是键。

　　在使用 group 子句结束查询时，结果采用列表的列表形式。列表中的每个元素是一个具有 Key 成员及根据该键分组的元素列表的对象。在循环访问生成组序列的查询时，您必须使用嵌套的 foreach 循环。外部循环用于循环访问每个组，内部循环用于循环访问每个组的成员。

　　如果您必须引用组操作的结果，可以使用 into 关键字来创建可进一步查询的标识符。

1     //custQuery 是 IEnumable<IGrouping<string, Customer>> 类型
2     var custQuery = from cust in customers
3                     group cust by cust.City
4                     into custGroup
5                     where custGroup.Count() > 2
6                     orderby custGroup.Key
7                     select custGroup;

2.5 联接：join

　　联接运算创建数据源中没有显式建模的序列之间的关联。例如，您可以执行联接来查找位于同一地点的所有客户和经销商。在 LINQ 中，join 子句始终针对对象集合而非直接针对数据库表运行。

1     var innerJoinQuery = from cust in customers
2                      　　join dist in distributors on cust.City equals dist.City
3                      　　select new {CustomerName = cust.Name, DistributorName = dist.Name};

　　在 LINQ 中，join 子句始终针对对象集合而非直接针对数据库表运行。

　　在 LINQ 中，您不必像在 SQL 中那样频繁使用 join，因为 LINQ 中的外键在对象模型中表示为包含项集合的属性。

    from order in Customer.Orders...

2.6 选择（投影）：select

　　select 子句生成查询结果并指定每个返回的元素的“形状”或类型。

　　例如，您可以指定结果包含的是整个 Customer 对象、仅一个成员、成员的子集，还是某个基于计算或新对象创建的完全不同的结果类型。当 select 子句生成除源元素副本以外的内容时，该操作称为“投影”。

三、使用 LINQ 进行数据转换

　　语言集成查询 (LINQ) 不仅可用于检索数据，而且还是一个功能强大的数据转换工具。通过使用 LINQ 查询，您可以将源序列用作输入，并采用多种方式修改它以创建新的输出序列。您可以通过排序和分组来修改该序列，而不必修改元素本身。但是，LINQ 查询的最强大的功能是能够创建新类型。这一功能在 select 子句中实现。 例如，可以执行下列任务：

3.1 将多个输入联接到一个输出序列

 1     class Student
 2     {
 3         public string Name { get; set; }
 4
 5         public int Age { get; set; }
 6
 7         public string City { get; set; }
 8
 9         public List<int> Scores { get; set; }
10     }
11
12     class Teacher
13     {
14         public int Id { get; set; }
15
16         public string Name { get; set; }
17
18         public int Age { get; set; }
19
20         public string City { get; set; }
21
22     }

 1     internal class Program
 2     {
 3         private static void Main(string[] args)
 4         {
 5             //创建第一个数据源
 6             var students = new List<Student>()
 7             {
 8                 new Student()
 9                 {
10                     Age = 23,
11                     City = "广州",
12                     Name = "小C",
13                     Scores = new List<int>(){85,88,83,97}
14                 },
15                 new Student()
16                 {
17                     Age = 18,
18                     City = "广西",
19                     Name = "小明",
20                     Scores = new List<int>(){86,78,85,90}
21                 },
22                 new Student()
23                 {
24                     Age = 33,
25                     City = "梦里",
26                     Name = "小叁",
27                     Scores = new List<int>(){86,68,73,97}
28                 }
29             };
30
31             //创建第二个数据源
32             var teachers = new List<Teacher>()
33             {
34                 new Teacher()
35                 {
36                     Age = 35,
37                     City = "梦里",
38                     Name = "啵哆"
39                 },
40                 new Teacher()
41                 {
42                     Age = 28,
43                     City = "云南",
44                     Name = "小红"
45                 },
46                 new Teacher()
47                 {
48                     Age = 38,
49                     City = "河南",
50                     Name = "丽丽"
51                 }
52             };
53
54             //创建查询
55             var peopleInDreams = (from student in students
56                             where student.City == "梦里"
57                             select student.Name)
58                             .Concat(from teacher in teachers
59                                     where teacher.City == "梦里"
60                                     select teacher.Name);
61
62             //执行查询
63             foreach (var person in peopleInDreams)
64             {
65                 Console.WriteLine(person);
66             }
67
68             Console.Read();
69         }
70     }

　　

3.2 选择各个源元素的子集

　　1. 若要只选择源元素的一个成员，请使用点运算。

1     var query = from cust in Customers
2                     select cust.City;

　　2. 若要创建包含源元素的多个属性的元素，可以使用具有命名对象或匿名类型的对象初始值设定项。

1     var query = from cust in Customer
2                    select new {Name = cust.Name, City = cust.City};

3.3 将内存中的对象转换为 XML

 1             //创建数据源
 2             var students = new List<Student>()
 3             {
 4                 new Student()
 5                 {
 6                     Age = 18,
 7                     Name = "小A",
 8                     Scores = new List<int>() {88,85,74,66 }
 9                 },
10                 new Student()
11                 {
12                     Age = 35,
13                     Name = "小B",
14                     Scores = new List<int>() {88,85,74,66 }
15                 },
16                 new Student()
17                 {
18                     Age = 28,
19                     Name = "小啥",
20                     Scores = new List<int>() {88,85,74,66 }
21                 }
22             };
23
24             //创建查询
25             var studentsToXml = new XElement("Root",
26                 from student in students
27                 let x = $"{student.Scores[0]},{student.Scores[1]},{student.Scores[2]},{student.Scores[3]}"
28                 select new XElement("student",
29                 new XElement("Name", student.Name),
30                 new XElement("Age", student.Age),
31                 new XElement("Scores", x))
32             );
33
34             //执行查询
35             Console.WriteLine(studentsToXml);

3.4 对源元素执行操作

　　输出序列可能不包含源序列的任何元素或元素属性。输出可能是通过将源元素用作输入参数计算出的值的序列。

 1             //数据源
 2             double[] radii = {1, 2, 3};
 3
 4             //创建查询
 5             var query = from radius in radii
 6                 select $"{radius * radius * 3.14}";
 7
 8             //执行查询
 9             foreach (var i in query)
10             {
11                 Console.WriteLine(i);
12             }

　　【备注】$"{radius * radius * 3.14}" 相当于 string.Format("{0}",radius * radius * 3.14)，这里采用的是 C# 6.0 的语法。

四、LINQ 查询操作的类型关系

　　LINQ 查询操作在数据源、查询本身及查询执行中是强类型的。查询中变量的类型必须与数据源中元素的类型和 foreach 语句中迭代变量的类型兼容。强类型可以保证在编译时捕获类型错误，以便及时改正。

4.1 不转换源数据的查询

　　下图演示不对数据执行转换的 LINQ to Objects 查询操作。源包含一个字符串序列，查询输出也是一个字符串序列。

　　①数据源的类型参数决定范围变量的类型。

　　②选择的对象的类型决定查询变量的类型。此处的 name 为一个字符串。因此，查询变量是一个 IEnumerable<字符串>。

　　③在 foreach 语句中循环访问查询变量。因为查询变量是一个字符串序列，所以迭代变量也是一个字符串。

4.2 转换源数据的查询

　　下图演示对数据执行简单转换的 LINQ to SQL 查询操作。查询将一个 Customer 对象序列用作输入，并只选择结果中的 Name 属性。因为 Name 是一个字符串，所以查询生成一个字符串序列作为输出。

　　①数据源的类型参数决定范围变量的类型。

　　②select 语句返回 Name 属性，而非完整的 Customer 对象。因为 Name 是一个字符串，所以 custNameQuery 的类型参数是 string，而非Customer。

　　③因为 custNameQuery 是一个字符串序列，所以 foreach 循环的迭代变量也必须是 string。

　　下图演示另一种转换。select 语句返回只捕获原始 Customer 对象的两个成员的匿名类型。

　　①数据源的类型参数始终为查询中的范围变量的类型。

　　②因为 select 语句生成匿名类型，所以必须使用 var 隐式类型化查询变量。

　　③因为查询变量的类型是隐式的，所以 foreach 循环中的迭代变量也必须是隐式的。

4.3 让编译器推断类型信息

　　您也可以使用关键字 var，可用于查询操作中的任何局部变量。但是，编译器为查询操作中的各个变量提供强类型。

五、LINQ 中的查询语法和方法语法

　　我们编写的 LINQ 查询语法，在编译代码时，CLR 会将查询语法转换为方法语法。这些方法调用标准查询运算符的名称类似 Where、Select、GroupBy、Join、Max和 Average，我们也是可以直接使用这些方法语法的。

　　查询语法和方法语法语义相同，但是，许多人员发现查询语法更简单、更易于阅读。某些查询必须表示为方法调用。例如，必须使用方法调用表示检索元素的数量与指定的条件的查询。还必须使用方法需要检索元素的最大值在源序列的查询。System.Linq 命名空间中的标准查询运算符的参考文档通常使用方法语法。

5.1 标准查询运算符扩展方法

 1         static void Main(string[] args)
 2         {
 3             var nums = new int[4] { 1, 2, 3, 4 };
 4
 5             //创建查询表达式
 6             var qureyNums = from n in nums
 7                             where n % 2 == 0
 8                             orderby n descending
 9                             select n;
10
11             Console.WriteLine("qureyNums:");
12             foreach (var n in qureyNums)
13             {
14                 Console.WriteLine(n);
15             }
16
17             //使用方法进行查询
18             var queryNums2 = nums.Where(n => n % 2 == 0).OrderByDescending(n => n);
19
20             Console.WriteLine("qureyNums2:");
21             foreach (var n in queryNums2)
22             {
23                 Console.WriteLine(n);
24             }
25
26             Console.Read();
27         }

　　两个示例的输出是相同的。您可以看到两种形式的查询变量的类型是相同的：IEnumerable<T>。

　　若要了解基于方法的查询，让我们进一步地分析它。注意，在表达式的右侧，where 子句现在表示为对 numbers 对象的实例方法，在您重新调用该对象时其类型为 IEnumerable<int>。如果您熟悉泛型 IEnumerable<T> 接口，那么您就会了解，它不具有 Where 方法。但是，如果您在 Visual Studio IDE 中调用 IntelliSense 完成列表，那么您不仅将看到 Where 方法，而且还会看到许多其他方法，如 Select、SelectMany、Join 和Orderby。下面是所有标准查询运算符。

　　尽管看起来 IEnumerable<T> 似乎已被重新定义以包括这些附加方法，但事实上并非如此。这些标准查询运算符都是作为“扩展方法”实现的。

5.2 Lambda 表达式

　　在前面的示例中，通知该条件表达式 (num % 2 == 0) 是作为内联参数。Where 方法：Where(num => num % 2 == 0) 此内联表达式称为lambda 表达式。将代码编写为匿名方法或泛型委托或表达式树是一种便捷的方法，否则编写起来就要麻烦得多。=> 是 lambda 运算符，可读为“goes to”。运算符左侧的 num 是输入变量，与查询表达式中的 num 相对应。编译器可推断 num 的类型，因为它了解 numbers 是泛型 IEnumerable<T> 类型。lambda 表达式与查询语法中的表达式或任何其他 C# 表达式或语句中的表达式相同；它可以包括方法调用和其他复杂逻辑。“返回值”就是表达式结果。

5.3 查询的组合性

　　在上面的代码示例中，请注意 OrderBy 方法是通过在对 Where 的调用中使用点运算符来调用的。Where 生成筛选序列，然后 Orderby 通过对该序列排序来对它进行操作。因为查询会返回 IEnumerable，所以您可通过将方法调用链接在一起，在方法语法中将这些查询组合起来。这就是在您通过使用查询语法编写查询时编译器在后台所执行的操作。并且由于查询变量不存储查询的结果，因此您可以随时修改它或将它用作新查询的基础，即使在执行它后。

传送门

　　入门：《走进 LINQ 的世界》

　　进阶：《LINQ 标准查询操作概述》（强烈推荐）

　　技巧：《Linq To Objects - 如何操作字符串》 和 《Linq To Objects - 如何操作文件目录》

本文首联：http://www.cnblogs.com/liqingwen/p/5832322.html

【参考】https://msdn.microsoft.com/zh-cn/library/bb397897(v=vs.100).aspx 等

【来源】本文引用部分微软官方文档的图片

移除Excel工作表密码保护小工具含C#源代码

2018-11-07 19:44 by zhoujie, 61 阅读, 0 评论, 收藏, 编辑

有朋友发了个Excel.xlsx文件给我，让我帮忙看看里面是怎么做出来的。打开审阅后发现，每个Excel工作表都添加了密码保护：

看不到里面的隐藏列和公式等等，感觉很神秘。于是研究了一下Excel文件的格式，做了一个解除工作表密码的小程序：

原理很简单：.

xlsx文件其实是一个zip压缩文件，而每个文件都是xml格式。微软专门提供了SDK，我是直接用DotNetZip操作的，移除每个工作表的加密节点即可。

获取工具和源代码

腾讯QQ会员中心g_tk32算法【C#版】

 

最近用C#写qq活动辅助类程序，碰到了会员签到的gtk算法不一样，后来网上找了看，发现有php版的（https://www.oschina.net/code/snippet_1378052_48831）

后来参考了php版的查php相关的资料用C#写了一个：

 /// <summary>
        /// 计算gtk32值
        /// </summary>
        /// <param name="skey"></param>
        /// <returns></returns>
        public static string GetGTK32(string skey)
        {
            var hash = 5381;
            var md5Key = "tencentQQVIP123443safde&!%^%1282";
            var start = hash << 5;
            var result = string.Empty;
            for (int i = 0; i < skey.Length; i++)
            {
                var ascode = CharToASCII(skey.Substring(i, 1));
                result += (hash << 5) + ascode;
                hash = ascode;
            }
            var str = start + (result + md5Key);
            return GetMD5(str);
        }

        /// <summary>
        /// MD5加密
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public static string GetMD5(string text)
        {
            StringBuilder sb = new StringBuilder();
            using (MD5 md5 = MD5.Create())
            {
                byte[] md5Byte = md5.ComputeHash(Encoding.Default.GetBytes(text));
                for (int i = 0; i < md5Byte.Length; i++)
                {
                    sb.Append(md5Byte[i].ToString("x2"));
                }
            }
            return sb.ToString();
        }

        /// <summary>
        /// /*字符转化为ASCII*/
        /// </summary>
        /// <param name="character"></param>
        /// <returns></returns>
        static int CharToASCII(string character)
        {
            ASCIIEncoding asciiEncoding = new ASCIIEncoding();
            int intAsciiCode = asciiEncoding.GetBytes(character)[0];
            return intAsciiCode;
        }

另附上解析cookie中的skey和p_skey方法和gtk算法：

        /// <summary>
        /// 解析cookie,取到Skey
        /// </summary>
        /// <param name="cookies">腾讯QQ cookie</param>
        /// <returns></returns>
        public static string GetSkey(string cookies)
        {
            #region 字符串分割解析
            //var keyStr = "skey=";
            //var index = cookies.IndexOf(keyStr) + keyStr.Length;
            //var skey = cookies.Remove(0, index);
            //if (skey.Contains(";") && skey.Length > 10)
            //{
            //    var laindex = cookies.IndexOf(";");
            //    skey = skey.Remove(10);
            //}
            #endregion
            var skey = Regex.Match(cookies, "skey=(.){10}?").Value.Remove(0, 5);
            if (skey.Length > 10)
            {
                skey.Remove(10);
            }
            return skey;
        }

        /// <summary>
        /// 解析cookie,取到p_skey
        /// </summary>
        /// <param name="cookies">腾讯QQ cookie</param>
        /// <returns></returns>
        public static string Getp_skey(string cookies)
        {
            return Regex.Match(cookies, "p_skey=(.)+?_").Value.Remove(0, 7);
        }

        /// <summary>
        /// 算出g_tk
        /// </summary>
        /// <param name="sKey">cookie中的sKey值</param>
        /// <returns></returns>
        public static string GetGTK(string sKey)
        {
            var hash = 5381;
            for (int i = 0, len = sKey.Length; i < len; ++i)
            {
                hash += (hash << 5) + sKey[i];
            }
            return (hash & 0x7fffffff).ToString();
        }