博客园_快速代码生成+基础框架

.NET 应用程序界面开发经验总结设计良好的程序的表现之一就是细节做的还可以

2012-01-06T01:17:00Z

做程序主要体现的是细节，细节方面做的好，用户会觉得你的软件比较专业。良好的架构与设计模式可以使维护方便。在用户这边，要花一些心思琢磨用户的想法。有时候用户比我们的界面设计还专业，用户有很强的行业知识，他见识过的同行业的软件比我们多。下面的这几点界面设计的体会和经验，来自于用户，在这里与大家分享。

1 如果要写数据项到注册表中，最好以加密的形式保存

虽然.NET提倡的是XCOPY，但有时还是需要写一些必要的信息到注册表中，以减少用户的配置出错的可能性。比如，自动更新功能中，需要把自动更新的网址写到注册表中。ASP.NET Web程序如果不使用默认的80端口，也推荐在安装程序时把Port写到注册表中。对于需要用户反馈的程序，一种默认方法是把用户的feedback内容发送到邮箱中，这时需要提供邮箱的注册用户名和密码，这种情况是必须要加密的。

有时候不小心看了一下自己的注册表(regedit)内容，也是惨不忍睹，大量的程序都会写数据项到注册表中。

2 界面划分的基本原则是信息分类，将同类的信息放在一起，集中显示。

这是物料主档的功能的界面，先分大类，用Tabcontrol分开，基本信息，环保指令，包装规格，计划数据，附件信息。大类里面再小的类别，用GroupBox分开，比如控制点，规格。

规格这个地方，使用了ComboBox，这个有待于商量。当选择的数据项比较多时，应当使用ComboBox，数据项比较少时，我以为用RadioButton要合适一些,这也取决于空间的大小程度。

这个图片中有两组Item Type，上面一组是ComboBox的翻版，下面一组对文字进行了简化调整。

使用ComboBox的好处是，当它的item发生变化时，界面不需要变动，而RadioButton做不到这一点，也许这是选择ComboBox的一个很好的理由。

对信息分类导向的界面设计国中，菜单项的深度也应该尽量保持在三层以内，对相同的功能进行分类。请看下图

只用了二层，相同的功能菜单里面，还可以用分割符号分开，以增加可读性。

3 界面中的名词选择尽量选择专业的词汇，避免通用的词汇。比如以前我做ERP系统控制面板，总会加上Managment这个词语，如Sales Management/Purchasing Management以表达销售管理,采购管理，Management这个词语应该去掉。在很多信息分类的TabControl中，通常第一个tab page的名字叫General或者上面例子中的Basic Information,或General Information，当系统中有多个这样的界面布局时，应该保持一致。比如上面的物料主档用了Basic Information，其它的地方，在基本信息的tab page中也应该用Basic Information。举例说明

采购收货的界面，第一个tab page使用General Information。

物料清单的界面，第一个tab page也使用了General Information。

4 界面设计时字体的选择。
以我的选择，功能界面中使用Microsoft Sans Serif, 8.25pt字体。状态栏(status)和菜单(menu)使用默认的Segoe UI, 9pt。对于功能界面，除了规定程序员在设计时使用指定的字体外，还在运行时，循环遍历一下界面中的界面控件，对不是标准字体的控件予以调整。字体统一，界面才看起来整洁，美观。

不推荐在控件中使用特殊的字体，尽管你可以在部署的时候把字体也拷贝到目标机器中。Crystal Report的报表中，需要使用一些特殊的字体，运行报表前应该检测字体是否存在。比如你可以把字体以嵌入的资源的方法嵌入到程序集中，如果目标机器的指定的字体不存在，可以从程序集的资源中释放字体到字体文件夹中。

5 对可能造成数据无法恢复的操作必须提供确认信息,提供用户放弃选择的机会。比如删除数据，退出功能时没有保存数据，耗费很长时间的MRP运算。这在开始操作前，要给用户有反悔的选择。
对于删除确认，有一种情况，就是对用户的设计予以认可，充分信任。比如用户在设计菜单界面时，要删除一条菜单，这时，不应该弹出确认删除的对话框。Visual Studio中删除一项MenuStripItem时，没有要我们确认删除。

正准备Delete菜单项中的New项，Visual Studio会认可你的操作，没有要你确认之后再删除。

因为这个理由，我在自定义的Menu Designer，Form Designer，Workflow Designer中都实行这个策略，充分信任用户的操作。

本文链接

Visual Studio 2010 开发与调试IronPython脚本为你的ERP/MIS 应用程序添加脚本功能

2012-01-05T01:25:00Z

时间过得真快，Visual Studio 2010推出来快两年了，.NET 4.0也逐渐普及。.NET 4里面有一项重要的功能，就是动态语言，可以在.NET代码中直接调用第三方的动态语言脚本，请参考下面的例子程序

ScriptRuntime py = Python.CreateRuntime();
//Dynamic feature only works on objects typed as 'dynamic'
dynamic helloworld = py.UseFile("helloworld.py");

Console.WriteLine("helloworld.py loaded!");
for (int i = 0; i < 1000; i++)
{
Console.WriteLine(helloworld.welcome("Employee #{0}"), i);
}

这是Visual Studio 2010中使用IronPython的例子，为了运行这个程序，请下载IronPython, 例子中的的源代码如下

def welcome(name):
return "Hello '" + name + "' from IronPython"

学到了这么多技术，最终都是为了改善产品，改善系统的可维护性。在之前的文章中我提到为应用程序添加脚本功能，可产生定制的动态的代码块，然后返回执行结果。这项功能为应用程序的灵活性提供了极大的方便。我在工作流的表达式求值，工资公式编辑器中有提到动态脚本Script.NET的能力。然而Script.NET停止开发很久了，而且我一直期盼的调试功能又没有实现出来。自己参考SharpDevelop做script debugger,没有结果，只好暂时停止对Script.NET的进一步探索与应用。现有IronPython 2.7.1 已经直接做成了Visual Studio的解决方案项目，简单方便省事。

几乎不用任何配置，直接安装下载回到的IronPython-2.7.1安装文件即可，它会为你的Visual Studio创建Python项目模板。在x86的电脑上，可以产生四个类型的项目模板，Console Application,WinForms Application,IronPython Silverlight Web Page，Wpf Application,而在x64的平台上，只产生了Console Application项目模板。

但是，这样还有点不方便，Python在这里被当成脚本语言，它的Build Action=None,意味着没有任何编译行为，这样会给代码的调试工作带来不方便之处。需要安装工具Python Tools for Visual Studio。

先卸载已经安装的IronPython工具包，才能继续安装Python Tools for Visual Studio。安装完成之后，项目模板又多了二项模板，Python Application和Python MPI Application。新建立一个Python Application项目

请先到Tools->Options的Python Tools中新建一个Interpreter，在Interpreter Options中点击Add Interpreter按钮，保存退出即可。然后就可直接在编辑器中放断点，调试的体验和调试.NET语言一样，Call Stask,Intermediate Window,Watch窗口都可用，这种感觉是相当的方便。再看看Program.py的文件属性，它的Build Action=Compile。

在安装工具包的同时，也同时会安装Python的命令行交互程序，这个程序可以当计算器用，直接输入表达式的值，它可以马上帮助你计算出结果。再来看看下面的Python的两个例子代码，以帮助你了解和学习这种语言。

Lambda表达式，这个可以简化代码的编写，请看Python的实现

func = lambda s: s * 3
print func("peter ")

func2 = lambda a, b: a * b
print func2(2, 3)

调试这段代码，在Output窗口可以显示它的执行结果。Lambda表达式减少了很多不必要的代码。

Python的for循环语句，它的一种写法是这样的

for i in range(0, 10,2):
print i

起始变量0，10是终止变量(不包括10)，2是步长。.NET 4中引入了并行循环，它的代码例子如下

Parallel.For(0, Int64.MaxValue, i =>
{

Console.WriteLine("i={0},thread id={1}", i, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(1000);
});

整理一下文章的思路，您首先要选择一门脚本语言，来为你的应用程序提供动态代码执行能力。在这里，我选择Python语言，并选择它的.NET实现版本IronPython。其次，我要对脚本与.NET host之间的代码互操作有所了解，如何把.NET的变量传到脚本中，如何传回脚本的执行结果到.NET代码中。最后，我需要一个灵活方便的脚本编辑工具，并且可以提供强大的调试功能。

本文链接

总结一下ERP .NET程序员必须掌握的.NET技术，掌握了这些技术工作起来才得心应手

2011-12-31T01:05:00Z

从毕业做.NET到现在，有好几年了，自认为只能是达到熟练的水平，谈不上精通。所以，总结一下，自己到底熟练掌握了哪些.NET方面的开发技术，以此对照，看看还有哪些不足，欢迎补充。

1 .NET Framework常见的API要熟练掌握。有些API可能需要多个类型配合使用，也有必要掌握。

IEntity2 clonedEntity = null;
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream memStream = new MemoryStream())
{
formatter.Serialize(memStream, sourceEntity);
memStream.Seek(0, SeekOrigin.Begin);
clonedEntity = (IEntity2)formatter.Deserialize(memStream);
}

