博客园_不断的谦逊，不断的努力

常见充值方式介绍及对比

2012-05-29T03:29:00Z

1：银联充值

1：环境部署

安装NetPay4NTSetup.exe，将MerPrk.key和PgPubk.key两个文件放到C:\WINDOWS目录下，环境部署完成了。

2：程序中要注意的问题

最容易导致问题的就是生成加密串，这个加密功能是由银联提共的，调用Interop.CHINAPAYLib.dll中类CHINAPAYLib.NetPayClientClass的sign方法，由于这是对字符串进行加密，不同的字符串加密后的串是不一样的，所以要注意被加密字符前后是否有多余的空格，支付金额的位数，如果加密串生成有误，到银联那边肯定报参数有误的。充值成功后就是回调解密，解密调用的是CHINAPAYLib.NetPayClientClass的check方法，返回“0”表示成功，其他值表示失败。充值成功才能进行转点和发奖。

3：还要注意的一个问题是充值金额

充值金额是一个12位的字符串，以分作为单位，如000000001000表示10元，不能提交0元的订单。

4：银联订单的大致流程：用户提交一个订单，将部分参数的值加在一起，按照一定的方式加密，将结果和其他参数POST到银联的指定地址，银联会对参数进行验证，如果验证通过则认为是合法的订单，用户可以开始支付，支付成功之后，银联会对两个地址发送请求，一个地址是前台显示页面（告诉用户支付成功），另一个页面则是逻辑功能页面，把用户买的东西给他，先还是验证订单是否合法，进一步确认用户是否已经支付，支付成功后就把东西给用户。并告诉银联已经把东西给用户了，如果出现问题，银联会隔一段时间再次发送请求，时间间隔会越来越大，一定时间过来不再发送请求，有时候银联那边也会出现问题，用户的钱扣了，但是没有向我们指定的页面发送请求，就只能联系银联让他们退钱，所有的支付流程大致都是这样的，只是不同的支付方式验证不一样。

验证无非3种：

1：参数验证，参数的格式验证，加密串是否匹配

2：IP验证，只有双方约定的IP才能访问

3：订单的验证，验证订单是否支付

1是必验证的，2||3=true就可，就怕为false，那样真的很不安全

2：快钱充值

1：环境部署

环境就是为了解决加密解密问题。登录公司在快钱的账号，按照相关提示可以生成一个加密问题和一个解密问题，解密文件要上传到快钱上，因为我们加密后传过去的字符串他们要解密验证。我们的程序只用调用这个两个文件，生成订单的时候要调用加密文件，回调的时候要调用解密文件，这两个文件建议放在C盘的一个目录中，把他们的路径配在配置文件中共程序调用。IP验证是必须的，只能让指定的IP访问就安全多了，如果哪个牛人能突破IP的限制，或者构造虚假的IP，那就真的可以横冲直撞了。

2：生成加密串注意的问题

所有的参数都是先放到Dictionary中的，然后生成一个字符串，参数加入dictionary中的顺序千万不能改，改了就是不同的字符串了，加密后的字符串当然是不一样的。总之要确保加密和解密的参数的顺序是一样的。

3：还要注意的一个问题是充值金额

充值金额没有位数的限制，以分为单位，如1000表示10元，左边不能补0

3：支付宝

支付宝不需要环境的支持。参数用MD5加密，为了确保安全，在回调页还要向支付宝发送一个请求，验证订单是否支付，参数的顺序是按照参数的名字排序的，所以用的是SortedDictionary集合。

注意：所有的参数都要放到集合当中，哪怕是提交按钮，所以提交按钮最好不要设置name属性。这一点也是支付宝最坑爹的，我猜它是将所有参数按照参数名称排序并串联，然后加密的，你的POST参数多了或者少了参数，哪怕是无关没用的参数都会导致加密串验证失败。当然这样做也好处，不用管参数的串联顺序，不像其他的充值方式，非要A参数必须在B参数的前面。

支付宝支付能确保支付的安全性主要是在回调页面还要去支付宝验证订单是否支付，当然还会验证订单的关联是否正确，不然还是有漏洞。

4：神州行和联通卡

没有任何特殊，所以注意的地方比较少，确保被加密的参数顺序不变，即参数的顺序是定的，不能改变。参数MD5加密。解密也是最简单的，加密的时候MD5一次，解密的时候在把参数MD5一下，两次MD5结果一样表示已经支付，相比上面几种支付方式，它是最不安全的。虽然回调页面有一个IP限制。要是没有这个限制那真的是彻底将接口暴露了，只要会点程序的人，都能很容易写一个东西去攻击了，不用付钱就能得到你想要的东西。

5：V币支付

V币支付同样没有任何特殊的地方，MD5验证，跟神州行和联通卡类似。

6：骏卡支付

骏卡支付跟其他支付方式不一样的地方时我们提供接口，供骏卡那边调用，由于这个接口是公开的，所以做了IP限制，只有骏卡那边提供的IP才能访问这个接口。验证也是MD5加密验证。

流程：用户在骏卡的网站上提交一个订单，然后骏卡会向我们的接口发送一个请求，我们就给用户转一定的点数，然后输出结果。然后骏卡那边会扣用户的骏点。

