博客园_铭想

【免费】承接各类SharePoint项目开发工作

2011-06-05T12:48:00Z

说是SharePoint项目其实也不可能是一个完整的项目，最好的开发量在2-3天左右的工作。当然是无偿的。

有意者请与我联系。

以下内容与本主题无关!

保护眼睛的颜色设置，适合长期工作在电脑前的白领们~！

第一步，在桌面上点击鼠标右键，依次点击“属性”、“外观”、“高级”按钮。

第二步，在打开的“高级”对话框中，在“项目”下拉列表里选择“窗口”。

第三步，再打开右边对应的“颜色”列表，选择其中的“其他”一项，在打开的对话框里，把“色调”的参数设置为85，把“饱和度”参数设置为90，把“亮度”参数设置为205。再点击“确定”退出设置。

第四步，打开ie浏览器，选择“工具”栏中的“internet选项”，点击“辅助功能”按钮，在“不使用网页中指定的颜色”前打钩。

全部步骤完成后，网页、文件夹、文本文档里的背景颜色都变成了绿色。其中，色调、饱和度和亮度的参数值，还可以根据个人的喜好稍作修改，让自己用电脑的候最舒服。
褚仁远教授还说，红色是最刺激眼睛的颜色，看得时间长了，就容易产生眼干、眼涩等症状，加重眼睛疲劳，所以建议大家不要使用红色作为电脑屏幕和网页的底色

所有的文档都不再是刺眼的白底黑字，而是非常柔和的豆沙绿色，这个是色调是眼科专家配置的，开始可能会有一点不适应，但长时间使用会很有效的缓解眼睛疲劳.

本文链接

【免费】承接翻译各类英文技术文章

2011-05-13T09:22:00Z

各位如果有一些英文技术文章看不懂，可以把文章地址回复到本贴，我会为大家翻译。

技术类型包括：C#，Asp.Net，SharePoint，JavaScript，SqlServer，面向对象，设计模式，BI，算法。

欢迎回复！

-------------------------------------------------------------------------------------------------

以下内容与本主题无关!

保护眼睛的颜色设置，适合长期工作在电脑前的白领们~！

第一步，在桌面上点击鼠标右键，依次点击“属性”、“外观”、“高级”按钮。

第二步，在打开的“高级”对话框中，在“项目”下拉列表里选择“窗口”。

第四步，打开ie浏览器，选择“工具”栏中的“internet选项”，点击“辅助功能”按钮，在“不使用网页中指定的颜色”前打钩。

所有的文档都不再是刺眼的白底黑字，而是非常柔和的豆沙绿色，这个是色调是眼科专家配置的，开始可能会有一点不适应，但长时间使用会很有效的缓解眼睛疲劳

本文链接

SharePoint Workflow 版本控制

2011-05-09T11:54:00Z

你创建了一个工作流，并且将它部署到生产环境。几个月后，业务需要做一些小的改变。你打开工作流代码，增加了一些Activities使得它满足了新的需求，然后重新部署到生产环境。令你感到震惊的事情发生了，所有的流程实例都中断了！你陷入了深深的狂乱中，因为你确信已经对修改的部分充分进行了单元测试，并且找不到产生错误的原因。你没有进行版本控制！
工作流的版本控制是非常重要的技术。当一个工作流处于闲置时（指等待触发条件，如等待某人审批），工作流的属性会被保存到数据库，这称之为持久化。当它需要重新开始执行时，它的属性会从数据库中取出，工作流才得以继续执行。版本控制如此重要是因为，工作流持久化后，如果改变了工作流的程序集,就不能保证当工作流重新恢复时，它能够匹配新的程序集。一旦匹配不上，工作流将会终止。最好的做法是每一次修改都创建一个新的工作流版本。

大致的思路是每次生成项目都使程序集的版本号增加，而不是永远都是1.0.0.0。将新的程序集添加到GAC。最后指定旧版本的工作流不能创建新实例，然后把新工作流添加到对应的列表。这样，老版本的工作流没有发生改变，因此不会对已经持久化的工作流产生危害。

如果你没有创建新版本而仅仅只是更新了工作流，所有运行中的工作流实例将会被删除。老版本工作流将会被移除。不要更新工作流而不创建新版本，除非你完全确认你不在需要正在运行的实例。

