OPC 仅仅是具有某些元数据的 zip 文件的首字母缩写词。 事实上，您可能早已熟悉 OPC，因为 Word 和 Excel 文档正是使用此格式。 如果您取一个 .docx 文件并将文件扩展名改为 .zip，您实际可以打开它并浏览里面的内容。 . nupkg 文件同样如此。

NuGet 产品同样随附能够轻松创建和发布程序包的实用工具。 现在，我先重点介绍如何使用 NuGet 发现和安装程序包。 之后，我将讲述如何创建和发布程序包。

具体使用参考：

使用 NuGet 管理项目库

随机日志

• 2010/12/16 -- Google 公布 2010 年搜索热词 (0)
• 2011/08/28 -- C#基础：Lambda表达式 (0)
• 2011/01/08 -- VIM学习笔记（四）：VIM常用设置命令 (0)
• 2011/01/24 -- Open Source Physics Engine (0)
• 2011/01/08 -- 2011年应关注的5项Web技术 (0)

让我们来看一个跟取款相关的例子：某年某月某日某时某分，老王在A取款机取钱，他儿子小王同时在B取款机取钱（不要问我为什么这么巧^_^），他俩从同一个账号上取。于是就发生了如下一序列的操作：

A取款机向中央数据库提问：这账上还有多少钱？

B取款机向中央数据库询问：这账上还有多少钱？

中央数据库回答A取款机：2W。

中央数据库回答B取款机：2W。

然后，老王对A取款机说：我要取出1.5W。

同时，小王对B取款机说：我要取出1.8W。

A取款机就算了一下，2W-1.5W=0.5W>0，于是就吐出1.5W现金给了老王，并且准备告诉中央数据库，现在还剩0.5W啦。但是，就在它告诉中央数据库之前，发生了以下的事情：

B取款机计算了一下，2W（此时，它还不知道余额已经成0.5W了，因为A取款机还没有告诉中央数据库）减去1.8W等于0.2W大于0，于是就吐出1.8W现金给了小王。然后，它当然也要知会中央数据库。

中央数据库于是收到A取款机的消息，说，这个账号还剩0.5W，于是刷新余额为0.5W。然后又收到B取款机说还剩0.2W，于是，就刷新余额为0.2W。

呵呵，于是，小王+老王的账户里一共存有2W元，结果老王取了1.5W元，小王取了1.8W元，账户里却还剩了0.2W元!~@#$%^&

这就是一种并发冲突，由于同一时间有两个或者多个端在对同一数据进行操作，从而导致数据发生了错误。

二、常见的并发冲突处理方式

一般来说，我们把并发冲突处理方式归结为3类。

第一类：放任不管方式；第二类：开放式并发处理方式；第三类：保守式并发处理方式。

1. 放任不管方式：

与其说这是一种处理并发冲突的方式，不如说，它是一种没有对并发冲突做任何处理的方式。但是在许多过去的系统里，由于没有考虑到多用户、网络应用等情况，这种”处理方式”还真存在于不少系统中。

举例来说，A、B两人从数据库中获取了同一个笔记本的信息，例如：IBM ThinkPad T61吧。然后：A把牌子改成了：Lenovo ThinkPad，B把型号改成了T61 8890A24。然后，他们开始提交了。此时，如果A先提交，然后B提交，那么，最后的结果是：IBM ThinkPad T61 8890A24；反之，则变成Lenovo ThinkPad T61。

总之一句话，谁最后提交谁老大。想像一下，如果A修改了1000个属性的值，B修改了1个属性的值，那么，对于先提交的A来说，这将是一个多么惨痛的打击:-)

虽然这种放任不管的方式似乎不太负责任，但是，其处理性能却是相对较高的。

2. 开放式并发处理

开放式并发处理，老外叫做Optimistic Concurrency——乐观的并发。这种并发处理方式要求我们对并发抱有一种乐观的态度：百分之九十九点九九不会发生并发冲突，万一发生了，系统也能捕获到冲突，或者根据策略自动处理，或者，就提醒一下用户，让用户来决定是不是要继续提交。