网络支付最常用的支付方式一般是：银联支付、块钱支付、支付宝。当然还有其他的支付方式。我觉得这三种支付方式是相对比较安全的。银联和块钱都有自己的加密解密方式，而且用户也不知道哪些参数是加密串的一部分，参数的顺序也是未知的；支付宝虽然是MD5加密，但会在回调页面验证订单是否支付，保证了安全性。

写着写着发现还是很能存在漏洞，不敢多说了。真要把网站写得很安全真不是简单的事情，要考虑的方面还真的比较多，特别是涉及到支付、提交数据的地方。比如A页面向B页面发送一个请求，B页面向数据库中插入数据，如果没有在B页面中做有效验证，任何程序员就可以花不到半个小时的时间写一个小东西，向B页面不断的提交数据，很容易就把数据库给弄爆了。所以最好别得罪程序员，特别是牛B的程序员。

作者：陈太汉

博客：http://www.cnblogs.com/hlxs/

本文链接

C#基础知识

2012-05-18T03:33:00Z

1：JIT（即时编译）。一个方法在第一次调用时JIT会把改方法的IL代码转换成CPU指令，再次调用该方法时就只需执行对应的指令。方法第一次被调用的过程大致是：1获得方法的IL代码；2：分配内存；3：将IL代码转换成CPU指令存在2分配的内存中；4：将方法表中对应该方法的指针指向2分配的内存；5：跳转到2分配的内存执行其中的指令，即该方法的CPU指令。

2：as的性能高于is。Is的作用是判断当前类型与目标类型是否兼容，即是否是同一类型或者目标类型是当前类型的父类型。强制类型转换也要判断类型的兼容性，如果不兼容就抛出一个类型转换异常，如果你的代码类型转换用Is+强制类型转换就做了两次兼容性判断，而as只有一次类型转换。

3：C#中的int对应FCL中的Int32，.net Framework 64中int对应FCL中的int64，int到底对应Int32还是Int64重要吗？不重要，那是.net Framework的事，或者说这他妈是CPU的事，同一类型，64位CPU所需存储的空间是32位CPU的2倍。

4：string是引用类型，常量字符串都存在字符串池中，如果一个字符串在代码中多次出现，那么这些都是对字符串池的引用，string s="a"+"b";只分配了一次内存，编译器会直接将其编译成string s="ab";s是对字符串池中ab的引用。

5：大量字符串的拼接用StringBuilder，少量则用字符串相加，能用+=则更好，string.format的效率是低下的，它的内存其实是params object[] +StringBuilder，params也是低效的，字符串相加，或是取其中的一部分都是要重新分配内存，然后将对应的字符串存入。FCL大部分代码都是用C#写的，而操作字符串这一块用的是非托管代码写的，处于对性能的考虑。

6：别看到new就以为会在托管堆中分配内存，值类型的变量就是分配中线程栈上的，结构体虽然可以用new，但是编译器推断出它是值类型，就会按照值类型的处理，当然IL代码中是没有newobj指令的。

7：静态类被编译成sealed abstract类型，所以他不能被继承，不能被实例化，所以他的属性和方法都是属于类型的，没有属于对象的，它必须直接继承Object。

8：const和readOnly的区别，IL代码中存的是const变量的值，而不是引用，所以修改是不可能的，如果一个DLL只引用了另一个DLL中的一个const变量，那么这个DLL是不会被引用的，因为编译的时候就知道变量的值了，所以在运行的时候也不会分配内存，readonly表示你不能修改它的指向，但是可以修改它所指向变量的值。

9：泛型，C#中的泛型和C++的模版区别在于引用类型，C++模版会每一种类型都会生成一个新的类型，而C#泛型中，引用类型用的是同一个类型，只有值类型用的是不同的类型。因为引用都是一个指针的引用，而值类型存储所需的空间是不同的。

其他基础知识，请看这篇博客：这些天写的技术微博

作者：陈太汉

博客：http://www.cnblogs.com/hlxs/

本文链接

软件随想--写牛B的代码

2012-05-16T06:43:00Z

1：写不易出错的代码

第一次听说“写明显没有什么错误的代码”时，我觉得这个说法很新鲜，让我记忆深刻。其他的很多观点听得我耳朵生茧，基本都是左耳进右耳出。明显没有什么错了的代码肯定是思路清晰、很容易理解的。而要做到这点很难，牛人才能写出牛叉的代码，要做到这一点要有足够的阅历和实战，只能当做目标啦，哪天也和云风一样：今天完成了XX功能，代码明显没有什么错误。现在还不知道明显没有什么错误的代码是怎么样的，但我知道很多代码让我半天不知所云。如从类名和方法名看不出其职能；变量命名让人蛋疼；不对参数做任何验证；参数到处都是都是基本类型；方法参数十几个；一个方法几屏；不能适应半点变化的方法；要么没有注释，要么一堆废话；排版稀烂。这些都是不好理解，半天找不到问题的代码，也是容易出错的代码。

2：写容易查错的代码