跟随下列步骤，为已经存在的工作流创建一个新版本。
1.在你工作流的Elements.xml文件中，替换CodeBesideAssembly属性值$assemblyname$为：
[assembly name], Version=1.0.0.0,Culture=neutral, PublicKeyToken=[token]
2.将[assembly name]替换成程序集的名称。
3.将[token]替换成public key token，你可以在GAC（c:\windows\assembly）中找到你的程序集，然后右键选择属性，将token拷贝到Elements.xml件中。
4.修改Elements.xml文件中name的值(如果workflow version 1.0.0.0)，使得用户能够区分老版本和新版本。
5.将旧版本的程序集添加到package中。双击Package,在Advanced tab中，添加已经存在的程序集文件，选择已经存在的1.0.0.0版本。注意：选择前应先copy一个新的程序集，放在bin\debug\V1.0.0.0目录下，选择新copy出来的文件，因为原有的文件编译后会重新生成。最后确认Source和Location是否都指向了新的文件。
6.修改Properties文件夹下的AssemblyInfo.cs文件，将最下面的两个版本号都修改为2.0.0.0
7.打开Elements.xml文件，copy整个<workflow>节点。修改name为workflow version 2.0.0.0,
version改为2.0.0.0,修改ID为新的GUID，可以使用Visual Studio自带的GUID Generator来生成。
8.部署解决方案后，在对应的列表或站点中创建一个新版本的工作流。这时，我们的列表或站点就有两个工作流了，然后选择移除工作流，选择Version 1.0.0.0版本的工作流不允许创建新实例，点击OK。

此方法用于Visual Studio 创建的工作流，如果是用SharePoint Designer创建的工作流会自动进行版本控制。

本文链接

SharePoint Workflow Debugging

2011-05-09T11:51:00Z

如果你在工作流开发中没有适当的处理异常，当异常出现时你会在工作流列表的Status列中看到‘Error Occurred’,而得不到任何有关异常如何产生的线索。在这种情况下，你只能对你的工作流进行调试，但如果你不了解正确的调试方法，那会使你陷入窘境。

调试工作流的方式和调试其他.Net应用程序几乎一样。在工作流的代码视图中，选择你想调试的行并且加入断点。同样你也可以在工作流设计器中调试Activity.

右键点击你想调试的Activity,然后选择调试->插入断点。

接下来要做的事情是在Visual Studio调试器中附加w3wp.exe进程。在Visual Studio中点击Debug下拉菜单，选择附加进行，在进程列表中选择w3wp进程并点击附加。如果有多个w3wp进行，全部都选择附加。如果进程列表中没有这个进程，首先用浏览器打开你的SharePoint站点，然后重新回到进程列表中点击刷新按钮。附加了进程后就可以运行工作流了，当运行到断点所在行或Activity时，Visual Studio将会自动进入断点。

在工作流中进行异常处理和普通的.Net应用程序有一些区别。在工作流设计器中，没有地方加入Try/Catch语句块。许多开发者从不处理异常，而是花费大量的时间去调试，试图找到错误发生的地方。然而，更好的方法是在工作流的根节点中使用FaultHandler Activity，当然也可以在其他一些Activity中使用，比如:sequence,parallel,IfElse等等。

在FaultHandler Ativity内部，你可以插入一些activities来处理错误。在SharePoint中通常使用工作流历史记录列表来记录错误、错误发生的地方和跟踪信息。这使得定位错误更加容易。

在每一个工作流中，至少需要在工作流根节点中定义一个fault handler。点击工作流设计器的根节点（绿色箭头）下拉菜单，选择View Fault Handlers。

在fault handlers 区域中，你可以拖拽多个FaultHandler activities.每一个activity都有一个FaultType的属性，你需要将这个属性设置为你想要处理的异常类型(类似与Catch的参数)。如果要处理所有的异常，可以设置为System.Exception。另外，你也可以针对你的工作流设置一个自定义异常类型。这是一个非常好的做法，它能够使调试更加简单，因为你知道你的自定义异常会在什么时候，什么原因产生。

在你指定了要处理的异常类型后，你需要添加一些Actions去适当的处理错误。使用Log to History List activity来记录错误日志和跟踪信息通常对于调试是非常有帮助的。

本文链接

我断言今年世界杯将会是一支新队夺冠！

2010-06-02T06:45:00Z

这支球队很可能在西班牙或者是

某欧洲二流球队中产生！

本文链接

JavaScript语言精髓（1）之语法概要拾遗