这个例子是.NET的深拷贝(deep copy)的实现，类似于这样的例子，还有很多。这些API的组合应用是需要掌握的。经过积累后，通常都会有自己的一个Utility类型库。

2 Linq to Object。虽然Linq to SQL已经被抛弃和遗忘，但是Linq to Object还真是一项很重要的技术。如果没有这项技术，数据的查找和操作的代码会被foreach充满，这样不容易维护，而且有很多代码都是routine代码，可以省略的。

string[] names = { "Tom","Dick","Harry","Mary","Jay" };
IEnumerable<string> query =
from n in names
where n.Contains ("a") // Filter elements
orderby n.Length // Sort elements
select n.ToUpper( ); // Project each element

foreach (string name in query)
Console.Write (name + "/");

同时，与Linq搭配的技术Lambda技术，可以简化很多代码，这也需要掌握，上面的例子用Lambda技术改写一下

string[] names = { "Tom","Dick","Harry","Mary","Jay" };
IEnumerable<string> query = names
.Where (n => n.Contains ("a"))
.OrderBy (n => n.Length)
.Select (n => n.ToUpper( ));

foreach (string name in query)
Console.Write (name + "|");

曾经有个非常流行的考试题目，考察委托的三种写法，举例如下所示

List<int> list = new List<int>();
list.AddRange(new int[] { 1, 5, 10, 20 ,33 });

//使用传统委托语法调用FindAll
Predicate<int> callback = new Predicate<int>(IsEvenNumber);
List<int> evenNumbers = list.FindAll(callback);

//使用匿名方法
List<int> evenNumbers = list.FindAll(
delegate(int i)
{
return (i % 2) == 0;
});

