博客园_看缘工作室

有多少爱可以重来 --Visual Studio 2010 的9项改进建议

2011-06-28T01:37:00Z

距Visual Studio 2010发布一年多了，这一年多的时间不知“耀”他们过得如何，是已经分开还是依然在一起？是否还记得当年发布会上，女孩突然出现时给他的惊喜?不过还好，相信大家都有自己的成长与进步，这就是Coding Life，我们都在得失中老去。。。

话入正题，本人从2002年接触DotNet至今，历经Visual Studio 的代代更新，看到它的成长，我很欣慰~~

Visual Studio是我用过最满意的代码编辑器，但还是有一些个人觉得需要改进的地方，这里写出来，大家补充，也许有的功能已经实现，还请各位大方指出。希望我们的Visual Studio越来越好，同时也希望MS早日推出跨OS平台的DotNet FrameWork。

1. 快速定位文件路径

在右键点击文件à属性后，属性对话框会显示出该文件的“完整路径”信息，如果这时需要定位至该文件所处的文件夹(比如完成一些拷贝粘贴工作)，则还要复制路径，然后在Explorer中打开。

建议：在“完整路径”右侧边缘处提供一个按钮，点击按钮后直接打开该文件所在文件夹窗口。

2. 代码书签

分布于不同文件的代码是有逻辑关系的，经常会有类似情况：检查一段代码的时，需要同时关注其他几段相关代码，这些代码有可能在一个文件中，也有可能在不同文件中，甚至使用2个屏幕核对相关代码，这样如果使用滚动条+行号的形式，在这些代码段中定位了，未免有些郁闷。

建议：提供类似断点的标注方式，但只是标注，目的是让程序人员可以快速的给代码段打上标记，以在不同屏幕、文件切换过程中方便的分辨。

3. Profile导入与导出

很多VS用户并不喜欢白底黑字的界面，更多的人出于对眼睛的保护，喜欢把背景色、字体等设置成别的格式，可是重新安装OS后就不得不把以上工作重新做一遍，浪费时间啊！

建议MS提供一个功能，该功能可以导入导出所有“选项”菜单中自定义的Profile。

如果可能，MS还可以根据不同国家的人，不同角色的人(例如程序员与架构师、测试员)，提供不同的内置偏好，以供相应人群使用。

4. 关于静态变量

静态可是个好东西啊！可是就是不受DotNet垃圾回收器的待见，用完后如果不置null，他就会一直呆在你那个AppDomain，GC不会去管他，因为它就是一个树图的根！

试想一下如果一个程序中大量使用静态委托，而又没有适当的置null，是不是会导致频繁的溢出呢？

建议：编译过程中，对于静态变量的使用，可以根据引用其的类的时序图，判断是否有漏置null的情况，如果质疑，则提出warning级别的提示。当然这只是给编程人员提个醒，起到辅助的作用，真正的代码安全还得靠经验。

5. 提供灵活的垃圾回收

我想这一点并不是所有人都需要的。因为垃圾收集工作悄然无声的进行，有些时候我并不希望GC启动，而有些时候我只希望做垃圾标记，而不希望GC压缩环节的启动，(因为在不久，也许会有更大规模的内存移动)。

建议：能否提供一个类似于Lock的方法，其中的代码执行过程中GC不要启动呢？

6. 项目顺序

如果一个解决方案中有多个项目，你怎样手动排列它们在“解决方案管理器”中的显示顺序呢？靠在项目名字前面加入数字序号吗？

建议：增加手动排序功能。

7. 查找替换目录

在“查找与替换”菜单中，查找范围只有如下几项：

如果想替换某个文件夹下所有或者某种扩展名的文件中的关键字，就不好弄了。

建议：增加类似DW那种在文件夹范围内操作的选项。

8. 加快ASP. NET Design界面与解决方案加载的速度

有过ASP.NET开发经验的人都有此体会，当你从Code界面切换至Design界面时，这个操作会损耗很长的时间，甚至会使人不耐烦。

而解决方案的加载也是如此，如果一个解决方案中项目过多(几十个)，加载时间会消耗很多，令人难以理解。

建议：加快速度。

9. 接口定义的变量，F12时定位至“实现”而不是“接口”

例如有如下代码：

IDataTableContainer dtc = new OracleContainer();

dtc.TransactionBegin(ref cd);

IDataTableContainer是一个接口，里面有一个方法签名TransactionBegin。当你将光标置于dtc.TransactionBegin(ref cd)上，并使用F12查找定义时，VS定位的是接口的位置，而不是接口的实现，可是有些时候我们希望找到的是具体方法，而不是签名。

建议：上述现象可使用F12定位至接口的实现。

以上建议功能可能已经有插件实现，欢迎共享！

本文链接

DotNet并行计算使用误区(三)

2011-06-27T01:17:00Z

这篇文章主要是从实用的角度讲解并行计算需要了解的一些基础知识以及需要注意的地方，包括并行循环的方法、如何终止、线程安全、常用类型等几方面。

关于TPL中提供的并行方法，这里就不再多说了，网上有很多例子，本系列文章第三个Topic主要讲的不是“如何跑”，而是要讲一下“如何停”。

曾经查过很多关于二者的资料，可能是我理解的原因，总觉得很少有对其解释正确的，所以我觉得还是有必要写出我的观点，请大家指正。

Section 1.并行循环的终止：Break与Stop

关于二者网上有很多解释，很多人都认为，在并行计算中：

1．Break的调用会导致当前任务和已分配任务的终止

2．Stop的调用会导致当前任务的终止

本人对以上两点持怀疑态度，经过试验证明，Break和Stop并不像以上说的那样。

这里先解释一下名词，“当前任务”指的是当前已经触发Break(Stop)条件的那个任务；“已分配任务”指的是与“当前任务”并行执行的任务；“未分配任务”指尚未开始的循环部分。

有以下测试代码，这些代码在不同核数量的机器上返回的记录数是不同的，这一点待会再说，先看代码：

class Program