2010-05-29T14:40:00Z

逻辑运算

JavaScript中支持两种逻辑运算，“逻辑或（||）”和“逻辑与（&&）”，他们的使用方法与基本的布尔运算一致：

var str= ‘hello’;
var obj = {};
x = str || obj;
y = str && obj;

这种运算符的特殊之处在于，他既不改变运算元的数据类型，也不强制运算结果的数据类型。除此之外，还有两条特性：

运算符会将运算元理解为布尔值；
运算过程支持布尔短路。

因此上例中，

x运算结果为：str；

y运算结果为：obj。

比较运算

1.等值检测

等值检测的目的是判断两个变量是否相等或相同。

相等是指运算符“==”和“!=”，相同是指运算符“===” 和"!=="。

名称	运算符	说明
相等	==	比较两个表达式，看是否相等。
不等	!=	比较两个表达式，看是否不相等
相同	===	比较两个表达式，看值是否相等并具有相同的数据类型。
不同	!==	比较两个表达式，看是否具有不相等的值或不同的数据类型。

等值检测中“相等”的运算规则

类型	运算规则
两个值类型进行比较	转换成相同数据类型的值进行“数据等值”比较。
值类型与引用类型进行比较	将引用类型的数据转换成为与值类型数据相同的数据，再进行“数据等值”比较。
两个引用类型比较	比较引用地址。

等值检测中“相同”的运算规则

类型	运算规则
两个值类型进行比较	如果数据类型不同，则必然“不相同”；数据类型相同时，进行“数值等值”比较。
值类型与引用类型进行比较	必然“不相同”。
两个引用类型比较	比较引用地址。

特别举例说明引用类型的等值比较，“比较引用地址” 的实际意义是：如果不是同一个变量或其引用，则两个变量不相等，也不相同。

var str = 'abcdef';
var obj1 = new String(str);
var obj2 = new String(str);

alert(obj1==obj2);//返回false
alert(obj1===obj2);//返回false

“===“和“！==”运算符的一般性用途

在JavaScript中false、‘’、0和Null、undefined是两两“相等”的：

alert(''==0);
alert(0==false);
alert(false=='');
alert(undefined==null);

以上的结果都是true，因此当比较的数据元中包含以上5种情况时，应使用“===”和“!==”。

PS:一个值应该与其自身“相等/相同”，但存在一个例外：一个NaN值，与自身不相等，也不相同。

2.序列比较（比较大小）

可比较序列的类型	序列值
Boolean	0~1
String
Number	负无穷大~正无穷大

类型	运算规则
两个值类型进行比较	直接比较数据在序列中的大小。
值类型与引用类型进行比较	将引用类型的数据转换为与值类型数据相同的数据，再进行“序列大小”比较。
两个引用类型比较	无意义。（*注1）

注1：其实，对引用类型进行序列检测运算仍然是等可能的，但这与valueOf()运算的效果有关。

以下是上述的例子：

//值类型的比较，布尔值与数值
var b0 = false;
var b1 = true;
var num = 1;
alert(b1<num);//false
alert(b1<=num);//true
alert(b1>b0);//true

//值类型与引用类型
var num = 1;
var ref = new String();
alert(num > ref);//true

//引用类型的比较
var o1={};
var o2={};
alert(o1 > o2 || o1 < o2 || o1 == o2);//false

//两个运算元都是字符串，比较字符串中每个字符的大小
var s1 = "abc";
var s2 = "ab";
alert(s1 > s2);//true

//当字符串与其他类型值比较时，将字符串转换为数值比较
var s3 = "101";
var i= "100";
alert(s3 > i);true

//当字符串转换为数值时得到NaN，任何数据与NaN比较都为false
var s4 = "abc";
var i = "100";
alert(s4 > i);

void运算符

使用void的语法格式是：[void 表达式]。

其作用是使后面的表达式立即执行，但忽略返回值(返回undefined)。

以下的例子很好的诠释了这句话的含义：

var s1 = "1";
function testVoid()
{
s1 = "2";
}
var s2 = void testVoid();
alert(s1);//2
alert(s2);//undefined

利用这种特性，我们可以使<a>标签中的Href属性失去作用，就像我们常看到的那样：

这里void后的括号并不是必须的，只不过它仍然满足[void 表达式]这一语法格式，表达式等于（0）而已，千万不要当成了函数调用。