一直想写很干净的代码，代码除了功能没有多余的代码，但是代码必须有日志，如果代码没有日志，要是出错了，查错肯定很麻烦，有时候真的是无从下手，一个功能涉及到一堆的模块，要想很快的定位错误，就必须记好日志。越清楚越好，程序执行到哪一步，当前的状态最好都要记下来，日志不在多，清楚记录有效的日志非常重要，过多无效的日志不方便查看，而且对于快速定位错误的位置没有任何帮助。如果日志都记录在文本文件中，最好能写一个分析日志的工具。可能是我写的和维护的代码太容易出错了，个人觉得记好日志真他妈重要。一看到日志就能知道出了什么问题那不是一般的爽，当然听说又出问题了让人郁闷。我以前所在的一家公司记录日志的方式是在很多类中都定义一个int类型的成员变量，每隔几行让它自增1，将这个值记录起来，当出错了就能大致估计是哪几行出错了。这种方法虽然有点蹩脚，代码中到处是这个变量，但的确能帮助我们快速定位错误的位置，日志的作用就是保存案发现场，只有记录犯罪分子作案的过程才能更好的抓住它。

3：写扩展性好的代码

“今天说要这样，明天说要那样，在上线的前一天说：还是觉得开始的做法是最好的”。而我们程序员总是为这种人2B的想法买单。写扩展性好的代码真的就是不仅要满足需求还要超越需求。我们到处可以听到这样的口号，当然很多情况下是这样的人自己都不知道需求是什么。最让人无语的是菜鸟提需求，我来实现。杀了我吧。但现实是杀了我之前我先要满足他的需求。当这种需求像滔滔江水绵延不绝的袭来时，我想到了四个字：生不如死。既然死不了，生活还得继续。代码还是要做到超越需求（你说这世界对程序员要求怎么就这么高呢），要做到这点难啊，我们是帮别人实现梦想的开拓者。前途是光明的，道路是坎坷的，现实是残酷的，代码必须是扩展性好的。当然这里所说都是人为因素。

还有就是项目的需求本来就是变化的，或者说你现在完成的是一期，还有二期，三期......，你在做的时候就必须考虑这些情况，不要把代码写死。我以前总是想：这个可能以后不会变化，可以写死，少一个参数，少一个变量性能会更好写。其实性能的提升相当于一个千万富翁突然多了几毛钱。但是要是以后需求变了，你就得改写代码，还得担心是否会出问题。有时候我就有点怕重构，就怕一个好的功能，被重构坏了，当然也和时间紧，测试不专业有关。写扩展性好的代码别在乎所谓的那点性能，那真的就是九牛一毛不值一提。一个项目维护时间久了，发现那些本来看是不变的很多都变了，而代码也被改了很多次，每一次修改就要做一堆本来没有必要的事情（修改代码，写测试说明，送测，协调上线，而这些沟通时间也不少，真叫一个低效浪费时间），如果能考虑到可能发生的变化，写好代码，效率会高很多，这一点就能体现高手和菜鸟的区别。

4：写高性能的代码

这是我一直渴望的（我当然也会说是我还没有做到的）。我觉得要写出高效的代码首先要非常明白你要实现的功能，将功能分析得很透彻，你找到了解决方案，回想你的实现，如果你的思路非常清晰，你就大致知道每一步是否够好，大致知道你的代码是否高效，或者更进一步说，你确定这就是最优解；如果功能实现了，但是你对自己实现的功能不是很了解，记忆模糊，那肯定不是最优解，你肯定会对自己不是很清楚的代码不放心（我经常是这样），就别谈性能，是否正确都待定。很多高效的代码都很简洁，容易理解，而有些代码总让人看起来很郁闷，如一堆看起来类似的代码实现一个很简单的功能。用数组和一个循环经常能将这样的代码简化，让你轻松实现简洁容易理解的代码，或许它不是最高效的。82法则告诉我们，我们应该对影响系统性能的20%的代码进行优化，而不应对其他的80%的代码耿耿于怀。20%影响性能的代码应注重性能进行优化，而其他80%则更多应该考虑理解性，扩展性等。

高手的代码特点有很多，很多优点是并存的。上面只是我个人认为最重要的四点。

顺便说一句：蛋扯多了才能扯得更好。

软件随想上一篇：http://www.cnblogs.com/hlxs/archive/2012/03/03/2378249.html

作者：陈太汉
博客：http://www.cnblogs.com/hlxs/

本文链接

三道简单的算法题

2012-05-08T06:20:00Z

好久没有做算法题了，重温几个简单的算法题。
第一题：求子数组的最大和
这是一道很常见的算法题，很多人都能很快的写出算法，但很多人都不能写得完全正确，问题主要出在sum初始化上，
很多错误的答案将他初始化为0，如果数组的所有元素都为负，那么得到的最大最是0，sum要初始化成数组的第一个元素。

第二题：求1+2+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字以及条件判断语句
这道题在网上也有很多个版本，有在构造函数中实现加法，利用两个静态变量一个存结果，一个存当前值，然后创建一个一维n个元素的数组，存结果的静态变量即为所求，
还有的就是用两个方法，一个方法是递归的，另一个值返回常量值0，就是把递归中的判断改成了一个返回值始终是0的方法。
我要说的是第三者方法：利用模板和关键字inline，编译后的结果就是：1+2+...+n，不会生成一堆方法的调用，因为将方法定义成了inline。

第三题：输入一颗二元树，从上往下按层打印树的每个结点，同一层中按照从左往右的顺序打印。
这道题主要用上了队列的思想，先进先出，因为我们很容易实现以层的顺序将二叉树中的元素插入队列，
先将根节点插入队列，每个节点出队列的同时将其子节点加入队列。打印出队列的节点。