{

static List<int> Data = new List<int>();

static ParallelOptions opt = new ParallelOptions();

static void Main(string[] args)

{

opt.MaxDegreeOfParallelism = Environment.ProcessorCount;

for (int i = 0; i < 10; i++)

{

Data.Add(i);

}

Console.WriteLine("CPU Degree:" + opt.MaxDegreeOfParallelism);

Console.WriteLine("GeneralFor Result:");

new Program().GeneralFor();

Console.WriteLine("ParallerStop Result:");

new Program().ParallerStop();

Console.WriteLine("ParallelBreak Result:");

new Program().ParallelBreak();

Console.Read();

}

//一个普通的For循环

private void GeneralFor()

{

for (int i = 0; i < Data.Count; i++)

{

if (Data[i] > 5)

break;

Console.WriteLine(Data[i]);

}

}

//并行计算的Stop

private void ParallerStop()

{

Parallel.For(0, Data.Count,opt, (i, LoopState) =>

{

if (Data[i] > 5)

LoopState.Stop();

Thread.Sleep(10);

Console.WriteLine(Data[i]);

});

}

//并行计算的Break

private void ParallelBreak()

{

Parallel.For(0, Data.Count, opt, (i, LoopState) =>

{

if (Data[i] > 5)

LoopState.Break();

Thread.Sleep(10);

Console.WriteLine(Data[i]);

});

}

}

下图分别是程序在2(32#)、4(64#)、48(64#)核CPU下运行的结果：

个人认为，不同CPU核数量对于使用Break与Stop终止循环形式的最终记录返回数量是有影响的，即这会影响TPL分配任务的方针，TPL在运行时才会“源源不断”的分配任务，开启的线程数也是递增形式的。(最大线程数应该有限制，具体是多少不确定，有的说是64也有的说是256，等待高人解答)

所以，对于Stop与Break，我的观点是，在并行任意任务中调用Stop方法，则会终止除当前任务外的所有并行任务(包括未分配的和已分配的)，返回最终结果，而不是像传说的那样，终止了当前任务；Break只会停止继续分配新任务，并不影响当前任务的和已经分配的并行任务的执行，而且同样不会终止当前任务。

Stop更改ParallelLoopState 对象的 IsStop值为true；

Break更改ParallelLoopState 对象的 LowestBreakIteration 属性值等于 true 。

	未分配的任务(未开始的任务)	已分配的任务(并行中的任务)	当前任务(触发条件的那个任务)
单行中的Break	停止分配	停止执行(相当于“当前任务”)	停止执行
Break	停止分配	继续执行	继续执行
Stop	停止分配	停止执行	继续执行

如上图中显示，调用Stop后，结果中只能可能有一个大于5的结果，因为此时未分配和已分配的任务都被终止了，而当前任务并没有停止，继续执行打印语句，打印出来的只是当前的那个大于5的任务；

而调用Break后，结果中大于5的结果数量不定，因为当当前任务因满足大于5的条件，而触发Break后，其他已分配的任务并不会停止，即使它们包含大于5的任务，同样也会打印出来，这就是上图中第三幅图中，Break任务出现两个大于5的结果的原因！

Stop和Break，它们的区别可以用下图表示：

图中实现表示运行的任务，虚线表示任务运行过程中被终止。

Section 2.线程安全

在并行计算中应当使用线程安全的类，例如有些时候我们需要不断迭代形成一个集合组织，这个集合可能是一个列表，在普通程序中List<T>完全可以完成这个任务，但是如果在并行计算中使用List<T>的add方法，就会出现一些错误，这些错误是随机的，也就是说有时候并不出现。

以下代码：

List<string> ls = new List< string >();

Parallel.For(0, 10000, (i) =>

{

ls.Add(i.ToString());

});

以上代码偶尔会出现错误，出现错误的概率随着循环次数和并行任务的增加而增大，类似代码需求可以使用ConcurrentBag<T>来代替，针对并行计算提供的类库请参照MSDN：http://msdn.microsoft.com/zh-cn/library/dd287108.aspx

提示：并行计算并不是天上掉下的馅饼，它不是所有时候都比串行程序快，因为并行总要付出一些额外的代价，比如任务分配、任务同步、任务通讯等，到底什么时候才能放心的吃掉这个馅饼，需要仔细地设计算法，并且应该在多台典型的服务器环境中进行测试、对比，这是一个比较烦人的过程，但是最终得到的结果可能会改变你的设计思路。

具体可以参考我的文章：

DotNet并行计算的使用误区(一)

http://www.cnblogs.com/isline/archive/2011/04/20/2022228.html

DotNet并行计算的使用误区(二)

http://www.cnblogs.com/isline/archive/2011/04/21/2023137.html

本文链接

ToList<>()所带来的性能影响

2011-05-10T01:32:00Z

前几天优化师弟写的代码，有一个地方给我留下很深刻的印象，就是我发现他总是将PLINQ的结果ToList<>()，然后再返回给主程序，对于这一点我十分不解，于是去问他是什么原因，得到的答案很幽默:因为习惯。
有时候对于方法的不甚了解加上“习惯”，往往是程序性能和稳定性终结者，就拿这个Case来说吧，原始代码如下：

var query = from cr in LCRNormal.AsParallel()
                        let listId = from crt in LCRNormal
                                     group crt by crt.KeyValue into m
                                     select m.Max(n => n.DBID)
                        where listId.Contains(cr.DBID) && !cr.IsRegularRecord && cr.Status != 3
                        select new ComputingResultForTemp()
                        {
                            KeyValue = cr.KeyValue,
                            DBID = cr.DBID,
                            Status = cr.Status
                        };

query.ToList<ComputingResultForTemp>();

    经过以上PLINQ后，泛型列表中大概还剩下60万至100万条数据，然后我们这位师弟做了两个很“施瓦辛格”的动作：ToList<>()和Count()，测试程序运行在一台4*2G HZ，12GB内存的服务器上，竟然跑了2天多！我觉得正式这两个方法导致了程序性能的降低，为了确定我的判断，我分别在以上代码、ToList<>()和Count()周围加上了StopWatch计时器，然后将结果以文本的形式输出：
    ● 100万数据PLINQ查询：
           ==========3/26/2011 01:34:31 PM ===========
           **(GetDeletedRecords)Start PLINQ(LINQ FITTER)
          ==========3/26/2011 01:38:38 PM ===========
           **(GetDeletedRecords)Finish PLINQ (LINQ FITTER)
   ● 80万数据ToList <>()：
           ==========3/26/2011 03:22:10 PM ===========
           **(GetDeletedRecords)Start Get List
● 80万数据Count()：
           ==========3/28/2011 02:12:09 PM ===========
           **(GetDeletedRecords)Start Get Count
           ==========3/28/2011 08:50:55 PM ===========
           ** (GetDeletedRecords)Finish Get Count
    日志格式是这样：任务开始时输出当前时间和“Start”，任务结束时输出“Finish”，当从日志中可以看出，PLINQ的效率还是很高的，只运行了几分钟；ToList<>()方法在运行了1天多后人为终止，所以只有Start没有Finish；Count()方法也运行了6小时多。
    所以最终优化方案很简单，去掉了ToList和Count，改用其他方法代替，程序从几天的运行时间一下缩短到几个小时。

我是Aicken(李鸣),欢迎您关注我的下一篇文章

本文链接

DotNet并行计算的使用误区(二)

2011-04-21T00:56:00Z

上接 DotNet并行计算的使用误区(一)

● 误区三 . 并行计算是运行时的事

的确，DotNet会在运行时决定是否使用并行库处理代码，但是早在你编译代码时，编译器就早已为这一时刻做好准备，换就话说：

1. 使用并行库处理代码与普通方式对比，IL的结构是不同的。

2. 即使你选择使用并行计算，并且你也确实拥有多核(线程)CPU，运行时你的代码也不一定是并行的。

使用TPL后CLR可能会分解任务，这一依据的其中之一是由IL支持的，IL将并行的任务代码分离，以便在将来的操作中并行，这一点可以从以下的示例中看出来，以下两段示例的核心C#代码都是Tostring()和Sleep()，Code A使用For包含Sleep，Code B使用Parallel.For处理：

Code Part A：

IL：

IL_000e: callvirt instance void [System]System.Diagnostics.Stopwatch::Start()

IL_0013: nop

IL_0014: ldc.i4.0

IL_0015: stloc.2

IL_0016: br.s IL_0031

IL_0018: nop

IL_0019: ldloca.s i

IL_001b: call instance string [mscorlib]System.Int32::ToString()

IL_0020: stloc.0

IL_0021: ldc.i4 0xc8

IL_0026: call void [mscorlib]System.Threading.Thread::Sleep(int32)

IL_002b: nop

IL_002c: nop

IL_002d: ldloc.2

IL_002e: ldc.i4.1

IL_002f: add

IL_0030: stloc.2

IL_0031: ldloc.2

IL_0032: ldc.i4.s 10

IL_0034: clt

IL_0036: stloc.3

IL_0037: ldloc.3

IL_0038: brtrue.s IL_0018

IL_003a: ldloc.1

IL_003b: callvirt instance void [System]System.Diagnostics.Stopwatch::Stop()

我们注意到，Code Part A的Sleep是直接出现在Load方法中的。

再来看看Parallel方式：

Code Part B：

Form1_Load:

IL_0019: callvirt instance void [System]System.Diagnostics.Stopwatch::Start()

IL_001e: nop

IL_001f: ldc.i4.0

IL_0020: ldc.i4.s 10

IL_0022: ldloc.1

IL_0023: ldftn instance void WindowsFormsApplication4.Form1/'<>c__DisplayClass1'::'<Form1_Load>b__0'(int32)

IL_0029: newobj instance void class [mscorlib]System.Action`1<int32>::.ctor(object,

native int)

IL_002e: call valuetype [mscorlib]System.Threading.Tasks.ParallelLoopResult [mscorlib]System.Threading.Tasks.Parallel::For(int32,

int32,

class [mscorlib]System.Action`1<int32>)