由此应该可以想到，既然这里使用到的是void 忽略返回值这一特性，那么该链接么有执行默认行为的原因并不是我们原以为的0在起作用，如下形式会得到同样的效果：

<a href="javascript: void 1">I am a useless link</a>
<a href="javascript: void 'abcde'">I am a useless link</a>
<a href="javascript: void (1 + 2)">I am a useless link</a>

函数调用

最常用的函数调用方式：

//具名函数直接调用
function foo()
{

}
foo();

//匿名函数通过引用来调用
var fooRef = function(){}
fooRef();

下面来看看几种不常见的函数调用方式：

//没有引用的匿名函数调用1
( //这里的括号对表示强制运算符
  function()
  {
    alert('test');
  }()//这里的括号对表示函数调用运算符（*注）
);
//执行完后，弹出‘test’表明函数执行成功。
下面来分析一下这段代码，首先来看内部的函数，
function()
{
  alert('test');
}()
这样还不够清晰，这段代码等同于
function fun1()
{
  alert('test');
}()
如果还觉得不够清晰的话，其实它还等同于
function fun1()
{
  alert('test');
};
();
也就是说第1个分号前的函数申明是作为完整的语法结构被解释，而后面的“();”则显然是一段错误的语法，
那么是什么让上面的函数调用得以成功执行呢？答案是最外层的强制运算符。
我们知道强制运算符是把本不会产生运算关系的运算元强制进行运算，比如：1*2+3*4，不会按照2+3这样的逻辑进行运算，但1*(2+3)*4之后就可以了。
回到上面的例子，最外层的强制运算符把本应单独解释的两段语句强制执行，执行的效果就是产生函数调用！

//没有引用的匿名函数调用2
(
   function()
   {
    }
)();//这里的括号对表示函数调用运算符（*注）
经过上面的例子，这个就比较好理解了。
这里强制运算符运算的是“函数直接量声明”这个表达式，并返回一个函数的引用，然后通过函数调用运算符“()”来操作这个函数引用。

//没有引用的匿名函数调用3
void function()
{

}();//这里的括号对表示函数调用运算符（*注）
运算符void用于使其后的函数表达式执行运算，可理解为一种强制运算，类似示例1。

上面3个例子中标（*注）的地方都是函数调用运算符，既然是函数调用的语法，那么和普通的函数调用一样，也是可以传递参数的。

void function(s)
{
alert(s);
}('test');

break的不常见用法

一般情况下，break子句作用于循环语句的内层或者switch语句中，但break子句也具有一种扩展的语法，以指示它所作用的范围。

该范围用已经声明过的标签来表示：

break some_label;

some_label:
{
   var s1 = "1";

   if(s1 =="1")
   {
      break some_label;
   }
   s1 ="2";

}
alert(s1);// 结果为1，表明s1 ="2"并没有执行。

continue的不常见用法

continue后面也可以带一个标签，这时它表明从循环体内部中止，并继续到标签指示处开始执行。

some_label:
for(var i = 1; i <3;i++)
{
    for(var k =11; k < 13;k++)
    {
    if(k==12)
    {
        continue some_label;
    }
    alert("i = " + i + ";k = " + k);
    }
}
//依次弹出i = 1;k = 11  i = 2;k = 11
//直接看代码不容易理解，可以加个断点调试一下，其实这里的continue some_label的意义是从内部循环中跳出来，
//并继续执行外部的下一次循环，普通的continue是执行当前循环的下一次循环。
//这里需要注意的是continue对应的标签后不能添加大括号。

JavaScript中没有GOTO语句，break和continue语句提供了另一种选择的可能。

运算符的二义性

一、加号“+”的二义性

加号作为运算符在JavaScript中有三种作用：

1.字符串连接符

2.表达式求和运算符

3.数字取正运算符

第3点不常用，他的意思是表示数学里的正号。

var n = 1;
alert(+n);//表示+(1)，其结果还是1。可与alert(-n),进行比较，这里的结果是-1

这三种情况中，1、2两点最容易出现二义性问题。因为这两种处理运算处理方式依赖与数据类型，而无法从运算符上进行判断。如：

c = a + b;

是根本无法知道他真实的含义是在求和还是在做字符串连接。

由于这种二义性的存在会出现一些问题。浏览器中，由于DOM模型的许多值看起来是数字，但实际上确实字符串。因此试图做加法运算时，实际却变成了字符串连接。