//使用Lambda表达式
List<int> evenNumbers = list.FindAll(i => (i % 2) == 0);
(代码来自于LINQ之路 3：C# 3.0的语言功能（下））

3 .NET 4引入了新的并行编程库。这项技术不同于多线程技术，它是适应多核时代的需要。来看下面的例子程序

static double ParallelPi()
{
double sum = 0.0;
double step = 1.0 / (double)num_steps;
object monitor = new object();
Parallel.For(0, num_steps, () => 0.0, (i, state, local) =>
{
double x = (i + 0.5) * step;
return local + 4.0 / (1.0 + x * x);
}, local => { lock (monitor) sum += local; });
return step * sum;
}

有了新面的Lambda表达式基础，这个例子也不难读懂。这是用并行库求PI的值。

.NET 4还引入了动态语言，如下的例子所示，Python的例子

ScriptRuntime py = Python.CreateRuntime();
//Dynamic feature only works on objects typed as 'dynamic'
dynamic helloworld = py.UseFile("helloworld.py");
Console.WriteLine("helloworld.py loaded!");

for (int i = 0; i < 1000; i++)
{
Console.WriteLine(helloworld.welcome("Employee #{0}"), i);
}

//Python的代码
def welcome(name):
return "Hello '" + name + "' from IronPython"

如果要改善.NET程序的性能，可以考虑使用.NET并行库。如果你在寻找脚本语言，可以寄宿到.NET中方便调用，这里的Python应该是一个很好的开始。对于.NET框架直接内置的技术，必定会有大量的第三方工具，产品来对它做Enhancement或Extension,你可以找到很称手的工具，为你的项目增加灵活性和改善性能。

4 ORM开发技术。可以选择NHibernate，也可以选择Entity Framework。ORM技术可以让你的代码专注于业务逻辑，大大简化数据访问代码的编码与调试。此外，ORM技术支持界面与逻辑分离，强类型的数据绑定，这些好处，都可以给你的项目增加灵活性。比如保存客户的代码，用ORM技术写，是这样的

using (DataAccessAdapterBase adapter =GetDataAccessAdapter())
{
try
{
adapter.StartTransaction(IsolationLevel.ReadCommitted, "SaveCustomer");
adapter.SaveEntity(Customer, true, false);
adapter.Commit();
}
catch
{
adapter.Rollback();
throw;
}
}

可不能小看了这几句，首先它是用代码生成器生成的，其次，对于增改数据库字段，这里不用作任何的修改，再次，界面的变动和业务逻辑的变动，也不会影响到这里。就这几项好处，可以节约大量的时间，让你专注于业务逻辑。

5 分布式的通讯技术。.NET Remoting和WCF，至少要掌握一项才行。

6 界面组件包。.NET 框架自带的界面控件虽然简单好用，但不够强大。所以，推荐你选购一套流行的界面控件，为你的项目增加可读性。虽然都是说界面不重要，逻辑重要，但是我们心里也明白，界面看起来惨不忍睹，再好的逻辑和架构也也不会被客户接受。界面要做到简单，实用，说起起容易，做起来可相当不容易。这里可以选择的控件比较多，Infragistics,Syncfusion,ComponentOne，都是很著名的控件供应商。

本文链接

应用反射技术为Infragistics Solution设计例子程序代码简洁而且学习的效率高

2011-12-29T01:45:00Z

公司的ERP系统是采用Infragistics的控件，这个系列的组件非常庞大，功能很多。在学习的过程中，经常需要查找它的Sample来了解它的属性，经过一段时间的研究，就想到把它的Sample重新组织一下以方便学习。有些Sample是VB写的，只熟悉C#程序，VB可以看懂但不能用于编程开发，于是就用VB Converter转换为C#代码

点击Convert Anywan进行转换，转换正确率达99%，遇到索引(index)转换需要手工修改，比如C#中DataRow drow[“CustomerId”] 这样引用列，转换后是的结果是drow(“CustomerId”)。

于是乎，三下五除二就把它的例子程序转移到了C#的解决方案中，形成我的Infragistics Solution。

这样集中学习它的例子，下次忘记了查阅这个解决方案文件和记得笔记代码，效果不错。

有一个地方还需要改善一下，Infragistics 公司提供的NetAdvatange Sample是一个个独立的解决方案文件。这在安装程序，维护版权方面是很有用的，但是不利于学习研究。它的每一个Sample中都有这样的代码

[STAThread]
static void Main()
{
Application.Run(new Form1());
}

Form1看起来并不刺眼，通常在Sample程序中，这表示是没有任何修改的通过Visual Studio模板生成的窗体。

比较麻烦的是，经过我的合并与添加，最后形成这样一个文件佳结构，以UltraGrid为例子

Intermediate Tutorial2中还有更多的例子，如果要写代码调用它们，可能要写很多个new Form1的代码，而且要经常修改启动窗体，这样显然不合理，有些麻烦。在熟练应用了反射技术后，自然就想到了动态生成类型与调用。

添加一个MainForm作为启动窗体，添加treeView控件，以显示Sample中的Form，在Form_Load中增加代码

private void InfragisticsSolutionForm_Load(object sender, EventArgs e)
{
Assembly assembly = Assembly.GetExecutingAssembly();
TreeNode root = tree.Nodes.Add("Infragistics Solution");
foreach (Type type in assembly.GetTypes())
{
TreeNode node= root.Nodes.Add(type.FullName);
node.Tag = type;
}
root.ExpandAll();
}

这样就把这个解决方案中的Form都添加到了窗体树中，生成的窗体效果如下图所示

再来设计启动Sample窗体的代码，在treeView的MouseDoubleClick和Call按钮的点击事件中调用如下的代码

if (tree.SelectedNode.Tag != null )
{
Type type = tree.SelectedNode.Tag as Type;
Form frm = Activator.CreateInstance(type) as Form;
if (frm != null)
{
frm.Show(this);
}
}

这样就轻松的完成了Sample窗体的启动。还有一个地方值得改善，每次点击Call 按钮之后，都会new窗体，这会消耗大量的内存，Form没有显示在用户界面中，并不表示它已经从内存中被GC当成垃圾回收，经过改良后的代码如下

if (tree.SelectedNode.Tag != null )
{
Type type = tree.SelectedNode.Tag as Type;
Form frm=Application.OpenForms[type.Name];
if (frm != null)
{
if(!frm.Visible)
frm.Show(this);
return;
}
frm = Activator.CreateInstance(type) as Form;
if (frm != null)
{
frm.Show(this);
}
}

先从Application.OpenForms查找已经开启的窗体，如果有就把它显示出来。这个代码有个问题，type.Name为Form1，如果其它的窗体也叫这个名字Form1,尽管他们在不同的命名空间中。这样，其它的Form1名称的窗体都无法打开，如果改进type.FullName,则frm每次都是null，像这样修改过之后

Form frm=Application.OpenForms[type.FullName];

即使窗体已经显示出来了，frm的值也是null。查找MSDN文档，Name定义就是取自InitializeComponent

private void InitializeComponent()
{
this.Name = "Form1";
}

这种缓存的办法是失效的，无法达到节约内存的目的。经过数次的调整与修改，最后的代码如下

if (tree.SelectedNode.Tag != null )
{
Type type = tree.SelectedNode.Tag as Type;
Form frm = null;
if (_types.Contains(type))
{
foreach (Form t in _forms)
{
if (t.GetType().FullName.Equals(type.FullName))
{
frm = t;
break;
}
}
if(frm.IsDisposed)
frm = Activator.CreateInstance(type) as Form;
if (!frm.Visible)
frm.Show(this);

return;
}

frm = Activator.CreateInstance(type) as Form;
if (frm != null)
{
frm.Show(this);
_types.Add(type);
_forms.Add(frm);
}
}

两个集合分别用来存放缓存的对象和实例子，定义如下

List<Form> _forms;
List<Type> _types;

希望能对你有帮助。

本文链接

Linq to LLBL Gen Pro LLBL Gen的Linq程序设计

2011-12-28T01:14:00Z

继续讲解LLBL Gen的开发教程，这一篇学习Linq to LLBL Gen的应用。

MSDN对Linq的解释如下：LINQ（语言级集成查询）的意图就是提供一种统一且对称的方式，让程序员在广义的数据上获取和操作数据。虽然Linq to SQL已经不再更新，但是Linq to xml,Linq to Object仍然很实用，它可以简化程序代码的编写。在没有Linq的.NET 2.0时代，通常只能用foreach循环遍历来查找满足条件的数据。

LinqMetaData

如果要在LLBL Gen的项目中使用Linq，首先要保证你的项目属性是.NET 3.0/3.5以上，这会调用Linq的模板生成需要的元数据。在生成的DatabaseGeneric中会产生Linq的文件夹，并且增加类型LinqMetaData。它的定义如下所示

public partial class LinqMetaData: ILinqMetaData
{
#region Class Member Declarations
private IDataAccessAdapter _adapterToUse;
private FunctionMappingStore _customFunctionMappings;
private Context _contextToUse;
#endregion

/// <summary>CTor. Using this ctor will leave the IDataAccessAdapter object to use empty.
/// To be able to execute the query, an IDataAccessAdapter instance
/// is required, and has to be set on the LLBLGenProProvider2 object in the query to execute.
///</summary>
public LinqMetaData() : this(null, null)
{
}
}

这里省略了一些方法和属性，请参考生成的类型来学习它的代码。要使用Linq,请传入当前项目的DataAccessAdapter

using(DataAccessAdapter adapter = new DataAccessAdapter())
{
LinqMetaData metaData = new LinqMetaData(adapter);
var q = from c in metaData.Customer
where c.Country=="USA"
select c;
// enumerate over q here so it gets executed
}

为什么可以这样的写？因为LinqMetaData提供了Customers的集合属性，定义如下所示

/// <summary>returns the datasource to use in a Linq query when targeting CustomerEntity instances in the database.</summary>
public DataSource2<CustomerEntity> Customer
{
get { return new DataSource2<CustomerEntity>(_adapterToUse, new ElementCreator(), _customFunctionMappings, _contextToUse); }
}

LLBL Gen提供了两种模式的代码调用方式：Adapter和SelfServicing，导致同一种类型要定义二次。比如SelfServicing中实体定义为IEntity，而Adapter则定义于IEntity2，在名称后面加一个数字2。以此类推，凡是类型名后面有数字2的，表示它适用于Adapter模式。Customer属性是定义一个数据源对象。

在这里，推荐安装测试工具软件TestDriven.NET,它的Personal版本完全免费。在任何一个.NET项目文件中，新建立一个方法，点击右键Test With->Debugger，很方便的调试一段代码。因为这个软件，我就再也没有使用很著名的代码片段编辑工具Snippet Compiler，TestDriven.NET会让带给你编写.NET测试代码非常便利的体验。

转化Linq 查询结果

使用Linq to LLBL Gen查询数据之后，如果要把数据绑定到界面中，则需要提供成Entity2或EntityCollection样式。

这里有ILLBLGenProQuery接口用于转化Linq查询结果，以减少我们自已转化的代码。

var q = from c in metaData.Customer
where c.Country=="Germany"
select c;
EntityCollection<CustomerEntity> customers =
((ILLBLGenProQuery)q).Execute<EntityCollection<CustomerEntity>>();

如代码所示，customers就可以直接用于绑定到界面的GridView或DataGridView中。

写到这里，发现Windows Live Writer的Insert Code有一个小bug：对Linq查询中的from/select关键字没有高亮显示。瑕不掩玉，这个Insert Code工具帮助我的博客中的规范化的代码方面产生了重要作用。

Group by 分组

按照国家和城市为组，对客户进行分类

var q = from c in metaData.Customer
group c by new { c.Country, c.City } into g
select new { g.Key, g.Count()};

按照客户的国家分类

var q = from c in metaData.Customer
group c by c.Country into g
select g;

Order By 排序

var q = from c in metaData.Customer
orderby c.CustomerId[1]
select c;

CustomerEntity的CustomerId属性是一个字符串，按照它的第二个字母排序。

Queryable: Contains 包含的查询

// Query 1, 检查实体是否在集合中 simple entity check in entity list
var q = from c in metaData.Customer
where c.Orders.Where(o=>o.EmployeeId==3).Contains(order)
select c;

// Query 2, 操作数是查询结果的实体集 operand is entity which is result of query
var q = from c in metaData.Customer
where c.Orders.Contains(
(from o in metaData.Order
where o.EmployeeId == 2 select o).First())
select c;

// Query 3, 操作数和源都是查询operand and source are both queries.
var q = from c in metaData.Customer
where c.Orders.Where(o => o.EmployeeId == 2).Contains(
(from o in metaData.Order
where o.EmployeeId == 2 select o).First())
select c;

// Query 4, 查询中的常量比较 constant compare with value from query. Yes this is different.
var q = from c in metaData.Customer
where c.Orders.Where(o => o.EmployeeId > 3).Select(o => o.ShipVia).Contains(2)
select c;

// Query 5, 检查常量表是否在查询结果中 check if a constant tuple is in the result of a query
var q = from c in metaData.Customer
where c.Orders.Select(oc => new { EID = oc.EmployeeId, CID = oc.CustomerId }).Contains(
new { EID = (int?)1, CID = "CHOPS" })
select c;

// Query 6, as 5 but now compare with a tuple created with a query
var q = from c in metaData.Customer
where c.Orders.Select(oc => new { EID = oc.EmployeeId, CID = oc.CustomerId }).Contains(
(from o in metaData.Order where o.CustomerId == "CHOPS"
select new { EID = o.EmployeeId, CID = o.CustomerId }).First())
select c;

// Query 7, 检查实体的属性是否包含指定的常量集合 checking if the value of a field in an entity is in a list of constants
List<string> countries = new List<string>() { "USA", "UK" };
var q = from c in metaData.Customer
where countries.Contains(c.Country)
select c;

// Query 8, 与7对比，换成IEnumerable。as 7 but now with an IEnumerable
LinkedList<string> countries = new LinkedList<string>(new string[] { "USA", "UK"});
var q = from c in metaData.Customer
where countries.Contains(c.Country)
select c;

// Query 9, combination of 2 queries where the first is merged with the second and
// only the second is executed. (this is one of the reasons why you have to write
// your own Funcletizer code.
var q1 = (from c in metaData.Customer
select c.Country).Distinct();
var q2 = from c in metaData.Customer
where q1.Contains(c.Country)
select c;

// Query 10, as 7 but now with an array obtained from another array.
string[][] countries = new string[1][] { new string[] { "USA", "UK" } };
var q = from c in metaData.Customer
where countries[0].Contains(c.Country)
select c;

// Query 11, complex contains query with comparison of in-memory object list
List<Pair<string, string>> countryCities = new List<Pair<string, string>>();
countryCities.Add(new Pair<string, string>("USA", "Portland"));
countryCities.Add(new Pair<string, string>("Brazil", "Sao Paulo"));

// now fetch all customers which have a tuple of country/city in the list of countryCities.
var q = from c in metaData.Customer
where countryCities.Contains(
(from c2 in metaData.Customer
where c2.CustomerId == c.CustomerId
select new Pair<string, string>()
{ Value1 = c2.Country, Value2 = c2.City }).First())
select c;

Linq的查询有些复杂，如果不能理解，可以在工作中需要用到的时候再来仔细体会。

Excluding / Including fields 不包含/包含字段

这个需求很重要。在写SQL语句时，不要写SELECT *，而是用具体的字段名，Excluding / Including 也就是用来指定需要SELECT出来的字段名。下面的查询，在查询结果集中不包括Photo和Notes字段。

var q = (from e in metaData.Employee
select e).ExcludeFields(e=>e.Photo, e=>e.Notes);

Calling an in-memory method in the projection 在Linq投影中调用方法

/// Utility class which obtains value from a webservice
public class InMemoryCallExample
{
public static int GetInterestRate(string customerId)
{
return MyService.GetInterestRate(customerId);
}
}

// this class can now be used in the following query:
var q = from o in metaData.Order
select new
{
o.OrderId,
InterestRate = InMemoryCallExample.GetInterestRate(o.CustomerId)
};

在Linq的返回结果中调用方法，select new产生一个匿名对象，可以对它进行再调用方法处理加工。

也可以直接用Lambda表达式来完成这样的操作，例子代码如下所示

Func<string, string> stringChopper = s=>s.Substring(0, 3);

// this function can now be used in a query:
var q = from c in metaData.Customer
select stringChopper(c.CompanyName);

Prefetch paths 子查询

方法 1: WithPath and PathEdges

// query A
var q = from c in metaData.Customer.WithPath(...) select c;

// query B
var q = (from c in metaData.Customer select c).WithPath(...);

// query C
var q = (from c in metaData.Customer.WithPath(...) where ... select c) join o in metaData.Order on ...

方法2：WithPath and Lambda expressions

var q = (from c in metaData.Customer
where c.Country=="UK"
select c).WithPath(p=>p.Prefetch(c=>c.Orders));

Function mappings 函数映射

从开头的一段代码中我们看到，Linq to LLBL Gen会产生直接的数据库查询动作。查询数据库时，ORM框架也会调用一些数据库系统的函数，比如SUM,AVG或是自定义的函数，这就要求有一种机制来定义函数的调用方法。

数据库函数定义代码如下

ALTER FUNCTION fn_CalculateOrderTotal(@orderID int, @useDiscounts bit)
RETURNS DECIMAL
AS
BEGIN
DECLARE @toReturn DECIMAL

SELECT @toReturn = SUM((UnitPrice-(Discount * @useDiscounts)) * Quantity)
FROM [Order Details]
WHERE OrderID = @orderID
GROUP BY OrderID

RETURN @toReturn
END

LLBL Gen的代码生成工具会对这个函数进行.NET封装调用，产生如下所示的代码以调用数据库中的fn_CalculateOrderTotal

public class NorthwindFunctions
{
public static decimal CalculateOrderTotal(int orderId, bool useDiscounts)
{
// empty body, as it's just here to make the query compile. The call is converted to a SQL function.
return 0.0M;
}
}

public class NorthwindFunctionMappings : FunctionMappingStore
{
public NorthwindFunctionMappings() : base()
{
this.Add(new FunctionMapping(typeof(NorthwindFunctions), "CalculateOrderTotal", 2,
"fn_CalculateOrderTotal({0}, {1})", "Northwind", "dbo"));
}
}

NorthwindFunctions类型会根据数据库中的函数，生成.NET调用代码。NorthwindFunctionMappings 则把这个函数转化为Linq to LLBL Gen的映射定义方式，最后看到应用代码是这样的

metaData.CustomFunctionMappings = new NorthwindFunctionMappings();
var q = from o in metaData.Order
where o.CustomerId == "CHOPS"
select new { o.OrderId, OrderTotal = NorthwindFunctions.CalculateOrderTotal(o.OrderId, true) };

Full-text search 全文索引

以上面为基础，实现Linq中的全文索引就比较容易，对于SQL Server，在自定义的数据库函数中调有数据Contains。

public class NorthwindFunctions
{
public static bool FullTextSearch(string fieldToSearch, string toFind)
{
// empty body, as it's just here to make the query compile. The call is converted to a SQL function.
return true;
}
}

/// Class which defines the custom mapping between NorthwindFunctions.FullTextSearch and CONTAINS()
public class NorthwindFunctionMappings : FunctionMappingStore
{
public NorthwindFunctionMappings() : base()
{
// FullTextSearch(2) on 1 field
this.Add(new FunctionMapping(typeof(NorthwindFunctions), "FullTextSearch", 2, "CONTAINS({0}, {1})"));
}
}

应用代码与前面的相同，在使用前设置CustomFunctionMappings

metaData.CustomFunctionMappings = new NorthwindFunctionMappings();
// fetch the employees which have 'BA' in their Notes field which is Full text search enabled.
var q = from e in metaData.Employee
where NorthwindFunctions.FullTextSearch(e.Notes, "BA")
select e;

经过这两个例子，就引伸出关于调用数据库中函数的方法，也就是如何调用我们经常用到的SQL函数SUM/AVG。请参考帮助文档中的Supported default method / property mappings to functions。

一般来说，调用数据库的函数比前面的调用自定义函数更简单，ORM框架会预先设置好这些函数的映射。对于SQL Server 2005及以上的版本，因为引入了CLR Host技术，会略有些不同。如果我们的SQL代码不涉及CLR 函数和类型，调用方法和前面的一样。如果有涉及，要确保添加正确的的Function Mapping。

本文链接

LLBL Gen 元数据编程 LLBL Gen Meta-data Programming

2011-12-27T01:30:00Z

LLBL Gen作为ORM工具，有时候为了能生成一些基础的元数据，也需要了解它的对象及其之前的关系，这在通用的框架代码中的作用更加明显。举例说明，它生成的解决方案视图一般是这样的

现在有如下的需求需要满足，以提供基础的元数据，参考测试代码如下

string AssemblyFile = @"E:\Solution\Enterprise\Bin\Northwind.CRM.BusinessLogic.dll";
string TableName = "Employees";

string projectName = EntityClassHelper.PrefixProjectName(AssemblyFile);

string entity = EntityClassHelper.GetEntityName(TableName, AssemblyFile);
string entityName = "EmployeeEntity";
string str = EntityClassHelper.TrimEntityName(entityName);

IEntity2 currencyEntity = EntityClassHelper.GetEntityObject(TableName, AssemblyFile);
string typeName = "EmployeeEntity";
string table = EntityClassHelper.GetSourceTableName(typeName, AssemblyFile);

string entityColumnName = EntityClassHelper.GetObjectProperyName(AssemblyFile, TableName, "EmployeeId");
entityColumnName = EntityClassHelper.GetObjectProperyName(AssemblyFile, TableName, "LastName");
List<string> path = EntityClassHelper.GetPrefetchPath(AssemblyFile, TableName);

IEntity2 entity2 = EntityClassHelper.GetEntityObject(TableName, AssemblyFile);
List<string> relations = EntityClassHelper.GetPrefetchPathEx(entity2);

需求列出如下图表所示

序号	需求描述
1	如何获取LLBL Gen代码生成器生成的项目名称，这可以确定类型所在的命名空间
2	如何根据数据库表名(Customers)，获取它对应的生成的实体名(CustomerEntity)
3	如何根据实体名(CustomerEntity)，获取它映射到的数据库表名(Customers)
4	如何根据实体名，获取它的主键属性/字段
5	如何根据表名及指定的字段表，获取对应的生成的实体的属性
6	如何获取实体的子集合的关系

项目名称空间

这里要获取的就是Root namespace，顶层的命名空间，依照这个名称，从而可以得到实体所在的名称空间。

LLBL Gen从3.x开始，项目文件改用xml配置文件，这为大量的第三方工具的产生提供的便利。如果要获取上图所示的Root namespace，可以采用Xml技术(XmlDocument)或Linq to Xml读取它的配置节

如上面的Xml文本所示，RootNamespace就是我们需要的顶层命名空间。

观察LLBL Gen生成的项目文件，它的实体定义的代码所下的例子所示

using SD.LLBLGen.Pro.ORMSupportClasses;

namespace Northwind.DAL.EntityClasses
{
// __LLBLGENPRO_USER_CODE_REGION_START AdditionalNamespaces
// __LLBLGENPRO_USER_CODE_REGION_END
/// <summary>Entity class which represents the entity 'Category'.<br/><br/></summary>
[Serializable]
public partial class CategoryEntity : CommonEntityBase
// __LLBLGENPRO_USER_CODE_REGION_START AdditionalInterfaces
// __LLBLGENPRO_USER_CODE_REGION_END
{
}
}

反射生成的解决方案文件类库，获取它的类型，如果是IEntity2(Adapter模式),去掉必须的EntityClasses，前面的部分即是我们需要的顶层(Root namespace)命名空间，实现代码如下所示

Assembly assebly=Assembly.Load(businessLogic);
Type[] types = assembly.GetTypes();
string rootNamespace = "";
foreach (Type type in types)
{
if (!string.IsNullOrEmpty(type.Namespace))
{
string nspace = type.Namespace.Substring(type.Namespace.LastIndexOf('.') + 1);
if (type.Name.EndsWith("Entity") & nspace == "EntityClasses")
{
rootNamespace = type.Namespace;
int idx = rootNamespace .LastIndexOf(".");
rootNamespace = rootNamespace .Substring(0, idx);
break;
}
} }

变量rootNamespace就是我需要的顶层命名空间。

数据库表与它生成的实体对象名

来观察一下LLBL Gen提供的数据访问接口类型DataAccessAdapter，这提供一个保护的方法成员GetFieldPersistenceInfos，使用Reflector得到它的源代码跟踪进去，看到有数个方法

// Summary: Retrieves the persistence info for the field passed in.
// Parameters:
// field: Field which fieldpersistence info has to be retrieved
// Returns:the requested persistence information
protected virtual IFieldPersistenceInfo GetFieldPersistenceInfo(IEntityField2 field);
// Summary: Retrieves the persistence info objects for the fields of the entity passed in.
// Parameters: entity:
// Entity bject which fields the persistence information should be retrieved for
// Returns: the requested persistence information
protected virtual IFieldPersistenceInfo[] GetFieldPersistenceInfos(IEntity2 entity);
// Summary: Retrieves the persistence info for the fields passed in.
// Parameters: fields: Fields for which the persistence info has to be determined
// Returns: the requested persistence information
protected virtual IFieldPersistenceInfo[] GetFieldPersistenceInfos(IEntityFields2 fields);
// Summary: Retrieves the persistence info objects for the fields of the entity passe in.
// Parameters: entityName:
//Entity name for entity type which fields the persistence information should be retrieved for
// Returns: the requested persistence information
protected virtual IFieldPersistenceInfo[] GetFieldPersistenceInfos(string entityName);

IFieldPersistenceInfo就是实体属性对应的数据库字段的映射类型，不过这几个方法都是保护类型的，需要在派生类中访问，如下的代码所示

namespace Northwind.DAL
{
public sealed class DataAccessAdapter : Northwind.DAL.DatabaseSpecific.DataAccessAdapter
{
public string GetSourceTableName(string entityType)
{
return base.GetFieldPersistenceInfos(entityType)[0].SourceObjectName;
}
}

因为同一个实体对应的表，表中的所有字段所属的表名肯定是相同的，所以直接取它的第零个字段的SourceObjectName。这样，我们就做到了根据实体的名称，来获取它应对的数据库表名称。在我的Management Console开发工具中，没有直接从DatabaseSpecific.DataAccessAdapter类型派生，这样的方式会产生很多麻烦。每新建一个项目就要派生一个类型出来，这样不符合工具的含义，观察一下生成的文件PersistenceInfoProvider

internal static class PersistenceInfoProviderSingleton
{
#region Class Member Declarations
private static readonly IPersistenceInfoProvider _providerInstance = new PersistenceInfoProviderCore();
#endregion

/// <summary>Dummy static constructor to make sure threadsafe initialization is performed.</summary>
static PersistenceInfoProviderSingleton()
{
}

/// <summary>Gets the singleton instance of the PersistenceInfoProviderCore</summary>
/// <returns>Instance of the PersistenceInfoProvider.</returns>
public static IPersistenceInfoProvider GetInstance()
{
return _providerInstance;
}
}
}internal class PersistenceInfoProviderCore : PersistenceInfoProviderBase
{
/// <summary>Initializes a new instance of the <see cref="PersistenceInfoProviderCore"/> class.</summary>
internal PersistenceInfoProviderCore()
{
Init();
}

/// <summary>Method which initializes the internal datastores with the structure of hierarchical types.</summary>
private void Init()
{
this.InitClass((13 + 2));
InitCategoryEntityMappings();
InitCustomerEntityMappings();
}}

这两个类型暴露了IPersistenceInfoProvider 给外部类型库来获取它的映射关系，这一点我是通过分析LLBL Gen ORM Support Classes得到的。因为LLBL Gen框架要自动生成SQL语句，必然需要一种机制或是映射来保存这种数据库表和实体的映射关系，NHibernate是使用外部xml配置文件的方式，LLBL Gen则直接使有代码，并且代码直接由生成工具维护，不需要开发人员参与，这一点应该比NHibernate更加合理优秀一些。来看一下经过反射后的得到的代码

public abstract class PersistenceInfoProviderBase : IPersistenceInfoProvider
{
protected PersistenceInfoProviderBase();

protected void AddElementFieldMapping(string elementName, string elementFieldName, string sourceColumnName, bool isSourceColumnNullable, string sourceColumnDbType, int sourceColumnMaxLength, byte sourceColumnScale, byte sourceColumnPrecision, bool isIdentity, string identityValueSequenceName, TypeConverter typeConverterToUse, Type actualDotNetType, int fieldIndex);
protected void AddElementMapping(string elementName, string catalogName, string schemaName, string targetName, int numberOfFields);
public IFieldPersistenceInfo[] GetAllFieldPersistenceInfos(IEntity2 entity);
public IFieldPersistenceInfo[] GetAllFieldPersistenceInfos(string elementName);
public IFieldPersistenceInfo GetFieldPersistenceInfo(string elementName, string fieldName);
protected void InitClass(int capacity);
}

方法AddElementMapping和AddElementFieldMapping添加表及其字段与实体的映射到内部集合中，并通过GetAllFieldPersistenceInfos接口向外公布映射数据。这就解释了方法GetSourceTableName的原理。

Management Console因为要适应新项目的需要，所以不能直接用派生的方式，直接用反射来获取元数据信息。

1 反射项目root namespace名称，得到DatabaseSpecific.PersistenceInfoProviderSingleton类型，反射它的GetInstance()方法得到IPersistenceInfoProvider

2 传入需要的参数，得到IFieldPersistenceInfo类型，观察它的属性，可以看到SourceObjectName，其它的属性如下

public interface IFieldPersistenceInfo
{
Type ActualDotNetType { get; }
string IdentityValueSequenceName { get; }
bool IsIdentity { get; }
string SourceCatalogName { get; }
string SourceColumnDbType { get; }
bool SourceColumnIsNullable { get; }
int SourceColumnMaxLength { get; }
string SourceColumnName { get; }
byte SourceColumnPrecision { get; }
byte SourceColumnScale { get; }
string SourceObjectName { get; }
string SourceSchemaName { get; }
TypeConverter TypeConverterToUse { get; }
}

这些属性的含义，就代表了数据库字段的内存映射，于DataTable不同。DataTable是装载数据，而IFieldPersistenceInfo是装载字段的元数据，也就是下图中的Column Properties

这个类型在生成SQL语句方面有重要的作用，你可以通过查看它的源代码（反射得到，没有加密）看到它的重要作用。

讲到这里，所有的元数据的信息都可以通过上面的接口和方法获取到。

SQL Trace

如果对LLBL Gen生成的SQL语句感兴趣，可以通过Trace机制来跟踪它的SQL输出，配置过程如下所示。修改配置文件

<system.diagnostics>

</system.diagnostics>

这样配置，可以将LLBL Gen生成的SQL语句输出到文本文件中，不过这种方式不适合即时查看。需要重写一个TraceListener来截获它的SQL输出。

public class ORMTraceListener : TraceListener
{
static Socket m_socClient;
//在可以连接的情况下，才能保证去发送消息
static bool m_serverAvailable=false;

static ORMTraceListener()
{
m_server = false;
OnConnect("127.0.0.1", 2907);
}

public override void Write(string message)
{
if (!String.IsNullOrEmpty(message) && m_server&&NeedSend(message))
OnSendData(message);
}

public override void WriteLine(string message)
{
if (!String.IsNullOrEmpty(message) && m_server && NeedSend(message))
OnSendData(message+Environment.NewLine);
}
}

这里应用Socket把截取的SQL语句输出到我的监控程序中，修改上面的type为ORMTraceListener 即可。

截取的SQL语句不是标准的SQL Server语句。原因是LLBL Gen是跨数据库平台的，独立于数据库方言，所以要用一种公共的方法来描述生成的SQL语句，这也提供了一种通用SQL语句生成的方法(学技术的同时，也看到了技术的最佳实践，这在以后的工作中会提供相当大的帮助）。SQL语句格式如下所示

Generated Sql query:

Query: SELECT DISTINCT [Enterprise].[dbo].[Company].[CompanyCode] FROM [Enterprise].[dbo].[Company] WHERE ( ( [Enterprise].[dbo].[Company].[Suspended] = @Suspended1)) ORDER BY [Enterprise].[dbo].[Company].[CompanyCode] ASC

Parameter: @Suspended1 : String. Length: 1. Precision: 0. Scale: 0. Direction: Input. Value: "N".

在此基础上，再创建一个解析工具，把这里的SQL解析成可以直接在SQL Server中运行的T-SQL脚本。

本文链接

ORM + .NET Remoting 完整例子程序虽然现在都流行WCF，也没有必要抛弃已经掌握的.NET Remoting

2011-12-26T01:04:00Z

LLBL Gen作为项目开发的ORM框架，选择.NET Remoting作为分布式技术框架。一直也很想把ERP框架从.NET Remoting升级到WCF，只是关于方法重载的配置方法需要特殊处理。举例说明如下

public interface IEmployeeManager
{
EmployeeEntity GetEmployee(System.Int32 Employeeid);
EmployeeEntity GetEmployee(System.Int32 Employeeid, IPrefetchPath2 prefetchPath);
EmployeeEntity GetEmployee(System.Int32 Employeeid, IPrefetchPath2 prefetchPath, ExcludeIncludeFieldsList fieldList);
}

IEmployeeManager接口用于对员工表Employee进行CRUD操作。上面三个重载方法是用来从数据库中读取员工信息

对.NET Remoting技术实现，只需要派生于MarshalByRefObject，实现IEmployeeManager接口的方法即可

public class EmployeeManager : MarshalByRefObject, IEmployeeManager
{
public EmployeeEntity GetEmployee(System.Int32 Employeeid)
{
return GetEmployee(Employeeid, null);
}

public EmployeeEntity GetEmployee(System.Int32 Employeeid, IPrefetchPath2 prefetchPath)
{
return GetEmployee(Employeeid, prefetchPath, null);
}

public EmployeeEntity GetEmployee(System.Int32 Employeeid, IPrefetchPath2 prefetchPath, ExcludeIncludeFieldsList fieldList)
{
EmployeeEntity _Employee = new EmployeeEntity(Employeeid);
using (DataAccessAdapterBase adapter = GetCompanyDataAccessAdapter())
{
bool found = adapter.FetchEntity(_Employee, prefetchPath, null, fieldList);
if (!found) throw new RecordNotFoundException("Invalid Employee");
}
return _Employee;
}
}

这样对于.NET Remoting是没有问题的。然后对于WCF技术，它不支持方法重载overload，需要添加Name特性

public interface IEmployeeManager
{
[OperationContract(Name="Employeeid")]
EmployeeEntity GetEmployee(System.Int32 Employeeid);
[OperationContract(Name="EmployeeidPrefetchPath")]
EmployeeEntity GetEmployee(System.Int32 Employeeid, IPrefetchPath2 prefetchPath);
[OperationContract(Name="EmployeeidPrefetchPathFieldList")]
EmployeeEntity GetEmployee(System.Int32 Employeeid, IPrefetchPath2 prefetchPath, ExcludeIncludeFieldsList fieldList);
}

每次加这么多参数很麻烦，于是就制造一个工具，专门用于生成Name的参数值

甚至可以把这个工具的代码直接集成到Code Smith的模板中，这样大大减少了工作量，提高工作效率。

回到主题，来看看LLBL Gen的.NET Remoting版本，这个例子被直接映射到了ERP框架中。

定义接口方法

public interface IService
{
int GetNumberOfCustomers();
void GetOrderStatistics(out decimal averageOrderPrice, out decimal highestOrderPrice, out int numberOfOrders, out int orderIdWithHighestPrice);
OrderEntity GetOrderAndCustomerWithHighestPrice(int orderId);
CustomerEntity GetCustomerWithMostOrdersAndNumberOfOrders(out int numberOfOrders);
EntityCollection<CustomerEntity> GetAllCustomers();
EntityCollection<CustomerEntity> GetAllCustomersFilteredOnProduct(int productId);
EntityCollection<ProductEntity> GetProductsSortedBySortExpression(SortExpression sorter);
bool RemoveOrder(OrderEntity toRemove);
CustomerEntity GetCustomerWithFullOrders(string customerId);
bool SaveCustomer(CustomerEntity toSave, bool recursive);
CustomerEntity GetCustomer(string customerId);
void SaveOrders(EntityCollection<OrderEntity> orders);
}

从技术的角度来讲，有二种类型的方法：单向的，传入参数，执行动作，不返回值；双工，传入参数，返回值。

接口的实现代码

public class Service : MarshalByRefObject, IService
{
public int GetNumberOfCustomers()
{
Console.WriteLine("GetNumberOfCustomers called");
using(DataAccessAdapter adapter = new DataAccessAdapter())
{
// simply obtain the count of the customerid and return that.
return (int)adapter.GetScalar(CustomerFields.CustomerId, AggregateFunction.CountRow);
}
}
}

其它的代码参考下载的例子程序，它的实现代码可以用代码生成器生成。不带参数的DataAccessAdapter 表示从默认生成的配置文件中读取连接字符串，内容如下

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="Northwind.ConnectionString.SQL Server (SqlClient)" value="data source=.\sqlexpress;initial catalog=Northwind;integrated security=SSPI;persist security info=False;packet size=4096"/>
</appSettings>
</configuration>

服务器端的实现，把接口的实现代码发布成服务

// register a channel and assign the service type to it. This opens the service to the outside world at TCP port 65100.
TcpChannel channel = new TcpChannel(65100);
ChannelServices.RegisterChannel(channel, true);

Type serverType = Type.GetType("RemotingService.Service");
RemotingConfiguration.RegisterWellKnownServiceType(serverType, "theEndPoint", WellKnownObjectMode.Singleton);

// switch on FastSerialization
SerializationHelper.Optimization = SerializationOptimization.Fast;

客户端实现代码，读取服务并调用它来实现数据库的读写

// grab service object first.
TcpChannel channel = new TcpChannel();
ChannelServices.RegisterChannel(channel, true);

MarshalByRefObject o = (MarshalByRefObject)RemotingServices.Connect(typeof(IService), string.Format( "tcp://{0}:65100/theEndPoint", SERVERNAME));
IService service = o as IService;
if(service == null)
{
throw new Exception("Service couldn't be obtained. Aborting");
}

MainForm.DalService = service;
// switch on FastSerialization
SerializationHelper.Optimization = SerializationOptimization.Fast;

之后的代码中，都会应用MainForm.DalService来获取客户数据以及客户的产品资料。

这个例子还有几点可以讨论的地方，请参考如下的思考

1 服务的调用代码。如果有多个.NET Remoting服务，应该做成工厂模式，并且提高cache以减少内存的消耗。

工厂模式的参考代码如下所示

IService service;
if(!_cache.Contains(service))
service=CreateService(service)
return service;

这样实现的好处是，当这个接口被多个客户段代码调用时，服务实现只被创建了一次，节约内存。虽然.NET的垃圾回收器已经很智能了，但是这种带缓存版本的写法，比没有缓存要有效率。

2 没有使用配置文件，而是直接在代码中创建TcpChannel的方式。在学.NET Remoting的时，也喜欢用各种书中推荐的方式，用配置文件而不是直接硬编码到代码中。在实践中发现，这样每次都需要把已经配置好的配置文件的片段拷贝到新项目的配置文件中，比较麻烦。一般来说，Channel和Port在部署到客户服务器上是不会变动的。于是就改变做法，把Channel的创建直接写到代码中，Port留给配置文件来指定。这种方式不需要增加配置文件节，方便部署。

3 当方法需要返回多个值时，参考接口IService的GetOrderStatistics方法，这里使用的是out修饰参数。把值赋给传入的参数，方法调用完成后，再获取参数值。这里，推荐用结构struct设计成返回值，以应对增加参数的变化。

方法参数的传入也一样，当有多个参数要传入到方法内部时，可以有struct把这些参数简单封装一下，作为一个整体传入方法中。在未来有对这个方法进入维护时，也会相对容易一些。

文章中提到的例子程序，请到LLBL Gen官方网站下载，代码名称是Example_NorthwindRemotingExampleCS_Adapter。

本文链接

ERP项目开发中的DataTable的性能优化代码写得漂亮看起来舒服，运行起来也有效率

2011-12-23T09:59:00Z

公司的ERP框架是用ORM技术来访问数据库的，但有些查询还是会用DataTable保存数据，并且会把用户修改后的数据保存到服务器中。在习惯了ORM的写法后，对于用DataTable的保存用户修改过的数据，然后保存到数据库中反而有些不适应。ORM会自动检测到哪些数据项被改动了，进而生成必要的UPDATE子句，如果没有数据被更改，则不会产生任何UPDATE语句，这是ORM的好处与便利。把这个技巧应用到DataTable中，来看看下面的性能优化技巧。

DataColumn item = new DataColumn("IsChanged", typeof(bool));
item.DefaultValue = false;
itemTable.Columns.Add(item);

有一个临时的查询表itemTable，保存物料的计划信息。在物料计划功能中，我们会修改一下物料的计划数据，然后把它保存到数据库中。因为有很多物料，有的会被修改计划日期，有的不会修改，所以我给物料计划表itemTable加了一个额外的字段IsChanged，以表示这个物料的物料计划是否被修改过。如果被修改过，比如下面的方法

itemTable.Rows[0]["PlanQty"]=200;
itemTable.Rows[0]["IsChanged"]=true;

第二行代码，我会把这个table的IsChange列的值设为true，表示这一行已经被修改过，在保存时，需要生成SQL UPDATE语句。这样，在窗体被关闭时或用户点击保存按钮时，用下面的判断语句

int changed=(from item in itemTable.AsEnumerable()
where item.Fields<bool>("IsChanged")==true
selectg item).Count();
if(changed)
{
foreach(item in itemTable.AsEnumerable()
where item.Fields<bool>("IsChanged")==true)
//save item and its plan qty
}

changed变量判断当前是否有物料的计划数量被更改过，如果有才保存被改过的物料及其计划，否则不会做任何动作。

以此类推，这个技巧还可以应用于删除或是新增

DataColumn item = new DataColumn("IsNew", typeof(bool));
item.DefaultValue = false;
itemTable.Columns.Add(item);

item = new DataColumn("IsDeleted", typeof(bool));
item.DefaultValue = false;
itemTable.Columns.Add(item);

虽然这是个很小的技巧，却可以解决很多场合的问题。举例说明

1 用户打开物料计划功能，只是看了一下，没有修改任何物料及其计划，在退出功能时，你不应该提示用户保存，因为用户没有作任何数据修改动作。

2 用户新增加了一条物料及其计划，你可以判断是新加的，进而生产INSERT语句，而不是UPDATE语句。如果不用这个技巧，你需要到数据库中去判断是否有这个物料的计划数据，如果有则产生UPDATE语句，否则产生INSERT语句。应用我说的这个技巧(IsNew)，你可以明显的减少往返于数据库之间的逻辑，性能会有明显的改善。

3 用户删除了一条物料及其计划，itemTable少了一行，你怎么把它写回到数据库中去呢？应用这个IsDeleted技巧，不对itemTable调用DeleteRow方法，而是把它的IsDeleted设为true,表示这个物料的计划被删除了，需要产生DELETE语句发送到数据库中。

在判断itemTable是否被修改过，也可以应用这个技巧

foreach (DataRow row in itemTable.Rows)
{
if (row.RowState == DataRowState.Unchanged)
continue;
//save changed item and its plan qty

}

DataRow有一个RowState属性，以表示这个表是否被修改过。你可以不用加上面的IsChanged列而应用RowState来判断，也可以达到这个目的。DataRowState.Added 表示是新增加的一行数据，其它的值是

// Summary:
//Gets the state of a System.Data.DataRow object.
[Flags]
public enum DataRowState
{
// Summary:
// The row has been created but is not part of any System.Data.DataRowCollection.
// A System.Data.DataRow is in this state immediately after it has been created
// and before it is added to a collection, or if it has been removed from a
// collection.
Detached = 1,
//
// Summary:
// The row has not changed since System.Data.DataRow.AcceptChanges() was last
// called.
Unchanged = 2,
//
// Summary:
// The row has been added to a System.Data.DataRowCollection, and System.Data.DataRow.AcceptChanges()
// has not been called.
Added = 4,
//
// Summary:
// The row was deleted using the System.Data.DataRow.Delete() method of the
// System.Data.DataRow.
Deleted = 8,
//
// Summary:
// The row has been modified and System.Data.DataRow.AcceptChanges() has not
// been called.
Modified = 16,
}

对于Add或Delete的情况，我还是习惯于加IsNew或IsDeleted列，尽管这不是必要的。

在应用ORM框架保存实体时，它会检测实体的字段属性是否被修改，只有修改过的属性，才会出现在ORM框架生成的UPDATE语句中，这样确实有效率，与判断DataTable的列值是否被修改过相似，看似乎一点点的改进，对于系统的性能提升是有好处的。

本文链接

ORM Querier 基于Transact-SQL解析的代码生成利器帮助开发人员高效快速生成需要的ORM代码

2011-12-23T05:32:00Z

对于习惯于用ORM来开发系统的开发人员来说，几乎不用写SQL语句，但是也要针对ORM框架，来设计合适的查询，ORM框架会生成合适的T_SQL语句并发送到SQL Server中。由于ORM框架有好几种，比如NHibernate,LLBL Gen,Entity Framwork，掌握熟练的SQL查询技术在这里没有用武之地，真是可惜。这篇文章是介绍我的Management Console中的一个工具程序，把SQL查询语句转化为ORM代码片段，相当于一个代码生成工具。

选定Northwind数据库的客户表为例子，它的脚本是这样的，这里省略了表的约束代码。

CREATE TABLE [dbo].[Customers]
(
[CustomerID] [nchar] (5) COLLATE Chinese_PRC_CI_AS NOT NULL,
[CompanyName] [nvarchar] (40) COLLATE Chinese_PRC_CI_AS NOT NULL,
[ContactName] [nvarchar] (30) COLLATE Chinese_PRC_CI_AS NULL,
[ContactTitle] [nvarchar] (30) COLLATE Chinese_PRC_CI_AS NULL,
[Address] [nvarchar] (60) COLLATE Chinese_PRC_CI_AS NULL,
[City] [nvarchar] (15) COLLATE Chinese_PRC_CI_AS NULL,
[Region] [nvarchar] (15) COLLATE Chinese_PRC_CI_AS NULL,
[PostalCode] [nvarchar] (10) COLLATE Chinese_PRC_CI_AS NULL,
[Country] [nvarchar] (15) COLLATE Chinese_PRC_CI_AS NULL,
[Phone] [nvarchar] (24) COLLATE Chinese_PRC_CI_AS NULL,
[Fax] [nvarchar] (24) COLLATE Chinese_PRC_CI_AS NULL
) ON [PRIMARY]

现在要开发一个查询客户信息的程序，找出客户ID为ANATR的地址，公司名称和联系人信息

由于使用了LLBL Gen ORM框架作为数据访问技术，上面的SQL语句显然不能直接拼凑成C#代码，需要进行转化，封装

的过程比较相对容易，但是也需要耗费一些时间和精力。来看看我设计代码生成工具ORM Querier

在上面的文本框中输入SQL语句，点击Generate生成按钮，同下面自动生成了C#代码。如果你熟悉LLBL Gen框架的API接口，拷贝这片代码到C#中是可以直接运行的，相当于我们的SQL查询语句的ORM版形式。

目前因为只用到了LLBL Gen，所以它只生成了基于LLBL Gen的代码片段。它的基本原理是解析T_SQL语句，生成映射的C#语句，所以，推广到生成NHibernate或是Entity Framework不是难题。

这个工具我酝酿了一段时间，一方面要推广自己的EPN快速开发框架，面对大量的不熟悉LLBL Gen这个框架的用户。另一方面，把理论变成代码工具实践，也需要一些技术上的判断与实作。

我在接触LLBL Gen这个ORM框架时，也会经常忘记它的SELECT是如何的写，UPDATE如何写，于是要经常查资料，后来干脆把资料整理出来，打印放到桌子上，经常看一下也不会忘记。如下图所示

这样的工作方法，效率又高了很多。但是也不是每天都会和代码打交道，有时候几个月的时间都是在修改报表，这一块的内容又忘记了。既然是有规律可寻的，就可以探索出合适的工具出来，把规律变成鼠标点击的简单动作，这样大大减少出错的机率，于是就产生了这个工具。试想一下，SQL查询技术，你不会忘记，在熟悉的SQL Server Management Studio中输入要查询的SQL语句，把它拷贝到ORM Querier中，执行Generate转化命令，就得到你需要的ORM代码片段。经过这样的改善，做事的效率又提高了很多，而且准确率高，不会出错。

经常地思考如何改善工作效率，把一些规律性的知识和技术转化为软件或程序，经过几年的积累就形成了我的开发工具系列工具集Management Console。我在epn.codeplex.com中开放了一部分的Management Console的源代码，欢迎下载使用，希望能对你的工作和学习有所启发和帮助。

本文链接

亲自下载CSDN社区600万用户数据设计两条编程题目考验你的.NET编程基础

2011-12-23T01:09:00Z

园子里这两天讨论的比较多的是CSDN-中文IT社区 600万用户数据在互联网上的传播，作为一名技术人员，暂且放下各自的想法的意见，仅仅从技术的角度来讲，分析和考验一下我们的编程基础。

把下载到的压缩文件释放到硬盘中，得到文件www.csdn.net.sql。作为技术人员，对这个文件产生好奇心和编程的冲动。于是提出了下面的两条编程题目：

1 如何把600万数据导入到SQL Server中？

2 如何选择合适的密码加密方法？

这个SQL文件有273MB，用SQL Server Management Studio打开它，会产生OutOfMemory异常，用记事本打开也很慢，推荐用Ultra Edit源代码编辑软件打开。

估计大家的硬盘里面都有这个文件了，我也就不必给密码和邮件加上阴影了。

用自己曾经注册到的邮件找一下，果然找到了自己的帐号和密码，确实是明文的。

分析一下SQL文件，它是由换行符号分开的，以#分隔用户帐号，密码，电子邮件的格式。这和逗号分隔文件格式很相似，于是动手把它导入到SQL Server中。请参考下面的两行代码

CREATE TABLE CsdnUser ([USER] NVARCHAR(MAX) )
BULK INSERT CsdnUser FROM N'F:\www.csdn.net.sql'

然后就是漫长的等待了，在4G内存，4核的Windows 7 x64的机器上，也跑了近5分钟才把数据从文本文件导入到SQL Server的CsdnUser表中。平时喜欢研究性能，性能改善研究，心中一阵窃喜。执行完成后，看到Messages中显示

(6428632 row(s) affected)，果然有600多万行数据，放数据库文件的磁盘一下子耗费了近6G的空间。

跑一下SQL语句 SELECT [User] FROM CsdnUser，用户数据就已经存放到了SQL Server数据库文件中了。

这样完成了文本文件到SQL Server的导入过程。如果我还想进一步的分解每一行的数据，像下面的结果显示这样

SELECT dbo.GetSplitOfIndex(User,'',1) AS [UserId]

dbo.GetSplitOfIndex(User,'',2) AS [Password]

dbo.GetSplitOfIndex(User,'',3) AS [Email]

FROM CsdnUser

则还需要写一个split函数，以分解开用#分开的用户数据。GetSplitOfIndex函数来源于互联网，地址是

http://www.fengfly.com/plus/view-168590-1.html，作者秩名，感谢他的智慧。函数的源代码如下所示

CREATE FUNCTION [dbo].[GetSplitOfIndex]
(
@String NVARCHAR(MAX) , --要分割的字符串
@split NVARCHAR(10) , --分隔符号
@index INT --取第几个元素
)
RETURNS NVARCHAR(1024)
AS
BEGIN
DECLARE @location INT
DECLARE @start INT
DECLARE @next INT
DECLARE @seed INT

SET @String = LTRIM(RTRIM(@String))
SET @start = 1
SET @next = 1
SET @seed = LEN(@split)

SET @location = CHARINDEX(@split, @String)
WHILE @location <> 0
AND @index > @next
BEGIN
SET @start = @location + @seed
SET @location = CHARINDEX(@split, @String, @start)
SET @next = @next + 1
END
IF @location = 0
SELECT @location = LEN(@String) + 1

RETURN SUBSTRING(@String,@start,@location-@start)
END

自SQL Server 2005起就开始集成CLR，允许.NET托管代码运行于SQL Server中，用我们熟悉的.NET API可以轻易的完成任务。打开Visual Stdio 2010，创建一个SQL Server CLR项目，SQL Server CLP函数的源代码清单如下

[Microsoft.SqlServer.Server.SqlFunction]
public static SqlString Split(string UserLine,int Index)
{
if (!string.IsNullOrEmpty(UserLine))
{
string[] lines = Regex.Split(UserLine, " # ");
if (lines.Length == 3)
return new SqlString(lines[Index]);
else
throw new ApplicationException("invalid input line");
}
return new SqlString("");
}

它的调用方法和TSQL函数的方式一样，如下图所示

SELECT dbo.Split(User,0) AS [User Id]

dbo.Split(User,1) AS [Password]

dbo.Split(User,2) AS [Email]

FROM CsdnUser

顺利完成第一题，如果你有更好的方法，欢迎留言。

对于密码是否用明文，是否要加密，各种情况下所采取的方法都有道理。不给密码加密，明文传送是不值得推荐，不过冒似很多系统都是用明文保存在数据库中的。如果你担心明文不好，容易被人家获取到，可以采用可逆的加密。请参考我的文章《数据加密小工具》，它对需要保护的数据进行简单的加密，也很容易的逆反到当初的明文

在我的知识管理系统Data Solution的用户反馈功能中，用户输入反馈的内容，发送到指定的邮箱中，因为使用的是smtp的方式，所以要把用户名和密码写到程序中去，但为了防止别人很轻易的从IL代码中读到到我的邮件的帐号和密码，我就使用了上面的可逆加密的方法，把邮件帐号和密码进行加密后，再放到程序代码中，这样可以增加被破解的难度。也没有把很重要的资料放到这个用于接受用户反馈的邮件帐号中，毕竟还是可能被人家破解的。

再进一步的，可以采用.NET提供的算法，进行Hash运算或是加密。MD5是公认的不可逆的加密算法，它的调用方法如下

byte[] Original = Encoding.Default.GetBytes(txt_Source.Text);
MD5 s1 = MD5.Create(); //使用MD5
byte[] Change = s1.ComputeHash(Original); 加密
txt_Result.Text = Convert.ToBase64String(Change);

请参考文章《使用MD5將字串加密 C# VS2005 Sample Code》学习MD5的调用方法。

如果你需要MD5的调用例子代码，下面的代码应该可以帮助到你,代码来原于园子里的朋友，
地址是http://www.cnblogs.com/konooo/archive/2009/01/22/1379920.html

/// MD5 16位加密加密后密码为大写
/// </summary>
/// <param name="ConvertString"></param>
/// <returns></returns>
public static string GetMd5Str(string ConvertString)
{
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(ConvertString)), 4, 8);
t2 = t2.Replace("-", "");
return t2;
}
/// <summary>
/// MD5 16位加密加密后密码为小写
/// </summary>
/// <param name="ConvertString"></param>
/// <returns></returns>
public static string GetMd5Str(string ConvertString)
{
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(ConvertString)), 4, 8);
t2 = t2.Replace("-", "");
t2 = t2.ToLower();
return t2;
}