IL_0033: pop

IL_0034: ldloc.0

IL_0035: callvirt instance void [System]System.Diagnostics.Stopwatch::Stop()

注意红色字体，Sleep已经不在Load方法中了，而是被一个“b__0”代替，并行代码与宿主代码分离，以下就是b__0的IL：

.method public hidebysig instance void '<Form1_Load>b__0'(int32 i) cil managed

{

// 代码大小 26 (0x1a)

.maxstack 8

IL_0000: nop

IL_0001: ldarg.0

IL_0002: ldarga.s i

IL_0004: call instance string [mscorlib]System.Int32::ToString()

IL_0009: stfld string WindowsFormsApplication4.Form1/'<>c__DisplayClass1'::a

IL_000e: ldc.i4 0xc8

IL_0013: call void [mscorlib]System.Threading.Thread::Sleep(int32)

IL_0018: nop

IL_0019: ret

} // end of method '<>c__DisplayClass1'::'<Form1_Load>b__0'

结构图：

以上的红色代码就是在Code A中出现的主要代码。再让我们重温一下这张图，IL的代码任务已经很明显的指示了出来。

每当我们增加一个并行代码段，IL中就会增加一个b_N块：假如我们的代码中包含两个Parallel块，每块的主代码与上述一致，IL如下：

IL_0019: callvirt instance void [System]System.Diagnostics.Stopwatch::Start()

IL_001e: nop

IL_001f: ldc.i4.0

IL_0020: ldc.i4.s 10

IL_0022: ldloc.1

IL_0023: ldftn instance void WindowsFormsApplication4.Form1/'<>c__DisplayClass2'::'<Form1_Load>b__0'(int32)

IL_0029: newobj instance void class [mscorlib]System.Action`1<int32>::.ctor(object,

native int)

IL_002e: call valuetype [mscorlib]System.Threading.Tasks.ParallelLoopResult [mscorlib]System.Threading.Tasks.Parallel::For(int32,

int32,

class [mscorlib]System.Action`1<int32>)