<img id = "testImg" style="border: 1 solid red" />
<script>
alert(testImg.style.borderWidth + 10);//1px10
</script>

另外，还有一条关于加号运算符的规则：如果表达式中存在字符串，则优先按字符串连接进行运算。

alert("123"+456);//123456
alert(123+"456");//123456

二、逗号“,”的二义性

先看下面几个示例，分析其表达的含义：

//示例1
a=(1,2,3);

//示例2
a=1,2,3;

//示例3
a=[1,2,(3,4,5),6];

//示例4
var a = 1,2,3;

示例1中，逗号被作为连续运算符使用，连续运算符（也叫逗号表达式）的意义是返回最后一个表达式的值，所以示例1的效果是“变量a赋值为3”。

示例2整个表达式为一个逗号表达式，因此整个表达式的值为最后一个表达式的值3，而变量a被赋值为1.

示例3中的逗号有两中含义（3,4,5）中的逗号表示连续运算符，而在1,2中则表示数组声明时的语法分隔符，因此示例3为将a声明为一个[1,2,5,6]的数组。

示例4并不会像示例2一样正常执行。因为这里的逗号被解释成了语句var声明时用来分隔多个变量的语法分隔符（var a, b,c）,而数字2，3为不合法的语法声明，因此会在解释期就提示出错。

三、方括号“[]”的二义性

//示例1
a = [ [1][1] ];

这个奇怪的语句并没有语法错误，尽管我们几乎不能理解，但JavaScript解释器可以理解。为了弄清这个问题，必须了解方括号的作用：

1.用于声明数组直接量。

2.存取数组下标的运算符。

3.对象成员存取。

因此第一个"[1]"被理解成了一个数组的直接量，它只有一个元素。接下来，由于他是对象，所以第二个“[1]”就被理解为取下标为1的元素，很显然，这个元素还没有声明。

因此“[1][1]”的结果为undefined，而a就变成了a =[undefined],只有一个元素的数组，该元素为undefined.

下面再来看一个稍微复杂一点的例子：

var a = [ ['a',1,2]['b',3,4] ];

['a',1,2]仍然是一个数组的直接量，但['b',3,4]怎么解释呢？

首先要了解'b',3,4被解释成为了一个逗号表达式，而他的值为4，因此[4]表示数组成员的存取，后面的过程就与上一个示例一样了。

本文链接

JavaScript语言精髓（0）

2010-02-26T14:30:00Z

“你的JavaScript怎么样啊？”我的项目经理问道。“。。。还。。可以吧” 我回答。这时是2006年，刚进这家公司才两个星期，也是我进的第一家公司。“明天我带本书来，你把JavaScript恶补一下。”第二天，一本《JavaScript权威指南》就拿在了我的手中。项目经理的目的是因为马上会有一个项目，这个项...

Linq在路上（一）一统江湖

2009-09-24T15:44:00Z

Linq 即 Link,连接了数据和编程语言。Linq之前不同的API访问不同的数据源。编程语言与数据源设计理念不统一。调整数据组合形式需要大量的代码。Linq之后统一的数据源查询语法。取长补短，吸取数据源设计理念中的精华。更为优雅、简洁的代码。Linq之内LINQ to ObjectLINQ to XMLLINQ to SQL自定义扩展...

Linq在路上（外一）获取SQL语句

2009-09-08T06:20:00Z

Linq方便了我们对数据库的操作，直接用C#的语法操作数据库。但Linq也隐藏了实际执行的SQL语句，封装是好事，可是有时候还是不得不了解Linq具体对数据库的操作。比如，只有查看实际的SQL语句才能对数据库或查询语句做优化，而且在调试时不能查看SQL是很郁闷的事情。有下面几种方法来挖掘出操作中所使用的Sql语句：1、获取Query所对应的SqlCommand对象：在开发过程中，我们可以通过Q...

Linq在路上（序）

2009-09-07T13:34:00Z

刚接触.Net的时候是2.0，时至今日，2.0的书看了不少，项目也做了不少，学习过cnblogs等论坛上大家的经验与心得，也就某些问题激烈讨论过。对2.0的知识体系不敢多全部精通但方方面面、边边角角的内容大概也都了解。自从学习到某一阶段进取心就不太强了，很松懈。没有压力、没有目标、没有方向。3.0，3.5的框架已经推出好久了，想研究研究，不然怎么跟得上MS的脚步，但无奈推出的组件太多，Linq...