仍然用上面的例子来说这事儿：A、B两个人同时获取了笔记本的信息：IBM ThinkPad T61。然后……（此处跟上例做一样的修改，直到提交）此时，如果A先提交，那么，B提交的时候，系统会发现，哎哟，不好，有并发冲突了，就会抛个异常给B，让B知道，发生并发冲突了，然后，B就可以根据实际情况，选择相应的处理策略（比如，继续提交进行覆盖或者取消提交等等）；相反，如果B先提交，那么，A提交时，就会得到相应的提醒。

这样的并发处理方式，可以说在可靠性与性能上取得平衡，适合于对数据可靠性要求不是特别严格，需要较高的性能，并且不会大量发生并发的场合。

3. 保守式并发处理

这是最为严谨的一种并发冲突的处理方式。它把并发转化为了串行操作。

例如，A从数据库中获取了笔记本信息：IBM ThinkPad T61，B也要对其进行修改，但此时由于A已经从数据库中将数据取出，因此，B被置于等待状态。直到A把数据修改完提交了，数据库数据更新为Lenovo ThinkPad T61了，此时，数据库才把数据给B，那么B就可以在Lenovo ThinkPad T61的基础上，把它修改为Lenovo ThinkPad T61 8890A24。而在B提交前，其它一切针对此记录的操作都得排除等着B。

这样子当然非常理想，由于不存在并发，自然也就消除了并发冲突的问题。但是，这种锁也存在着较为隐蔽的风险：如果A修改了数据，一直不提交，或者A因为故障，没有办法提交，那么，其它所有的相关的操作，都将被阻碍住。因此，只有对数据准确性要求极高并且用户可以忍受等待的情况下，使用这种并发冲突的处理方法。
三、EF并发冲突处理实例

EF发布时，提供了两种并发冲突处理方式：放任不管方式和开放式并发。默认采用放任不管的方式处理。如果要使用开放式并发，那么，必须设置相应属性上的Concurrency Mode值为Fixed。

原文：http://www.cnblogs.com/xiaomi7732/archive/2008/08/27/1278062.html

随机日志

• 2011/05/11 -- Google的野心 Android未来方向分析 (0)
• 2011/01/03 -- WebKit编译小结 (0)
• 2010/11/21 -- wordpress 的公告插件Continuous announcement 使用 (6)
• 2011/02/26 -- 补码加法运算 (1)
• 2011/04/05 -- 90后英国中学生建立黑客社交网 涉案金额达1.8亿元 (0)

一、SMO类

需要添加的Reference DLL：

Microsoft.SqlServer.ConnectionInfo.dll

Microsoft.SqlServer.Smo.dll

Microsoft.SqlServer.Management.Sdk.Sfc.dll

Microsoft.SqlServer.SqlEnum.dll

命名空间：

Using Microsoft.SqlServer.Management.Smo

Using Microsoft.SqlServer.Management.Common

Using Microsoft.SqlServer.Management.Smo.Agent

MS官方实例：

Creating a Job with Steps and a Schedule in Visual C#：

 //Connect to the local, default instance of SQL Server.
            Server srv = new Server();

            //Define an Operator object variable by supplying the Agent (parent JobServer object) and the name in the constructor.
            Operator op = new Operator(srv.JobServer, "Test_Operator");

            //Set the Net send address.
            op.NetSendAddress = "Network1_PC";

            //Create the operator on the instance of SQL Server Agent.
            op.Create();

            //Define a Job object variable by supplying the Agent and the name arguments in the constructor and setting properties.
            Job jb = new Job(srv.JobServer, "Test_Job");

            //Specify which operator to inform and the completion action.
            jb.OperatorToNetSend = "Test_Operator";
            jb.NetSendLevel = CompletionAction.Always;

            //Create the job on the instance of SQL Server Agent.
            jb.Create();

            //Define a JobStep object variable by supplying the parent job and name arguments in the constructor.
            JobStep jbstp = new JobStep(jb, "Test_Job_Step");
            jbstp.Command = "Test_StoredProc";
            jbstp.OnSuccessAction = StepCompletionAction.QuitWithSuccess;
            jbstp.OnFailAction = StepCompletionAction.QuitWithFailure;

            //Create the job step on the instance of SQL Agent.
            jbstp.Create();

            //Define a JobSchedule object variable by supplying the parent job and name arguments in the constructor. 

            JobSchedule jbsch = new JobSchedule(jb, "Test_Job_Schedule");

            //Set properties to define the schedule frequency, and duration.
            jbsch.FrequencyTypes = FrequencyTypes.Daily;
            jbsch.FrequencySubDayTypes = FrequencySubDayTypes.Minute;
            jbsch.FrequencySubDayInterval = 30;
            TimeSpan ts1 = new TimeSpan(9, 0, 0);
            jbsch.ActiveStartTimeOfDay = ts1;

            TimeSpan ts2 = new TimeSpan(17, 0, 0);
            jbsch.ActiveEndTimeOfDay = ts2;
            jbsch.FrequencyInterval = 1;

            System.DateTime d = new System.DateTime(2003, 1, 1);
            jbsch.ActiveStartDate = d;

            //Create the job schedule on the instance of SQL Agent.
            jbsch.Create();