IL_0033: pop

IL_0034: ldc.i4.0

IL_0035: ldc.i4.s 10

IL_0037: ldloc.1

IL_0038: ldftn instance void WindowsFormsApplication4.Form1/'<>c__DisplayClass2'::'<Form1_Load>b__1'(int32)

IL_003e: newobj instance void class [mscorlib]System.Action`1<int32>::.ctor(object,

native int)

IL_0043: call valuetype [mscorlib]System.Threading.Tasks.ParallelLoopResult [mscorlib]System.Threading.Tasks.Parallel::For(int32,

int32,

class [mscorlib]System.Action`1<int32>)

IL_0048: pop

IL_0049: ldloc.0

IL_004a: callvirt instance void [System]System.Diagnostics.Stopwatch::Stop()

下图中会有对应模块出现：

上面的例子说明，在IL阶段已经为运行时的并行执行任务做了准备，编译阶段将并行任务从宿主中分离出来，运行阶段决定是否采用并行方式执行任务。

本文链接

DotNet并行计算的使用误区(一)

2011-04-20T05:59:00Z

并行计算无疑是.Net Framework平台的一大亮点，它自动的将一个任务分解，并以并发的形式执行，程序员不用操心各任务之间的协作和同步问题，这使得可以更加专注于业务的实现。

.NET 中的 TPL(Task Parallel Library)，中文意思是任务并行库，它的设计是为了能更简单地编写可自动使用多处理器的托管代码。使用该库，用户可以非常方便地用现有序列代码表达潜在并行性，这样序列代码中公开的并行任务将会在所有可用的处理器上同时运行，通常这会大大提高速度。

但是，从网上很多已经发布的并行计算的例子来讲，有很多存在一定的误区甚至是误导，这导致了一线编程人员产生一些错误的思路，它们多是通过示例讲述并行计算的性能优越性，似乎程序人员可以不费吹灰之力就能将程序性能提升N倍，如果这些想法没有经过比较就应用于实际，那么就会造成一定的损失。这篇文章就来聊聊关于合理使用并行计算的问题，供大家参考，这些误区主要包括：

1. 只要使用并行就会提高程序性能

2. 并行循环嵌套越多程序性能越高

3. 并行计算是运行时的事

下面让我们来一个个的讲解这些误会。

● 误区一 .只要使用并行就会提高程序性能

实时并不是这样，实际上并行计算的使用对前提要求非常严格，一般情况大量使用并行计算不但不会提升性能，反而会适得其反，下面有两个Case给大家说明。

Case 1. 使用Thread.Sleep()比较并行与单行程序的性能并不客观。

在许多并行计算与单行方式程序性能比较的例子中，很多都包含类似Thread.Sleep()的语句，运行这样的Demo我们确实看到，并行的时间结果竟然提升如此许多，但是你有没有仔细研究一下时间降低的原因呢？

有如下两段代码：

Code Part A：

for (int i = 0; i < 10; i++)

{

a = i.ToString();

Thread.Sleep(200);

}

Code Part B：

Parallel.For(0, 10, (i) =>

{

a = i.ToString();

Thread.Sleep(200);

});

在我的双核本机上，测试结果是令人兴奋的：Code Part A跑了2秒多，而Code Part B只跑了800多毫秒，时间大幅降低，然而这样你就决定将你的代码迁移到并行方式吗？

我建议你还是等等再说吧，Code Part B比A具有更高性能的原因不是因为主代码并行而带来的性能提升，而是由于Sleep()，在并行环境中，任务实际上只是休息了1/N（N为并行数量），而不是单行程序中的全部，这是因为TPL将循环工作分解的缘故，在双核本机上，Code Part B相当于2个5次的循环同时进行，Sleep()又很少有共享资源的消耗，不需要与其他进程同步，所以运行时间比1次10次的循环降低了，假如我们去掉Code Part A、B中的Sleep语句，那么结果又是如何呢？答案是两者十分趋近。实际上在主代码短短小的情况下，并行计算会表现出一定的性能不稳定性，这里留一点，感兴趣的朋友自己测试一下吧。

选择并行计算处理问题，首先要保证你的样本或需求适合并行处理，比如写排序算法时就不能使用并行计算。

Case 2: 并行程序对于字符串与数字的处理效率是不同的。

@ 字符串累加：

单行：

for (int i = 0; i < 100000; i++)

{

a += i.ToString();

}

并行：

Parallel.For(0, 100000, (i) =>

{

a += i.ToString();

});

@ 字符串比较：

单行：

for (int i = 0; i < 100000; i++)

{

f = a.Equals(i.ToString());

}

并行：

Parallel.For(0, 100000, (i) =>

{

f = a.Equals(i.ToString());

});

@ 数字比较：

单行：

for (int i = 0; i < 100000000; i++)

{

f = i == j;

}

并行：

Parallel.For(0, 100000000, (i) =>

{

f = i == j;

});

运行以上三段测试代码可知，TPL对于字符串处理还是很令人满意的。所以不是所有情况都适合使用TPL库处理程序，这一点对于程序中的遍历情景很重要，在使用PLINQ时，建议先分析样本空间的类型与具体操作，再决定使用哪种计算。

● 误区二.并行循环嵌套越多程序性能越高

对于两层以上循环的代码段，在你决定使用并行前，先要做的是发现这段代码的主要耗损在哪，是在外层还是在内层，只有评估当并行对性能带来的提升大于损耗时，再重构为并行也不迟，因为TPL在很多情形都提供了并行支持，很多程序员在能用到并行的地方都用并行，而没有经过测试比较，实际上有很多时候，在所有的地方加上并行特性，程序的性能反而会受到损失，这里就不在给出案例了。

从下图可以看出，TPL虽然自动管理了循环中的对象，但是这些“自动”是有一些性能损失的，如果我们的代码中不断地要求TPL进行对象的拆分、合并、同步，而忽视了业务本身的优化，那无疑是对性能不利的。