//求子数组的最大和
int maxSum(int* arr,int len)
{
int sum,max;
sum=max=arr[0];
for(int i=1;i<len;i++)
{
if(sum<=0)
{
sum=arr[i];
}else{
sum+=arr[i];
}
if(sum>max)
{
max=sum;
}
}
return max;
}

//求1+2+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字以及条件判断语句
template<int n> inline int Sum(int m)
{
return Sum<n-1>(m-1)+m;
}

template<> inline int Sum<1>(int m)
{
return 1;
}

template<> inline int Sum<0>(int m)
{
return 0;
}

//第三题：输入一颗二元树，从上往下按层打印树的每个结点，同一层中按照从左往右的顺序打印。
class PrintByFloor
{
public:
struct Node
{
int value;
Node* left;
Node* right;
Node(int val):value(val),left(NULL),right(NULL){}
};

PrintByFloor():root(new Node(-1)){}

~PrintByFloor(){
MakeEmpty(root);
}

void Print()
{
if(root==NULL)
{
return;
}
queue<Node*> queue;
if(root->left!=NULL){
queue.push(root->left);
}else
{
queue.push(root->right);
}
while(queue.size())
{
Node* cur=queue.front();
cout<<cur->value<<"\t";
if(cur->left!=NULL)
{
queue.push(cur->left);
}
if(cur->right!=NULL)
{
queue.push(cur->right);
}
queue.pop();
}
}

Node* Add(int value,Node *t)
{
if(t==NULL)
{
t=new Node(value);
}else if(value<t->value)
{
if(t->left==NULL)
{
t->left=new Node(value);
}else{
return Add(value,t->left);
}
}else if(value>t->value)
{
if(t->right==NULL)
{
t->right=new Node(value);
}else{
return Add(value,t->right);
}
}

return t;
}

Node* Add(int value)
{
return Add(value,root);
}

private :
void MakeEmpty(Node *t)
{
if(t!=NULL)
{
MakeEmpty(t->left);
MakeEmpty(t->right);
delete t;
t=NULL;
}
}

Node *root;

};

测试代码如下：

//测试代码
int main() {
int arr[]={1,-3,5,5,-6,-2,-7};
int maxValue=maxSum(arr,sizeof(arr)/sizeof(arr[0]));
cout<<maxValue<<endl;

{
PrintByFloor floor;
floor.Add(8);
floor.Add(6);
floor.Add(5);
floor.Add(7);
floor.Add(11);
floor.Add(9);
floor.Add(12);
floor.Add(10);
floor.Add(3);
floor.Print();
}
cout<<endl;
int sum=Sum<100>(100);
cout<<sum<<endl;
getchar();
return 0;
}

结果截图：

作者：陈太汉

博客：http://www.cnblogs.com/hlxs/

本文链接

提高SQL查询效率

2012-05-07T03:09:00Z

转载：http://panyi5202.iteye.com/blog/612414

1.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。

2.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：
select id from t where num is null
可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：
select id from t where num=0

3.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。

4.应尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：
select id from t where num=10 or num=20
可以这样查询：
select id from t where num=10
union all
select id from t where num=20

5.in 和 not in 也要慎用，否则会导致全表扫描，如：
select id from t where num in(1,2,3)
对于连续的数值，能用 between 就不要用 in 了：
select id from t where num between 1 and 3

6.下面的查询也将导致全表扫描：
select id from t where name like '%abc%'
若要提高效率，可以考虑全文检索。

7.如果在 where 子句中使用参数，也会导致全表扫描。因为SQL只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。如下面语句将进行全表扫描：
select id from t where num=@num
可以改为强制查询使用索引：
select id from t with(index(索引名)) where num=@num

8.应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：
select id from t where num/2=100
应改为:
select id from t where num=100*2

9.应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：
select id from t where substring(name,1,3)='abc'--name以abc开头的id
select id from t where datediff(day,createdate,'2005-11-30')=0--‘2005-11-30’生成的id
应改为:
select id from t where name like 'abc%'
select id from t where createdate>='2005-11-30' and createdate<'2005-12-1'

10.不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。

11.在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。

12.不要写一些没有意义的查询，如需要生成一个空表结构：
select col1,col2 into #t from t where 1=0
这类代码不会返回任何结果集，但是会消耗系统资源的，应改成这样：
create table #t(...)

13.很多时候用 exists 代替 in 是一个好的选择：
select num from a where num in(select num from b)
用下面的语句替换：
select num from a where exists(select 1 from b where num=a.num)

14.并不是所有索引对查询都有效，SQL是根据表中数据来进行查询优化的，当索引列有大量数据重复时，SQL查询可能不会去利用索引，如一表中有字段sex，male、female几乎各一半，那么即使在sex上建了索引也对查询效率起不了作用。

15.索引并不是越多越好，索引固然可以提高相应的 select 的效率，但同时也降低了 insert 及 update 的效率，因为 insert 或 update 时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况而定。一个表的索引数最好不要超过6个，若太多则应考虑一些不常使用到的列上建的索引是否有必要。

16.应尽可能的避免更新 clustered 索引数据列，因为 clustered 索引数据列的顺序就是表记录的物理存储顺序，一旦该列值改变将导致整个表记录的顺序的调整，会耗费相当大的资源。若应用系统需要频繁更新 clustered 索引数据列，那么需要考虑是否应将该索引建为 clustered 索引。