Server srv = new Server();这个默认连接的是本地的SQL SERVER 实例，如果需要连接远程的只需要
Server srv = new Server(“192.168.108.16”,”sa”,”sa”);即可。
更多有关操作可以参考：
Programming SQL Server Agent

随机日志

• 2011/11/27 -- 工作总结（一）2011.11.27 (9)
• 2011/08/05 -- 网易iTown游戏平台：开放的不只是接口 (2)
• 2011/04/06 -- C语言编码风格（五）——indent工具 (0)
• 2011/04/07 -- VS2010第四篇：为爱Debug (0)
• 2011/07/10 -- StarUML (0)

游标是邪恶的，一般是在离开游标就不能活的情况下才去使用游标。为什么呢？详细的可以参考：

T-SQL查询进阶-10分钟理解游标

这篇文章分析的很好。

1. 使用临时表进行循环遍历

（1）TOP 1方法

SET ROWCOUNT 0

DECLARE @ID INT

CREATE TABLE #tb_ids (uID INT)
INSERT INTO #tb_ids
	SELECT userID FROM User

SELECT TOP 1 @ID = uID FROM #tb_ids
WHILE @@ROWCOUNT <> 0
BEGIN
	DELETE FROM #tb_ids WHERE uID = @ID

	--这里做你想干的事（根据uID）。

	SELECT @ID = uID TOP 1 FROM #tb_ids
END

（2）SET ROWCOUNT 1方法

这个其实和方法1原理是一样的。

declare @au_id INT

set rowcount 0

select * into #mytemp from authors

set rowcount 1
select @au_id = au_id from #mytemp
while @@rowcount <> 0
begin
  set rowcount 0
  select * from #mytemp where au_id = @au_id
  delete #mytemp where au_id = @au_id

  -- 这里做你想做的事

  set rowcount 1
  select @au_id = au_id from #mytemp<BR/>
end

set rowcount 0

相关文章

• 2012/04/15 -- SQL Server学习资源汇总 (0)
• 2012/04/04 -- T-SQL学习笔记 (7)

2.11招教你如何玩转数据库设计

相关文章

• 2012/04/15 -- T-SQL循环遍历并读取数据集的方法 (0)
• 2012/04/04 -- T-SQL学习笔记 (7)

1. T-SQL抛出异常

官方文档 ： Generates an error message and initiates error processing for the session. RAISERROR can either reference a user-defined message stored in the sys.messages catalog view or build a message dynamically. The message is returned as a server error message to the calling application or to an associated CATCH block of a TRY…CATCH construct.

更多参考。

2. T-SQL  Transaction中使用TRY CATCH

CREATE PROCEDURE [Name]
AS
BEGIN
    BEGIN TRANSACTION
    BEGIN TRY
        [...Perform work, call nested procedures...]
    END TRY
    BEGIN CATCH
        ROLLBACK TRANSACTION
        RAISERROR [rethrow caught error using @ErrorNumber, @ErrorMessage, etc]
    END CATCH
END

以上应该是个比较主流的模式，但仅仅只能对单独的SP，如果SP里面再调用其他的SP，那么调用的那个SP的ERROR抛出ROLLBACK就有问题了。