在这里Aicken给出一个建议，就是在并行前，先要评估这段代码的任务量有多大，有没有必要并行？这段代码有没有对磁盘等“写”要求的竞争？代码是处理什么任务的，以及代码的运行环境是否支持并行；再者就是代码重构后进行性能测试，这样才能保证并行计算有意义。

其实，用对并行计算除了对性能的提升外，还有一点可贵的地方，就是对代码的重构，简洁而富有结构性的代码，更加符合编码进步的要求，不是吗？

（待续）

本文链接

ITIL基础概述与实战案例分析(下)

2011-04-13T08:52:00Z

上一篇文章主要给大家介绍了“基于ITIL体系的IT部门建设”，下面举几个例子，来说明ITIL实施后的效果。

● 基于ITIL体系的IT项目管理

任何项目的上线都会启动对项目运维的环节，而这个环节的重要性往往超过项目管理的任何一个环节，因为这是“结果导向”管理思想的最终成果环节。

这里我想以电子商务项目为例，引入ITIL的“服务台职能(Service Desk Function)”来完善电子商务的运营体系。

这个职能处理了用户故障、问题请求与对其的处理、反馈跟进的方法，在这个方法中包括了事故管理、问题管理、配置管理、变更管理、发布管理6个流程，即当用户发起提问时(提问可能包括：系统使用困难、系统故障、系统改进建议、业务问题咨询等)，IT支持、技术与管理部门如何处理。这个职能是一个入口，“服务台职能”实施的程度直接体现了一个公司ITIL体系的建设程度。

以电子商务系统为例，用户遇到使用中的问题(可能是下单、付款等)，首先是服务台一线的服务人员，由服务人员从资源库中使用经验解答用户问题，如果一线人员无法解决问题，会将问题派发至内部工程师，由工程师解决，解决问题后将问题记录至知识库，供下次检索。

图2 服务台整体运作流程

实际上，这套方法的核心在于使用一线人员提供快速的服务，使用二线人员提供可靠地服务，一线与二线人员之间的交互方式、提供服务的质量可以根据SLAs设定，即根据矩阵图提供不同等级的服务。

图3 分度图

最先要解决的是第一象限的工作，实际上ITIL已经为IT部门规划了很多工作的分类，供CIO或ITIL实施人员参考，例如以下两个事件：总经理需要打印一份文档，可是打印机没有就绪；公司网络中断，造成至少10人无法访问办公系统。这个案例中事件一为第一象限工作，事件二为第三象限工作，有了这个参考，结合我们的企业文化，我们就可以更好的处理问题了，这只是一个例子。

Case 1. 电子商务订单查询不符

以下案例简单叙述了电子商务系统运营中，用户查询业绩的一个小例子，该例子说明一线客服怎样配合用户解决问题，与解决问题后客服人员所作的工作。

在这个案例中，用户问题并未调用内部工程师资源，而是重复利用了知识库的资源，完成了用户的服务工作。

所以，ITIL建议将用户问题在一线人员那里得到解决，而一线人员依靠的是个人经验和知识库，知识库是系统问题解决的沉淀，我们的客服模式在解决问题后，应该录入相关问题，将问题变为知识。

Case 2. 电子商务账号余额无法付款

下面这个流程显示了如何快速解决系统难题的流程与一线、二线工程师沟通方案。

该套方法不仅仅适用于电子商务，而且ITIL在ERP、系统集成方面同样有比较成熟的解决方案。

Case 3.ERP 出库流程变更

该案例模拟了将出库流程变更为新流程的流程，该流程适用于代码更新、系统发布等事件。

例：原始ERP出库单如下：

在ITIL中，如果需要对现有系统做出变更，需要以下流程的支持:

配置管理是识别和确认系统的配置项，记录和报告配置项状态和变更请求，检验配置项的正确性和完整性等活动构成的过程。

变更管理是指为在最短的中断时间内完成基础架构或服务的任一方面的变更而对其进行控制的服务管理流程。

发布管理是指对经过测试后导入实际应用的新增或修改后的配置项进行分发和宣传的管理流程。发布管理以前又称为软件控制与分发，它由变更管理流程控制。

经过以上步骤，ERP新版出库单增加了拣货流程，修改为：

ITIL的变更控制，不仅仅适用于一些既有系统的维护与更新，还是用于一些开发、测试、发布、上线工作的标准化管理，比如我们的IT项目的需求变更、测试发布等工作。

李鸣(aicken)原创转载注明

本文链接

ITIL基础概述与实战案例分析(上)

2011-04-13T07:09:00Z

这篇文章将结合实例给大家介绍ITIL Foundation的管理方法和具体应用。目前ITIL Foundation主要有两个版本，分别是Vesion 2与Vesion 3，个人认为二者并不是取代关系，而是不同企业发展不同阶段的不同管理手法。

一．简述ITIL
ITIL，全称 Information Technology Infrastructure Library，译为“信息技术基础架构库”或“IT基础架构库”。

ITIL适合那些业务领域多而杂的公司实施，它提供了一种简单的思路来处理复杂的问题，如果根据 ITIL进行 IT管理，至少有两方面的好处:一是所有纳入ITIL服务体系的业务部门都可以根据一套用业务语言描述的可量化的质量指标，降低与IT部门的沟通与工作Redo成本；二是IT部门可以提高服务质量、降低服务成本、降低项目沟通的成本，将需求与其变更定义在一个尽量清晰的范畴内，以一种相对正规的方式来运作项目，这样后面的IT管理方法(软件工程、系统集成标准)才能派上用场。

二．Vesion2 VS Vesion3

在V2中更强调流程的管理，是IT管理的具体方法，它包括一个职能：服务台职能；十个流程：事件管理、问题管理、配置管理、变更管理、发布管理、服务级别、可用性、连续性、能力管理、财务管理。V2规范了IT对业务的服务提供和服务支持两条线，服务提供思路包括服务级别管理、可用性、连续性、能力管理、财务管理；服务支持思路包括事件管理、问题管理、配置管理、变更管理、发布管理。服务支持是服务提供的基础，服务提供是服务支持的改进思路。