17.尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

18.尽可能的使用 varchar/nvarchar 代替 char/nchar ，因为首先变长字段存储空间小，可以节省存储空间，其次对于查询来说，在一个相对较小的字段内搜索效率显然要高些。

19.任何地方都不要使用 select * from t ，用具体的字段列表代替“*”，不要返回用不到的任何字段。

20.尽量使用表变量来代替临时表。如果表变量包含大量数据，请注意索引非常有限（只有主键索引）。

21.避免频繁创建和删除临时表，以减少系统表资源的消耗。

22.临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件，最好使用导出表。

23.在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果数据量不大，为了缓和系统表的资源，应先create table，然后insert。

24.如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。

25.尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该考虑改写。

26.使用基于游标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题，基于集的方法通常更有效。

27.与临时表一样，游标并不是不可使用。对小型数据集使用 FAST_FORWARD 游标通常要优于其他逐行处理方法，尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时间允许，基于游标的方法和基于集的方法都可以尝试一下，看哪一种方法的效果更好。

28.在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每个语句后向客户端发送 DONE_IN_PROC 消息。

29.尽量避免大事务操作，提高系统并发能力。

30.尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理

本文链接

C#成员初始化有点坑爹

2012-04-19T05:25:00Z

C#成员的初始化顺序你真的非常清楚吗，我发现有点坑爹，坑到爹突然有点搞不清楚什么状况。下面咱们开始分析，先看3个简单类。

public abstract class Base
{
public Base()
{
SetValue();
}
public abstract void SetValue();
}

public class Sub : Base
{
public string value;
public Sub()
{
value = "chentaihan";
}

public override void SetValue()
{
value = "陈太汉";
}
}

public class Sub1 : Base
{
public string value = "chentaihan";

public override void SetValue()
{
value = "陈太汉";
}
}

如果执行下面这段代码会输出什么值呢，请不要往下看，先给出你自己的答案。

static class Program
{
static void Main(string[] args)
{
Sub sub = new Sub();
Console.WriteLine(sub.value);
Sub1 sub1 = new Sub1();
Console.WriteLine(sub1.value);
Console.Read();
}
}

是的他很简单，但你确信你的答案就是对的吗？这么一个简单的问题我答错了，所以就有了这篇博客。 CLR VIA C#这本书告诉我们：成员在定义的时候初始化相当于在构造函数的最上面初始化，如果一个成员在定义的时候初始化，并在构造函数中赋值，那么在构造函数执行完成之后，该成员的值就是造函数中所赋的值，所以我得出的答案都是：chentaihan。但答案不是这样的。当运行结果出来时，我那个迷茫啊.....。

先来说说我的简单分析：

1：进入子类构造函数

2：Sub成员变量的内存被分配

3：调用父类构造函数

4：调用子类的方法SetValue(子类覆写了这个方法)，value被赋值

5：正式执行子类构造函数，成员变量value再次被赋值

从上面5步我得出他们输出的结果一样，都是chentaihan。错在哪里呢？

于是我用Reflector查看了一下，得到的结果正如上面所说，他们的源码是一样的，如下所示。正如CLR VIA C#这本书说的那样，那为什么结果不一样呢，Reflector代码是一样的，执行的结果却不一样，怎么回事，怎么回事，那我只能说Reflector坑爹，它不能反映程序的真正执行逻辑，非要我用IL，我用的还不熟呢。

public class Sub : Base
{
public string value;
public Sub()
{
value = "chentaihan";
}

public override void SetValue()
{
value = "陈太汉";
}
}

神马情况，他们的IL代码是不一样的，如图所示

看了这个图，我们知道答案是chentaihan,陈太汉。谁能告诉我怎么调用父类的构造函数和给value赋值的顺序不一样啊。该用的工具都用了，我该怎么证明这个结果，于是开始单步调试，于是发现了一个每天都发现了的秘密：成员初始化在构造函数之前执行。难怪这本书上说成员在定义的时候初始化相当于在构造函数的最上面初始化，Reflector也证实了这个答案。但是又绕进另一个坑爹的问题：构造函数还没有调用，内存还没有分配，怎么给成员变量赋值啊？这不是问题，从上图可以看出成员变量的赋值只是在父类的构造函数之前调用，肯定也是在子类的成员变量分配空间之后为成员变量赋值。好的，最后我们得出的结论是：

1：进入子类构造函数

2：Sub成员变量的内存被分配

3：为Sub成员变量赋值

4：调用父类构造函数

5：调用子类的方法SetValue(子类覆写了这个方法)，value被赋值

6：正式执行子类构造函数，成员变量value再次被赋值

同意以上观点的人请放过我，别吐槽，不同意的请留言

这样的解释答案就很合理，但同时也说明成员变量在定义的时候初始化和在构造函数中赋值的意义是不一样的，至少执行顺序不一样，产生的结果可能也不一样。

作者：陈太汉

博客：http://www.cnblogs.com/hlxs/

本文链接

C#内存管理与垃圾回收

2012-04-12T04:21:00Z

垃圾回收还得从根说起，就像生儿育女一样。