3. 临时表和表变量

基本原则：能用表变量就用表变量。实在不行才使用临时表。
如与动态语句结合、外部需要使用等，就需要临时表。

表变量主要开销系统的内存，而临时表则使用tempdb。对于小数据量的中间数据存储，可以使用表变量，而当需要临时保存的数据量很庞大时，建议使用临时表。具体使用表变量还是临时表，可以根据系统的运行状况来调整。

declare @tb table(id int,name varchar(50),age int) --创建表变量

insert @tb select 1,'nn',14
union all select 1,'nn',14

select * from @tb

create table #t(id int,name varchar(50),years int,nums int)--创建临时表

insert #t select 1,'nn',14,15
union all select 1,'nn',14,15
insert into #t  exec sp_gets  --可以用于存储过程或动态SQL结合

select * from #t
drop table #t

相关文章

• 2012/04/15 -- T-SQL循环遍历并读取数据集的方法 (0)
• 2012/04/15 -- SQL Server学习资源汇总 (0)

 一、建立委托

建立委托（delegate>），过程有点类似于建立一个函数指针。过程如下：

1. 建立一个委托类型，并声明该委托可以指向的方法的签名（函数原型）

delegate void MyDelegate(int a,int b);

2.建立一个委托类的实例，并指向要调用的方法

//利用委托类的构造方法指定，这是最为常见的一种方式

MyDelegate md=new MyDelegate(Max);

//利用自动推断方式来指明要调用的方法，该形式更类型于函数指针

MyDelegate md=Max;

3.利用委托类实例调用所指向的方法

int c=md(4,5);

利用委托实现方法的动态调用
首先，添加如下控件：
Ø  两个RadioButton，分别用来让用户选择求最大值以及求最小值

Ø  二个TextBox，用来输入两个操作数

Ø  一个TextBox，用来显示运算结果

Ø  一个Button，用来执行运算

下一步，在窗口中添加两个方法：Max，Min，这两方法的代码如下：

int Max(int x,int y)
{
   return x>y?x:y;
}

int Min(int x,int y)
{
   return x< font=""><>
}

为了使用委托来实现动态指向，我们需要建立一个委托类“MyDelegate”，并建立该委托类型的一个实例。

分别为两个RadioButton编写它们的“CheckedChanged”事件：

private void rbtMax_CheckedChanged(object sender, EventArgs e)
{
    if (this.rbtMax .Checked ==true)
    {
        this.md = new MyDelegate(this.Max );
    }
}
private void rbtMin_CheckedChanged(object sender, EventArgs e)
{
    if (this.rbtMin .Checked ==true)
    {
        this.md = new MyDelegate(this.Min );
    }
}

这段代码是，如果用户选择了求最大值的RadioButton，则让MyDelegate类型的实例“md”指向Max方法，如果用户选择了求最小值的RadioButton，则让MyDelegate类型的实例“md”指向Min方法。这样作的目的，就是要把选择的过程交给用户。

下一步，我们为界面中的Button编写Click事件，并利用委托来调用求最值的方法。代码如下所示：

private void btGetResult_Click(object sender, EventArgs e)
{
    if (this.md ==null )
    {
        MessageBox.Show("委托md没有指向任何方法！");
        return;
    }
    int a = int.Parse(this.tbxOP1 .Text );
    int b = int.Parse(this.tbxOP2 .Text );
    int c = this.md(a,b);
    this.tbxResult.Text = c.ToString();
}

从上面的代码中，可以发现，在使用委托之前，先要判断其值是否为空，如果不为空，则可以进行调用，同时，使用者可以看到，在调用md时，我们并没有关心md到底指向了哪一个方法，总之，md不为空的时候，就一定会指向Max和Min当中的一个。

委托使用的注意事项

Ø   在C＃中，所有的委托都是从System.MulticastDelegate类派生的。

Ø   委托隐含具有sealed属性，即不能用来派生新的类型。

Ø   委托最大的作用就是为类的事件绑定事件处理程序。

Ø   在通过委托调用函数前，必须先检查委托是否为空（null），若非空，才能调用函数。

Ø   在委托实例中可以封装静态的方法也可以封装实例方法。