在V3中该强调IT战略的梳理与落实方法，它是V2版本的精华并且加入了服务生命周期的概念，服务战略、服务设计、服务转换、服务运行、持续改进.

图1 ITIL V3服务生命周期

ITIL V3是V2版本的升华，它指出了流程并不是业务实现的全部，而只是其实现中的一部分，它可以影响业务实现，ITIL V3提到的IT服务管理包括决策、计划、设计、开发、测试、发布、运行和改进。

不管是软件工程还是ITIL，都是将IT管理中不可见的因素可见化，不可控的因素可控化，离散的因素量化，耦合的因素聚合化。它们都是在决策分析、团队建设、项目管理、投资运营中的一种思想和问题处理方式。

所以，实际上我觉得ITIL并不仅仅是针对IT的一种管理框架，它是企业管理的一种方法,这也正是ITIL V2的开发者英国商务部OGC的初衷。

三．基于ITIL思想的IT管理

IT对业务的管理的风险不仅仅是在于技术，关键在于一个“变”字，无论是何种管理思想，都在围绕一个“变”字进行。有规则、有章法、有计划的“变”是变更，这种变化是正常的、可持续的，我管这种变称为“协变”；任意的、独立的、无计划的“变”是失控，是定时炸弹，我管这种变称为“逆变”，这种“变”经常在以下场景出现：

由业务部门单向发起，没有经过业务需求分析与系统设计分析两者同时认可的需求“变”化。

出于某个操作或短期为了解决某个问题的需要，提出的“解决方案”

为了结果的快速导向，过度的协调了IT资源(IT资源是指：人力、时间、资金、支持、知识等)中的某一个，而忽视了其他资源，导致被忽视资源所对应的项目环节的薄弱。

实际上IT是为业务提供服务的部门，同时IT也是规整业务的部门，二者互相作用，IT对业务的支持不是按照业务部门的纯粹需要做纯粹的“服务”，而是要使用自己的专业知识，对需要进行加工，将“业务需要”变成“业务需求”，“业务需要”是不规整的、不可量化的、持续性低；“业务需求”是聚合的、可量化的、可持续的，这就是ITIL的真正本质的体现----即量化、流程、持续、改进。

有规则、有章法、有计划的“变”是变更，这种变化是正常的、可持续的，这一点可以使用“服务支持”流程应对，即事故管理、问题管理、配置管理、变更管理和发布管理，这套流程指出了问题的生产者与消费者之间的关系，从一个问题的诞生到问题的解决都给予了“应该”做的解释。

● 基于ITIL体系的IT部门建设

ITIL是一套建设与改进事物的方法，这套方法最多的应用于IT建设，在这套思想体系中，最大的使用了职能、流程、规范、周期来描述IT的模型，也就是说按照以上四个关键字建立的IT体系，就是符合ITIL体系的。

1.职能建设：

IT部门与职能建设，依据ITIL V3基本上分为：服务台职能(Service Desk Function)、运营管理职能(Operation Management Function)、技术管理(Technical Management Function)和应用管理(Application Management Function)。

服务台职能(Service Desk Function)是ITIL中一个最成熟的职能，它的应用很广泛，该职能和事件、问题、配置、变更、发布五个流程在下一节再讲述其在项目中的应用。

2.流程建设

○ SLAs：

很多项目或部门再出现问题时都希望IT部门能尽早尽快的解决，但是IT的资源是有限的，总要解决那些“重要的、应该首先解决”的问题，那么什么是“重要的”呢？这就涉及到了ITIL的服务级别管理，它是为签订服务级别协议（SLAs）而进行的计划、报告和评价，说白了就是合同，它确保组织所需的IT服务质量在成本合理的范围内得以维持并逐渐提高。

○ 财务管理：

IT服务财务管理是负责预算和核算的，并向客户收取相应服务费用的管理流程，这个流程甚至细化到打印纸张都划入各部门预算。

IT服务财务管理流程产生的预算和核算信息可以为服务级别管理、能力管理、IT服务持续性管理和变更管理等管理流程提供决策依据。

○ 持续性管理：

IT服务持续性管理是指确保发生灾难后有足够的技术、财务和管理资源来确保IT服务持续性的管理流程，它关注的焦点是在发生服务故障后仍然能够提供预定级别的IT服务，从而支持组织的业务持续运作的能力。

○ 能力管理：

能力管理是指在成本和业务需求的双重约束下，通过配置合理的服务能力使组织的IT资源发挥最大效能的服务管理流程。

○ 可用性管理

可用性管理是通过分析用户和业务方的可用性需求，设计IT基础架构的可用性。它应该有意识的规避潜在的风险，避免过度设计。

李鸣(aicken)原创转载注明

本文链接

The DotNet Garbage Collection

2011-04-12T07:04:00Z

今天开始发第一篇英文原创博客《The DotNet Garbage Collection》

The Garbage Collection is a very important part of DotNet platform.Today we will talk about it. Think about if not GC,DotNet is also called a platform? Although both languages are compiled into MSIL in dotnet, but when the recycling operation was "fighting each other", so that the programming will not only coding difficulty, but also make extremely complicated memory management ( language processing in different small differences, will be amplified in the recovery of resources), and it is not benefit to plantform transplanting.

This article will introduce the operation mode, algorithms, and associated of DotNet garbage collection ,and will show the key method of garbage collection.

Speaking of garbage collection, very few people know, is not associated with Java garbage collection occurs, as early as in 1958, Turing Award winner John invented the Lisp language has been provided to the function of GC, which is the first time in GC, a flash of thought! Then, in 1984, Dave Ungar invented the first official language Small talk with a GC mechanism.

. Net garbage collection is a big topic, if you did not come into contact with a similar language like C + +, it is difficult to understand how GC is an important and exciting things:

1. To improve the cohesion of software systems.
2. Reduce programming complexity, so that programmers do not have to deal with memory release.
3. Without prejudice to the abstract system designers.
4. Reduce the inappropriate use of memory produced by Bug.
5. Success of the memory management managed to the runing time, changes loopholes in the management of unpredictable to can be estimated.

Body:

This chapter will introduce "GC algorithms and working methods"," GC coding method analysis ".

Section. GC algorithms and working methods

1. Algorithm

The nature of the garbage collector is tracking all references OF the object, reorganize the objects which is no longer be used ,release current memory.

This sounds similar to something called the "reference count (Reference Counting) " algorithm, but this algorithm needs to traverse all the objects, and maintain their pointer, so some lower efficiency, and the problem of "reference cycle" will “give you some jokes” at some time,the "reference cycle" is the reason of memory leak. So. Net used a technique called "mark and clear (Mark Sweep) " method to accomplish the above tasks.

The algorithm of "Mark and clear ", the name suggests, has two skills:

" Mark " skills - garbage identification: the root from the application, marking the using of reference and making relationship with each other, traversal all objects which be allocated on the HEAP, the no referenced object will not be marked, its becomes garbage; survival of the object is Marked, the CLR will make (maintenance) the objects to a "root - reachable object" chart. "

In fact, CLR will maintenance those relations as a "tree", no doubt, the students understand data structures are known, structures of tree can up speed of traverse.

Checking, marking an object reference, is a very interesting thing, there are many ways to do it, but only one is optimal efficiency,. Net finish it by the stack, in the process of input and output stack.

First in the tree, select an object which is survival, all references(in running time) of the object will be push stack, ok,and then, CLR start to find another survival objec and redo above step, until the stack is empty. Stacks become empty means that CLR have been traversaled all survival object of the local root (or a tree node). Tree nodes includes local variables (local variables will be recovered very quickly, because its scope is very clear and very easy to be controlled), register, static variables, these elements have to repeat this operation. Once completed, gc will check all objects one by one and mark referred objects, then some objects become garbage because it is not be marked.

"Clear" skills - release memory: Enabling Compact algorithm, move the survival objects, change their pointers to make it contiguous in memory, so the free memory contiguous too, and it solved the problem of memory fragmentation When re-allocate memory for other object, CLR do not have to searching the free space in a debris memory, so speed of allocation will be improved.

However, large objects (large object heap) except, GC will not move a giant in-memory, because it knows that the CPU is not cheap. Normally, large objects have a long lifetime, when a large object in the. NET managed heap generation, it is assigned to a special part of the heap, because the performance improved by move large objects less than arrange the heap special.

The “Compact” algorithm can improve the speed when re-allocate memory ,if the new object in the heap allocated are compact, then the cache performance will be improved, because objects who was allocated together are often used together (the program locality principle), Therefore, a continuous space for the program is very important.

我是李鸣(Aicken) 请您继续关注我的下一篇文章。

本文链接

物以类聚，人以群分：晒晒与腾讯站在一起的企业们

2010-11-05T06:34:00Z

国内五家著名互联网企业，金山、搜狗、傲游、可牛、百度今早联手举行发布会，表示将选择不兼容360系列软件。那么这五家“知

名”的互联网公司又是什么样的公司呢？就让我们来回忆一下吧。

金山：嗯，业界挺有名的，不过最拿得出手的不是什么“毒霸”，而是应该是游戏，单机版剑侠系列游戏可在国内大陆地区首屈一

指，网游剑侠系列就不怎么样了，简直是一个装备买卖系统，玩家只靠钱就能有装备和等级，而且后来官方竟然提供白驹丸这样的

挂机道具，这和外挂有何区别呢？
再说说金山毒霸，刚推出时，竟然查不出冰河服务端，这个连知名木马都放过的玩意，还有脸出来对别的产品说三道四？

搜狗：互联网里流传着这样一句话，没上网的都知道搜狐，上网的都不去搜狐。呵呵这是由一定道理的，张Sir影视歌网四栖明星多

多少少拿网联网当娱乐做。再说搜狗，做的不错，但可有可无，Google输入比你也不差！

遨游：一家失败的软件公司，别糟蹋遨游的名字了。

百度：为建立河蟹圈始终不懈奋斗，不惜挥刀阉割掉那个谁不希望网民知道的信息，试问你李彦宏，为一己私利你把用户知情权与

事实本真放在哪里？
还有百度那个臭名昭著的竞价排名，只要给钱你百度就大肆认为修改搜索结果，将大量假冒劣质信息排在首位，你可真便宜啊，给

钱就能“上”啊！
百度工具栏，刚推出时你不也是和CNNIC一样，在用户不知情的情况下强行安装无法彻底卸载吗！不过你就是点背，百度工具栏刚推

出不久360就出了卸载恶意软件的工具，想必你的非法利益受到很大的打击吧！

可牛：什么东西？点心吗？

腾讯：与上五家公司一样，一个被360触犯经济利益的公司，撕破脸皮般的不承认扫描用户硬盘数据的事实，打着维护用户利益为用

户着想的旗帜，卸载竞争对手的产品。物以类聚人以群分，与腾讯统一战线的都是些什么东西，腾讯会是什么东西呢？

本文链接

极限挑战—C#+ODP 100万条数据导入Oracle数据库仅用不到1秒

2010-08-31T07:36:00Z

.Net程序中可以通过ODP调用特性，对Oracle数据库进行操作，今天来讲一下数据批量插入的功能，所用技术不高不深，相信很多朋友都接触过，小弟班门弄斧了，呵呵。这篇文章是上篇文章的续集，因为上一次试验的征集结果没有突破4秒的方法，所以这次继续挑战与挖掘新方法，虽然是Oracle，但仍具有一定收藏意义。

上一次文章中提及的试验：

极限挑战—C#100万条数据导入SQL SERVER数据库仅用4秒 (附源码)

http://www.cnblogs.com/isline/archive/2010/03/18/1688783.html