根：根是一个位置，存放一个指针，该指针指向托管堆中的一个对象，或是一个空指针不指向任何对象，即为null。根存在线程栈或托管堆中，大部分的跟都在线程栈上，因为定义的变量就存在线程栈上，类型对象指针存在托管堆中，因为实例化一个对象要额外分配两个字段“类型对象指针”和“同步块索引”。

类型对象指针的作用。实例化一个对象并没有为其方法分配内存，类型的静态字段分配内存，而实例要向调用属于类型的一些东西，就必须通过类型对象指针。如对象的实例是共用类型的方法，实例只需要通过类型对象指针调用类型的方法，更多关于方法的调用请看我的这篇博客。

同步块索引的作用。1：用于lock，使对象在同一时刻只能一个线程访问；2：用于获取对象的hashCode;3:在垃圾回收时标志某个对象是否是垃圾。关于lock最经典的一个例子就是单例了，大家的实现都是实例化一个object对象，然后锁住它，然后在判断是否要实例要实现单例的那个对象。我们为什么要实例化一个object，而不是直接lock(typeof(object))，那是因为这样会把object这个类型给锁住，锁住期间，任何使用线程使用lock(typeof(object))就必须等待，object还是可以正常使用。lock能起到单线程访问的原因是：它里面有一个空的for死循环，一直在读同步块索引中的一个位，如果这个位没有被标志跳出循环，如果被标志就一直执行循环，直到方法执行完成，其他线程就一直等待，现在你知道lock能使你的程序只能单线程反问也知道lock的效率低了吧。

NextObjPtr一个最牛B的指针。CLR中的所有资源都从托管堆中分配，托管堆是一块连续的内存空间，维护一个指针NextObjPtr，它指向上一个对象地址的后面，下一个对象的开始位置，若托管堆中没有对象就指向托管堆的开始位置，每分配一个对象就将NextObjPtr指向这个对象的后面，以准备开始分配下一个对象。NextObjptr指针移动的位置其实就是上一个对象所在空间的长度，从指向对象的开始位置改为对象的末尾吗。从哪里开始分配对象就全靠NextObjPtr啦。

实例化一个对象需要多少空间？对象的所有字段所需的内存+类型对象指针+同步块索引。关于类型对象指针和同步块索引的作用前面已经提过了。有些字段没有明显定义，但它确确实实存在，每个对象除了object的对象都有base字段，通过它可以调用父类的实例字段和方法，通过它你可以访问你爷爷的爷爷定义的字段和方法。CLR用递归的方式调用父类的方法，当然也要看，你爷爷是否愿意让你调用，原因你懂的。

在垃圾回收开始之前速度比C快。对象就这样开心的在托管堆中分配，托管堆的容量是有限的，总有一天第0代会满，容不下一粒沙子。垃圾回收就出场了，在垃圾回收出场之前，你使用内存很happy，当然速度是非常快，比C语言的速度还快，因为C的内存是随便分配，只要找到合适大小的区域，就在那里分配内存了，这样会导致内存碎片，有时需要一块大的内存，需要遍历多处。垃圾回收的时候日子就不是那么好过了。速度肯定比C慢了，看下面你就知道垃圾回收的时候，程序的速度为什么慢了。

垃圾回收分两步：1：标记；2：压缩

1：标记。在垃圾回收开始的时候，垃圾回收器视托管堆中的所有对象都为垃圾，即线程栈上没有指针指向托管堆。这样的估计是因为一个对象被视为垃圾就是它没有被引用，当垃圾回收开始的时候，垃圾回收器会沿着线程栈线性扫描，当线程栈上的一个变量引用了托管堆中的对象时，垃圾回收器就会将这个对象标记，即修改该对象同步块索引中的一个特定的位，同步块索引就是一个bit数组，每一个元素都有它特定的作用，上面就列出了我所知道的三个功能。被标记的对象也可能引用其他的对象，而被引用的对象同样会被标记，垃圾回收器是用递归的方式将这些对象一一标记的，一个对象可能会被多个对象引用，当垃圾回收器发现某个对象被标记时就会退出递归，因为再往下递归完全是多余，而且还可能出现死循环。

垃圾回收器就这样线性的扫描线程栈，递归的扫描托管堆，最后将托管堆中所有被引用的对象标记，而没有被标记的对象就是垃圾，等着被回收。

2：压缩。当垃圾被回收之后，就会出现磁盘碎片，那么就要对托管堆进行整理，即压缩。将没有被回收的对象放在一起，靠近托管堆开始的位置，将剩余的内存腾出空间来以便存放新的对象。由于压缩很多对象就会移动位置，而引用他们的指针都会变得无效，所以托管堆要修改所有指针的指向，以保证不会因为垃圾回收而让对象变得不可到达，指针变得无效。

压缩完了之后，又腾出了空间，又可以分配新的对象，当第0代满了之后又进行垃圾回收，垃圾回收就这样一直进行着，直到回收了3代还是没有内存可以分配，那就是弹尽粮绝的时候了，CLR会告诉你OutOfMemoryException。CLR的内存被的程序吃光了。更多关于代的信息，可以看我的这篇博客。在第0代满的时候就会进行垃圾回收，第0代回收完之后还是没有足够的内存存放当前对象就回收第1代，如果还是不够就回收第2代，够就不回收下一代，垃圾回收还可以用代码控制GC.Collect()。