/// <summary>
/// MD5　32位加密
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
static string UserMd5(string str)
{
string cl = str;
string pwd = "";
MD5 md5 = MD5.Create();//实例化一个md5对像
// 加密后是一个字节类型的数组，这里要注意编码UTF8/Unicode等的选择　
byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(cl));
// 通过使用循环，将字节类型的数组转换为字符串，此字符串是常规字符格式化所得
for (int i = 0; i < s.Length; i++)
{
// 将得到的字符串使用十六进制类型格式。格式后的字符是小写的字母，如果使用大写（X）则格式后的字符是大写字符
pwd = pwd + s[i].ToString("X");
}
return pwd;
}

前几年是经常在CSDN上逛，也喜欢它的下载频道，可以找到很多资源，后来下载资源要积分的，没有分就不能下载，于是自己注册了多个CSDN的帐号，只用来下载资源。这里我有两句微词，既然是共享目的，为何要限制别人下载呢？新浪的爱问知识人就没有这么复杂的下载规则，即使被下载的文件需要积分，你也可以找到不要分的，免限制下载的资源。还有一条规则，如果你的CSDN帐号不够一定的级别，只能上传，但不能删除你上传的文件。我自己也曾在CSDN上发布过软件程序，后来有新版本发布，无法自己删除旧版本的程序，要到论坛去发贴子，依靠管理员才能删除，就这一条，使我彻底放弃了把CSDN作为程序代码的发布渠道。不过，CSDN还是对我们的技术有过很大的帮助，遇到问题用Baidu搜索到的头条通常就是CSDN的论坛的贴子，这一点要对CSDN表示感谢和致敬。