Ø   在创建委托实例时，需要传递将要映射的方法或其他委托实例以指明委托将要封装的函数原型（.NET中称为方法签名：signature）。注意，如果映射的是静态方法，传递的参数应该是类名.方法名，如果映射的是实例方法，传递的参数应该是实例名.方法名。

Ø   只有当两个委托实例所映射的方法以及该方法所属的对象都相同时，才认为它们是想等的（从函数地址考虑）。

内容太多啦，就不贴那么多了。。。

原文地址： http://www.cnblogs.com/warensoft/archive/2010/03/19/1689806.html

随机日志

• 2010/12/14 -- phone gap 简介 (0)
• 2011/04/29 -- PPPoE协议工作原理 (0)
• 2011/04/07 -- Visual Stdio 2010 第三篇：幸福也要敏捷 (0)
• 2011/03/01 -- Android入门学习资料收集【转】 (0)
• 2010/12/04 -- Linux环境下的C/C++基础调试技术1——初步了解 (0)

随机日志

• 2010/11/27 -- linux下FTP命令下载多个文件 (1)
• 2011/04/06 -- Android面试题 (0)
• 2011/06/15 -- 腾讯IM推出Q+平台 三大开放平台布局完成 (0)
• 2011/02/19 -- 牛人强悍剪辑《让子弹飞》神作《非基勿扰》 (0)
• 2011/05/11 -- Android的未来家庭自动化发展 (1)

“静态类型安全”，在编译时检查类型是否一致。

“动态类型安全”，.net4.0里的dynamic类型，在运行时，会提前获得dynamic类型实际的类型。

对任何引用的对象进行操作，CLR都知道此对象是何种类型的； CLR在对一个引用对象进行操作时，它先会检查此引用的类型， 查看本次操作是否有效；若无效，编译将不能通过。

从另一个方面来说，   “C#是类型安全的”指的是：

CLR在程序被编译时就会检查所有对象的有效性，而不是在运行时再检查所有对象的有效性，这样就会避免了在运行时 出现大的错误。

类型安全近似于所谓的内存安全（就是限制从内存的某处，将任意的字节合复制到另一处的能力）。
CLR一个很重要的特性就是Type安全。CLR在任何时候都知道某个对象的类型。你可以通过GetType方法获得，由于该方法不是虚函数，因此不能被覆盖，也就是说返回的值是永远真实的。

类型安全可以静态方式实施，及早在编译时期就捕捉到潜藏的错误；或者以动态方式，在执行时期关联类型的资讯，并在必要时检测即将发生的错误。类型安 全是编程语言的性质，而不是程式所自有的。例如，有可能以类型不安全的语言，编写出类型安全的程式。在此是以编程语言为主，而不讨论以个人能力维护的类型 安全。

在C#中，被传递的引用参数是类型安全的。

二、类型安全

1. C#中如果一个方法的参数类型是string，那么，如果你传入了一个int，就会抛出异常。这就是类型安全。VB.net中，编译器自动把int转换为string,然后传递给方法。这就是非类型安全。

2. 类型安全主要包括两个部分，强类型检查和运行期的类型数据。强类型检查就像第一条所说的，C#的编译器决不会允许int   i   =   “1 “;这样的语句通过编译。同时，这样的语句也不会通过：

string s= " ";
int i = s;

—————————————————

int FunctionA(string s)
string s = FunctionA(" ");//Error
int i = FunctionA(FunctionA(" "));//Error

—————————————————-

long l = 17382;
int i = l;//Error

—————————————————-
运行期的类型数据则主要是is、as运算符、强制类型转换和GetType方法。

3. 类型安全要求可以相互转换的不同类型数据在转换时 显式转换

4. 类型安全代码只访问被授权可以访问的内存位置。（在本讨论中，类型安全特指内存类型安全，不应与范围更广的类型安全混淆。）例如，类型安全代码不能从其他对象的私有字段读取值。它只以定义完善的允许方式访问类型。
在 实时   (JIT)   编译期间，可选的验证过程检查要实时编译为本机代码的方法的元数据和   Microsoft   中间语言   (MSIL)，以验证它们是否为类型安全。如果代码具有忽略验证的权