更多关于内存管理和垃圾回收的内容，请等待我的下一篇博客。

作者：陈太汉

博客：http://www.cnblogs.com/hlxs/

本文链接

《重来》值得你多看几遍

2012-04-12T01:04:00Z

作者崇尚简约、见解独到、看法新颖、内容有点另类，却总让我产生共鸣，从中受到不少启发，看起来真是过瘾。原来书还可以这样写。有些可能不知不觉加上了我自己的观点，同一句话不同的人有不同的理解，可能会出现断章取义的情况，往你喜欢的方面想就好，这是唯一一本我在几天之内看了两遍的书，我想很多人也会喜欢，于是昨晚我把自己喜欢的内容整理了一下，形成这篇博客。希望对大家有帮助。

1. 哪来的从错误中学习－－别人的失败与你何干，别人挣的没花得多，那么，正好你来挣。你到底能从错误中学到什么？你能学到的只是不再重蹈覆辙，但这有什么意义呢？

2. 工作狂不是英雄，他们没有力挽狂澜，不过是浪费时间，真正的英雄早已想出办法、搞定一切，然后回家了。

3. 在宇宙中留下你的足迹－－你不必去攻克癌症，只要冲着有价值的方向努力，要让你的客户说：“这个东西让我的生活变美好了”，如果你不做这件事了，人们就会觉得不对劲。

4. 怎么样做出好的产品－－不需要核心团队、市场调研，也不需要经纪人，就像自己身上痒痒了，就自己挠挠。

5. 着手做点什么－－你脑袋中有eBay的创意和你实际去创建eBay那是一点关系都没有，你的人生中真正有意义的是你做过什么，而不是你想过什么或者计划过什么。

6. 时间不是借口－－你的终极职责就是让你自己的梦想成真

7. 干自己认为很酷的工作－－如果面包不新鲜，就做不出绝味的三明治，如果不能卖让自己倍儿有面子的食物，那赚再多的前又有什么意思呢？

8. 与其做一个半成品，不如做好半个好产品－－同时做N件事的结果就是：一大绝妙的点子最后被转化成一个蹩脚的产品，很多东西是越简单越好。

9. 关注不变因数－－时尚总会凋零，只有当你聚焦于长久的功能时，你才会发现你握住了永不落伍的东西。

10. 立马上线－－最有效的成功方法就是不断尝试，不要再臆测到底会发生什么事了，到现实中去找答案吧。

11. 退出的理由－－有时候放弃其实是一步好棋，即是你已经为之投入很多努力，也不要把打好的时间浪费在不值得做的事情上。

12. 会议有毒－－世界上最可恨的打扰莫过于开会，会议中总难免轮到那么一个低能人士发言，于是大家的时间都被浪费在他们的扯淡上。

13. 速战速决－－不要等太久，否则你的激情会被扼杀掉

14. 不要逞英雄－－很多时候知难而退比逞英雄实在，最糟糕的事莫过于继续浪费时间

15. 该睡觉时就睡觉－－人在困倦的时候，就是一个没有创意的顽固分子，执着于眼前错误的解决方案。

16. 养成对客户说不得习惯－－如果一味听顾客的，我就只能给他们弄一匹快马(亨利-福特)。不要相信“客户永远是对的” 这种废话。

17. 头脑发热不等于当务之急－－当你突然想到一个创意时，认为他非要不可，可能到第二天早上就觉得可有可无。

18. 关于广告－－广告做得再好也无法弥补一次糟糕的用户体验。

19. 普及知识赢得竞争－－传道授业能为你建立起凝聚力，这是传统市场策略不可望其项背的。

20. 没人喜欢朔料花－－不要害怕让人看到你的缺点，不完美才真实，真实才能激起人们的共鸣。

21. 关于市场营销－－如果你开的是一家餐馆，那么餐后的薄荷糖就是市场营销。

22. 一夜成名的传说－－在遇到伯乐之前，你得努力很长时间。

23. 简历－－我们都知道简历就是一个笑话。

24. 多年的无关经验－一个具有6个月工作经验的应聘者和一个具有6年工作经验的应聘者相比，其差别小的令人吃惊。真正的差别来自于个人的努力程度、性格差异以及智力水平。现在已经不是以长短论英雄的时候了，真正重要的是他们做了什么。

25. 常规教育不值一提－－我从不把我自己受过的正规学校教育等同于我的受教育程度（马克吐温）

26. 人人都得干活－－在小团队里不要招监工型的人，他们就是累赘。他们丢下自己的事，想出各种事让别人去做，他们喜欢把别人拖去开会，那是他们表现自己的最佳机会，而被拖去开会的人都不能踏实的工作。

27. 企业文化不是由谁创造的－－企业文化是自然生产的，你鼓励创新，创新就是你的企业文化，你鼓励复制，复制就是你的企业文化。

28. 上报审批－－当公司里事事都要审批时，你就创造出了一种无脑文化，你成功的创造出了老板和员工的敌对关系，这种关系咆哮着：我不相信你。

29. 准点放人－－你需要的不是工作得更久的人，而是工作更高效的人。

30. 不要听风就是雨－－规章制度是组织体上的伤疤，他是针对不再可能发生的事情做出的过激反应，他是对一个人的错误做出集体的惩罚，他是官僚主义的温床。