这个试验是针对SQL SERVER数据库的，宿主环境也是.Net，有兴趣的朋友可以将这两个试验对比一下，为日后工作批量导数提供支持。

另外，一些朋友对上次试验环境有些异议，认为应该对数据库和服务器做优化或设置，以体现试验最终的时间结果。这个固然会影响试验的时间结果，但考虑到在试验环境中，对数据库优化的标准与优化程度不便统一与定量，试验结果也不易说明其影响源，所以这次试验依然以标准数据库建库后的配置为主，试验所在服务器硬件环境与上次试验保持一致。实验目的在于挖掘、对比宿主程序中的数据批量操作方法。

有新方法提升性能时间指标的朋友，欢迎互相切磋，互相提高，嘴上功夫就免了。。。

好了正文开始。

● 普通肉垫式

什么叫批量插入呢，就是一次性插入一批数据，我们可以把这批数据理解为一个大的数组，而这些全部只通过一个SQL来实现，而在传统方式下，需要调用很多次的SQL才可以完成，这就是著名的“数组绑定”的功能。我们先来看一下传统方式下，插入多行记录的操作方式：

//设置一个数据库的连接串，

string connectStr = "User Id=scott;Password=tiger;Data Source=";

OracleConnection conn = new OracleConnection(connectStr);

OracleCommand command = new OracleCommand();

command.Connection = conn;

conn.Open();

Stopwatch sw = new Stopwatch();

sw.Start();

//通过循环写入大量的数据，这种方法显然是肉垫

for (int i = 0; i < recc; i++)

{

string sql = "insert into dept values(" + i.ToString()

+ "," + i.ToString() + "," + i.ToString() + ")";

command.CommandText = sql;

command.ExecuteNonQuery();

}

sw.Stop();

System.Diagnostics.Debug.WriteLine("普通插入:" + recc.ToString()

+ "所占时间:" + sw.ElapsedMilliseconds.ToString());

我们先准备好程序，但是先不做时间的测定，因为在后面我们会用多次循环的方式来计算所占用的时间。

● 使用ODP特性

看上面的程序，大家都很熟悉，因为它没有用到任何ODP的特性，而紧接着我们就要来介绍一个神奇的程序了，我们看一下代码，为了更直观，我把所有的注释及说明直接写在代码里：

//设置一个数据库的连接串

string connectStr = "User Id=scott;Password=tiger;Data Source=";

OracleConnection conn = new OracleConnection(connectStr);

OracleCommand command = new OracleCommand();

command.Connection = conn;

//到此为止，还都是我们熟悉的代码，下面就要开始喽

//这个参数需要指定每次批插入的记录数

command.ArrayBindCount = recc;

//在这个命令行中,用到了参数,参数我们很熟悉,但是这个参数在传值的时候

//用到的是数组,而不是单个的值,这就是它独特的地方

command.CommandText = "insert into dept values(:deptno, :deptname, :loc)";

conn.Open();

//下面定义几个数组,分别表示三个字段,数组的长度由参数直接给出

int[] deptNo = new int[recc];

string[] dname = new string[recc];

string[] loc = new string[recc];

// 为了传递参数,不可避免的要使用参数,下面会连续定义三个

// 从名称可以直接看出每个参数的含义,不在每个解释了

OracleParameter deptNoParam = new OracleParameter("deptno",

OracleDbType.Int32);

deptNoParam.Direction = ParameterDirection.Input;

deptNoParam.Value = deptNo;

command.Parameters.Add(deptNoParam);

OracleParameter deptNameParam = new OracleParameter("deptname",

OracleDbType.Varchar2);

deptNameParam.Direction = ParameterDirection.Input;

deptNameParam.Value = dname;

command.Parameters.Add(deptNameParam);

OracleParameter deptLocParam = new OracleParameter("loc",

OracleDbType.Varchar2);

deptLocParam.Direction = ParameterDirection.Input;

deptLocParam.Value = loc;

command.Parameters.Add(deptLocParam);

Stopwatch sw = new Stopwatch();

sw.Start();

//在下面的循环中,先把数组定义好,而不是像上面那样直接生成SQL

for (int i = 0; i < recc; i++)

{

deptNo[i] = i;

dname[i] = i.ToString();

loc[i] = i.ToString();

}

//这个调用将把参数数组传进SQL,同时写入数据库

command.ExecuteNonQuery();

sw.Stop();

System.Diagnostics.Debug.WriteLine("批量插入:" + recc.ToString()

+ "所占时间:" +sw.ElapsedMilliseconds.ToString());

以上代码略显冗长，但是加上注释后基本也就表达清楚了。

好了，到目前为止，两种方式的插入操作程序已经完成，就剩下对比了。我在主函数处写了一个小函数，循环多次对两个方法进行调用，并且同时记录下时间，对比函数如下：

for (int i = 1; i <= 50; i++)

{

Truncate();

OrdinaryInsert(i * 1000);

Truncate();

BatchInsert(i * 1000);

}

当数据量达到100万级别时，所用时间依然令人满意，最快一次达到890毫秒，一般为1秒左右。

经过试验，得出一组数据，可以看出两种方式在效率方面惊人的差距（占用时间的单位为毫秒），部分数据如下：

记录数	标准	批处理
1000	1545	29
2000	3514	20
3000	3749	113
4000	5737	40
5000	6820	52
6000	9469	72
7000	10226	69
8000	15280	123
9000	11475	83
10000	14536	121
11000	15705	130
12000	16548	145
13000	18765	125
14000	20393	116
15000	22181	159

因为篇幅原因，不再粘贴全部的数据，但是我们可以看一下由此数据生成的散点图：

其中有些数据有些跳跃，可能和数据库本身有关系，但是大部分数据已经能说明问题了。看了这些数据后，是不是有些心动了？

源程序放了一段时间直接拷贝贴过来了，可能需要调试一下才能跑通，不过不是本质性问题，对了如果要测试别忘记安装Oracle访问组件。

本文链接