本文链接

博客园_快速代码生成+基础框架

.NET 应用程序界面开发经验总结 设计良好的程序的表现之一就是细节做的还可以

Visual Studio 2010 开发与调试IronPython脚本 为你的ERP/MIS 应用程序添加脚本功能

总结一下ERP .NET程序员必须掌握的.NET技术，掌握了这些技术工作起来才得心应手

应用反射技术为Infragistics Solution设计例子程序 代码简洁而且学习的效率高

Linq to LLBL Gen Pro LLBL Gen的Linq程序设计

LLBL Gen 元数据编程 LLBL Gen Meta-data Programming

ORM + .NET Remoting 完整例子程序 虽然现在都流行WCF，也没有必要抛弃已经掌握的.NET Remoting

ERP项目开发中的DataTable的性能优化 代码写得漂亮看起来舒服，运行起来也有效率

ORM Querier 基于Transact-SQL解析的代码生成利器 帮助开发人员高效快速生成需要的ORM代码

亲自下载CSDN社区600万用户数据 设计两条编程题目考验你的.NET编程基础

.NET 应用程序界面开发经验总结设计良好的程序的表现之一就是细节做的还可以

Visual Studio 2010 开发与调试IronPython脚本为你的ERP/MIS 应用程序添加脚本功能

应用反射技术为Infragistics Solution设计例子程序代码简洁而且学习的效率高

ORM + .NET Remoting 完整例子程序虽然现在都流行WCF，也没有必要抛弃已经掌握的.NET Remoting

ERP项目开发中的DataTable的性能优化代码写得漂亮看起来舒服，运行起来也有效率

ORM Querier 基于Transact-SQL解析的代码生成利器帮助开发人员高效快速生成需要的ORM代码

亲自下载CSDN社区600万用户数据设计两条编程题目考验你的.NET编程基础