在这本书中，看到“废话”这个词是最多的。因为这个词能让大家产生共鸣，别人的不是总能让自己兴奋，就像微博中的加V人士总说党的不是来吸引大家的眼球。当然这根本不是作者的目的，有个性的人就是不一样，就像乔布斯一样，言辞就是那么激烈“这就是一坨屎”，就像周星驰的经典台词“看到没有，屎诶，看到没有，里面有坨屎”，这是一本很有个性的书籍，适合所有有个性的人。

作者：陈太汉

博客：http://www.cnblogs.com/hlxs/

本文链接

裂变问题分析

2012-03-31T06:23:00Z

问题：一个瓶子放一个细菌,细菌一分钟裂变一次，1变2，60分钟后瓶子就满了，问给这个瓶子里放两个细菌裂变后要多久瓶子会满？

首先我们用猜的，不是30就是59，不可能是其他的答案，如果让我从30和59中选一个答案，那我肯定选59，不可能30吧，会这么弱智吗，没错答案就是59。

现在我们用数学公式来证明。根据题目我们知道瓶子装满时细菌的数量为2^60，假设N分钟后瓶子满，那么我们得到2*2^N=2^60，1+N=60，从而得出N=59。

是的就这么简单，还有更简单的呢。1个细菌裂变成2个细菌用时1分钟，1个细菌裂变让瓶子满的时间是60分钟，那么2个细菌让瓶子满的时间=1个细菌裂变让瓶子满的时间-1个细菌裂变成2个细菌的时间=60-1=59。

从上面的那个等式我们可以得出：N个细菌让瓶子满的时间=1个细菌裂变让瓶子满的时间-1个细菌裂变成N个细菌的时间

有了这个等式我们就很容易知道往瓶子里面放N个细菌多就会满了，4个细菌的时间为58,8个细菌的时间是57,16个细菌的时间，同样的，5,6,7的时间都是58分钟，因为8个细菌刚好要57分钟，所以我们很容易知道往瓶子里任意放1~2^N个细菌让瓶子满的时间为60-logN。

从上面那个等式可以看出：用时和细菌是1变2，还是1变3，或是1变N，没有多大关系，有关系的是1个细菌变成N个细菌所需的时间。所以上面那个等式适用于裂变是1变N的情况。

问题扩展：题目基本不改，只是将细菌1变2改成1个细菌生出2个细菌，就变成了鸡生蛋的问题了，其实就是1变3吗

作者：陈太汉

博客：http://www.cnblogs.com/hlxs/

本文链接

这些天写的技术微博

2012-03-27T18:22:00Z

为什么类型和实例对象都要类型对象指针方法和类型所需的内存是在一起分配的，方法被类型和实例对象共享，在实例化一个对象的时候不会为方法分配内存，而调用方法时只能通过类型对象指针定位到方法表中相应的方法，进行调用

==与Equals的区别：值类型他们的效果是一样的，因为值类型分配在线程栈上，存的就是值，直接比较的就是值引用类型：==判断是否指向同一个地址；Equals比较的是变量所指的内存中的数据是否相同

Dictionary时间复杂度：Add；ContainsKey；Remove；TryGetValue为O(1),只有ContainsValue为O(n);因为前者根据哈希算法直接定位到数组索引，而后者却要遍历数组做比较；Remove和Add并没有发生数组元素的移动，数组是预先分配好的，Add只是填充，而Remove只是将对应的元素都置为初始状态

不要把动态的内容存在不能修改的缓存中，如存在静态字段中，如果内容改了，缓存中内容却改不了，如果存在静态字段中，可以隔一段时间更新一下，或者让你的缓存依赖某个文件。总之要让自己可以控制缓存中的内容

int映射到FCL中System.Int32,string映射到FCL中System.String,他们没有区别，相当于using int=System.Int32

值类型赋值是逐一对字段赋值，将一个很大的结构体当做实参传递是很低效的，如果这个结构体有1000个字段，那就要赋值1000次，而引用类型赋值，只是修改指针指向，说明将Class修改成Struct并不一定能提升性能，struct的类型实例一定要小

拆箱其实是一个获得一个指针的过程，该指针指向对象的数据部分，紧接其后是一个赋值动作，拆箱就是把引用类型赋给值类型，其实是赋给一个中间变量，然后你就可以调用值类型的方法了

在foreach循环读取数组中的元素的同时添加或删除元素，都会报InvalidOperationException异常，因为添加和删除都会修改字段version的值，而MoveNext里面会判断version的值和数组元素的个数是否发生变化，如果发生变化就报这个异常

效率：静态方法>实例方法>虚方法 1：静态方法不需要判断对象是否为空，而实例方法需要判断调用该方法的对象是否为空 2：虚方法有一些额外代码，用于判断是调用父类的方法还是调用子类的实例方法。实例方法和虚方法都要进行非空检查，若为null，就会抛出你常见的NullReferenceException，而静态方法不需要进行非null检查，你见过调用静态方法抛这个异常吗？

金字塔、锥形结构、树形结构有很好的稳定性，能很好的分散压力负载

想了几十分钟没有找到好的解决方法，吃完饭后瞬间就找到了好的方案，感觉思路非常清晰，这就是正确的答案

一个简单的防攻击类

DataTable 转换成 List

作者：陈太汉

博客：http://www.cnblogs.com/hlxs/

本文链接