博客园_喜乐的ASP.NET(Alex Song)

非常好玩的C#/.NET 基础 -- 安全有效引发事件

2011-12-20T23:15:00Z

最近在网上看到一篇很好的文章, 讨论如何安全有效的引发事件.

也许你不一定要用到下面相同的解决方案, 但是至少你应该知道在引发事件时候需要考虑的问题.

引发事件的问题

引发事件是一个非常容易的事情, 但是的确也有它的误区. 让我们举个例子. 假设我们写个消息接收器, 每当我们收到一个新消息, 我们引发一个包含了新消息的事件 MessageReceived.

安装我们通常的方法,就是:

public class MessageReceivedEventArgs : EventArgs
{
// 接收到的消息
public string Message { get; private set; }

// 架构 ReceivedEventArgs
public MessageReceivedEventArgs(string message)
{
Message = message;
}
}

接下来, 我们创建一个非线程安全访问的类UnsafeMessenger来实现这个消息同时通知所有的订阅者(subscriber).

public class UnsafeMessenger
{
public event EventHandler<MessageReceivedEventArgs> MessageReceived;

// 当收到新消息时调用
public void OnNewMessage(string message)
{
if (MessageReceived != null)
{
MessageReceived(this, new MessageReceivedEventArgs(message));
}
}
}

注意, 通常OnNewMessage() 是私有的, 但是在这里为了测试的方便,我们将它设为public.

大功告成!! 是吗? 事实上, 如果我们是单线程的程序, 这的确已经足够, 但是这是非线程安全访问(thread-safe).

为什么? 想想, 订阅者可以任何时候订阅或者取消订阅. 比如,我们当前有一个订阅者, 那么当接收到一个新消息,执行到这一句时:

if (MessageReceived != null)肯定会通过, 因为有一个订阅者, 如果这个时候, 这名订阅者执行了取消订阅的命令:myMessenger.MessageReceived -= MyMessageHandler; 那么MessageReceived委托就为null 了,

//已经通过了这个IF语句

if (MessageReceived != null)
{
//MessageReceived委托就为null 了, 但是我们将要执行这句
MessageReceived(this, new MessageReceivedEventArgs(message));
}

这个时候, 就会引发NullReferenceException.

方案一: 锁住它, 锁机制

当允许多线程的时候, 我们可以用锁机制来避免一个用户在我们执行事件时订阅或者取消订阅, 或者在用户执行操作时, 不能引发事件.

public class SyncronizedMessenger : IMessenger
{
// 委托和锁
private EventHandler<MessageReceivedEventArgs> _messageReceived;
private readonly object _raiseLock = new object();

// 订阅/取消订阅的锁机制
public event EventHandler<MessageReceivedEventArgs> MessageReceived
{
add { lock (_raiseLock) { _messageReceived += value; } }
remove { lock (_raiseLock) { _messageReceived -= value; } }
}

// 引发事件的锁机制

public void OnNewMessage(string message)
{
lock (_raiseLock)
{
if (_messageReceived != null)
{
_messageReceived(this, new MessageReceivedEventArgs(message));
}
}
}

}

这样, 如果有人试图订阅或取消订阅时, 必须要等待OnNewMessage事件的完成, 反之亦然.

方案二: 永不为空, 默认加载一个订阅者

我们面临的主要问题是有可能委托为空. 那么如果事先加载一个委托,会怎么样?

public class EmptySubscriberMessenger : IMessenger
{

// 立刻给它一个空的订阅者
public event EventHandler<MessageReceivedEventArgs> MessageReceived = (s, e) => { };

// 现在根本无需检查是否为 null!
public void OnNewMessage(string message)
{
MessageReceived(this, new MessageReceivedEventArgs(message));
}

}

方案三: 创建一个本地的委托副本

另外一个简单的方案, 也就是很多人都在使用的, 微软建议的模式: 创建一个本地的委托副本.

public class LocalCopyMessenger : IMessenger
{
public event EventHandler<MessageReceivedEventArgs> MessageReceived;

// 当我们引发事件时, 做一个副本
public void OnNewMessage(string message)
{
var target = MessageReceived;

if (target != null)
{
target(this, new MessageReceivedEventArgs(message));
}
}
}

下面是以上四种方法的效率, 在执行10亿次的重复操作时:

以上参考翻译自: C#/.NET Fundamentals: Safely and Efficiently Raising Events

小结

有一种编程方式叫 Cargo Cult Programming, 中文名: 货物崇拜编程. 维基定义为"

其特征为不明就里地仪式性地使用代码或程序架构。货物崇拜编程通常是一个程序员既没理解他要解决的 bug，也没理解表面上的解决方案的典型表现。

这个名词有时也指不熟练的或没经验的程序员从某处拷贝代码到另一处，却不太清楚其代码是如何工作的，或者不清楚在新的地方是否需要这段代码。也可以指不正确或过份的应用设计模式，代码风格或编程方法，却对其原理不明就里。"

我承认在"高举实用主义"(敝人的如何做一个快乐的ASP.NET程序员) 的年代, 为了效率, 我也经常这样做.--试问谁有时间给第三方控件做测试?

自从这个创建本地委托副本的方案被大牛们推荐后, 大家都在用, 有人也不一定明白它背后的故事.

有时间的朋友们聊聊.net中的野史, 谈笑间扩充一点编程的能力,总比聊哪个明星又被潜规则了要有益处. 哈哈~~~

本年总结 + 新年祝福

有可能是本年最后一篇下面是我今天博文的部分列表, 先祝大家新的一年快乐!

* 程序员人生

有些时候，作为程序员，我们只是需要被重启一下

码斗士的修炼之路 -- 如何保持并提升战斗力

如何做一个快乐的ASP.NET程序员

* C# 语言

写出优雅简明代码的论题集 -- Csharp(C#)篇[1]

写出优雅简明代码的论题集 -- Csharp(C#)篇[2]

再说Csharp(C#) ”整洁代码”那些事 -- 变小[1]

C# 中奇妙的函数–8. String Remove() 和 Replace()

C# 中奇妙的函数–7. String Split 和 Join

C# 中奇妙的函数–6. 五个序列聚合运算(Sum, Average, Min, Max,Aggregate)

C# 中奇妙的函数–5. Nullable 静态类

C# 中奇妙的函数 -- 4. Empty, DefaultIfEmpty, Count

C# 中奇妙的函数 -- 3. 联接序列的五种简单方法

C# 中奇妙的函数 -- 2. First 和 Single -- 你是她心中的第一还是唯一?

C# 中奇妙的函数 -- 1. ToLookup

不可不知的C#基础 4. 延迟加载 -- 提高性能

不可不知的C#基础 3. 线程浅析

不可不知的C#基础 2. -–从 struct 和 class的异同说开去

不可不知的C#基础 1. -- Extension 扩展方法

* 其他

从 Comparison/Converter 到Func 的进化

从 Linq Queries 快速生成数据 HTML, EXCEL, CSV 报表

DynamicXml -- 动态读取操作XML (一个从XML到Object的通用实现)

本文链接

如何做一个快乐的ASP.NET程序员

2011-12-19T20:37:00Z

首先我想解释一下标题中两个关键字: "快乐", "ASP.NET程序员".

有的人想成为一个"杰出"的程序员, 或者"资深"的程序员, 简单来说就是"大牛"级的人物 -- 但是本文不是针对此种发展方向不是说我不鼓励大家朝这方向走, 而是对我而言我更看重"快乐"的本身. -- 而且除非你是天才导致"杰出"或者"资深"是同时需要正确的态度和漫长的过程.

那么为什么单单谈"ASP.NET程序员" -- 这是对我本人的写照, 也是对一类人的写照 -- 我们跟着微软混, 在微软的平台上面选择不同的地域,建立自己的城池. -- 不管是出于无奈还是值得骄傲的选择. -- 很大的程度上来说, 微软的举动和变革多少会影响我们的发展前途.

我不想标榜自己的能力, 事实上我只不过一个非常普通的程序员, 没有对技术过人的洞悉能力, 也没有创造出一个让我自豪的系统. 但是我在工作的时候享受着编码和项目组织的喜悦. -- 有朋友问我怎么可以每天都充满这种喜乐, 我开始思考一些久违了的问题.

1. 保持一颗谦卑且自信的心. 这是什么意思? 谦卑意味着, 承认自己的有限, 承认自己的不足. 自信代表, 相信都是人设计的逻辑和框架理论, 只要花时间就可以学得会.

在工作中, 和同事交流的时候,不要担心你对他们说你不懂会降低了你的身份. 因为作为程序员,其实身边的同事都很聪明,交谈中, 你到底会不会大家心里都有数. 如果可以承认自己的有限, 同时虚心的向别人请教, 对方不仅不会"鄙视"你, 还会尊重你,欣赏你. 更重要的是你的请教会让他有成就感,这本身是对他的一种医治和肯定,换句话说,这是一个"双赢"的好事.

[特例: 如果遇到一些人真的会因着你的谦卑而欺负你,要小心保护自己. 但是不要"以妄为常", 这类人往往是因为他在这方面受过伤]

2. 与人分享你的"财富". 作为一个程序员, 什么是你的财富? -- "知识", "经验". 在网上社区和同事中分享你的财富, 会让你更富有.

曾经听过一个讲座. 说贫穷的人关注自己, 中产阶级挤压别人抬高自己, 富有的人影响别人. 请注意, 这里的贫穷和富有不单单是指金钱,内心富有的人不会只关注自己,也不会老想着把别人压下去. 我看到很多喜欢和别人分享自己"财富"的人, 他们一天天的成长, 不断的进步, 也帮助着更多的人.

[特例: 遇到过一些闷声发大财的, 很少能自得其乐. ]

3. 高举实用主义,不追求理论的卓越. 作为一名"ASP.NET"程序员. -- 实用在我看来是很重要的. 从.net1.0 到现在.net本身不断进步完善, 我们用的工具, 设计模式和编码的方式都在变化. 如果你想"了解全盘"或者"追求完美",那么你就完了.

.NET1.0中很多的东西到了现在都不用了, 以前花了很多时间去学这部分的, 如果没有用上的确浪费了.

满足客户或者老板目前的需求, 学习目前项目需要的知识是"实用主义"的本质. 接受项目中代码的不完善, 接受系统的不完美.

看过很多鼓吹"追求卓越"方面的文章, 对于.NET项目来说, 我认为是一种误区. Google 和 Apple.com 都有无法访问的时候.

我们只能在有限时间和有限资源的情况下, 做到最好. -- 别把自己逼疯了.

对于做管理的或者做老板的读者, 我想说的, 大家都在这潭子上混, 退一步海阔天空. 很多时候辛苦做出的系统, 客户未必用的顺手, 也未必真的可以用很久.

以前在HSBC上班时, 听说有个程序员代码写错了, 导致银行赔了10个亿, 银行都没有解雇这哥们 -- 因为这不是他一个人的错, 还牵涉到测试人员和一层层质量把关的问题.

说明一下, 我并非说软件质量不重要, 而是说要关注在实际需求上, 而非不切实际的要求.

[特例: 听说有些公司有些老板, 对程序员的要求很苛刻, 我认为可以尝试着跟他们沟通, 往公司里多注入一些"幽默感"]

4. 关注新事物, 立足不变的基础. 永远不要放弃对新事物的关注. 常常上上cnblogs, 订阅各类你喜欢的feed, 很多时候一个简单的新东西会节省你几天的摸索.

但是光光学新东西是不够的. 很多基础的东西, 象C#语言本身, 设计模式等等, 一定要学. 不知道为什么还有人在评论asp.net程序员是拖控件的....

5. 了解自己, 善于使用已有的代码. 有这样一个故事, 客户向程序员说他的需求, 一个大牛立刻飞快的敲着键盘开始架构, 开始以每秒80公里的速度编程; 另外一个大牛说:"等等, 我做过这个东西".

不管是你以前做过, 还是你可以在网上找到代码. 那都是你的资产. 花一点点时间整理你的资产.

[特例: 有人花一个星期到网上找需要的代码, 最后只得自己写. -- 也不要太执着了, 多问问身边的程序员, 说不定他们可以很快告诉你答案]

如果你不同意我的观点, 可以讨论; 如果你认同可以推荐一下,让大家都来关注程序员的快乐.

本文链接

DynamicXml -- 动态读取操作XML (一个从XML到Object的通用实现)

2011-12-13T20:18:00Z

最近的一个项目用到很多不同结构的XML文件. 于是就在网上搜索了一些文章, 结合实际遇到的问题写成自己要的代码.

既然已经获取了这方面的知识,不敢独取, 拿出来共享. 这个也还不是很成熟, 希望大家共同完善, 提出宝贵意见, 共同进步.

目标

基于已经有的XML文件,例如:

<root>
<books>
<book>
<author>John Savacki</author>
<title>E.G.Title</title>
<price>20.50</price>
</book>
<book>
<author>Tom Curly</author>
<title>E.G.Title 2</title>
<price>26.50</price>
</book>
</books>
</root>

或者是类似任意结构的XML文件, 可以实现初始化

dynamic dx = new DynamicXml(xml);

并且读取属性值:

dx.books.book[0].author, dx.books.book[2].price

解决方案

自然是选择C# 4.0 中引入的 DynamicObject, 关键是已有的.net框架中不能提供这样的功能.

那么就从这个类中继承生成子类, 同时也需要实现 IEnumerable.

稍微介绍一下:

DynamicObject 类使您能够定义可以动态对象上执行哪些操作以及如何执行这些操作。

如果只需要设置和获取属性的操作，您可以只覆盖 TrySetMember 和 TryGetMember 方法。

IEnumerable 公开枚举器，该枚举器支持在非泛型集合上进行简单迭代。

应该大家都知道要实现自定义集合的IEnumerable 就要完成

public IEnumerator GetEnumerator()

也就是说, 为了实现需求, 至少我们需要完成三个函数:

TrySetMember, TryGetMember, GetEnumerator

实现

通过上面的分析, 我们知道这个类看起来应该是这样:

public class DynamicXml : DynamicObject, IEnumerable
{

public DynamicXml(string text)
{
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
}
public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
{
}
public IEnumerator GetEnumerator()
{
}

}

在构造函数里我们希望可以读取XML的内容, 加载所有元素的值.

在TrySetMember中, 我们为设置成员值的操作提供实现, 以便为设置属性值指定动态行为。在本文中, 我们只考虑读取XML内容, 所以不需要重写这个函数.

在TryGetMember中, 我们要为获取成员值的操作提供实现。

在 TryGetIndex中, 我们要为按索引获取值的操作提供实现.

实现的代码如下:

public class DynamicXml : DynamicObject, IEnumerable
{
private readonly List<XElement> _elements;

public DynamicXml(string text)
{
var doc = XDocument.Parse(text);
_elements = new List<XElement> { doc.Root };
}

protected DynamicXml(XElement element)
{
_elements = new List<XElement> { element };
}

protected DynamicXml(IEnumerable<XElement> elements)
{
_elements = new List<XElement>(elements);
}

public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = null;
if (binder.Name == "Value")
result = _elements[0].Value;
else if (binder.Name == "Count")
result = _elements.Count;
else
{
var attr = _elements[0].Attribute(
XName.Get(binder.Name));
if (attr != null)
result = attr;
else
{
var items = _elements.Descendants(
XName.Get(binder.Name));
if (items == null || items.Count() == 0)
return false;
result = new DynamicXml(items);
}
}
return true;
}

public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
{
int ndx = (int)indexes[0];
result = new DynamicXml(_elements[ndx]);
return true;
}

public IEnumerator GetEnumerator()
{
foreach (var element in _elements)
yield return new DynamicXml(element);
}
}

运用

在具体运用中, 有些地方是非常有趣的, 因为我们有了dynamic, 所以你可以用同一个变量去获取不同结构的XML文件. 运用代码如下:

static void Main(string[] args)
{
string xml = @"<root>
<books>
<book>
<author>John Savacki</author>
<title>E.G.Title</title>
<price>20.50</price>
</book>
<book>
<author>Tom Curly</author>
<title>E.G.Title 2</title>
<price>26.50</price>
</book>
</books>
</root>";
dynamic dx = new DynamicXml(xml);
Console.WriteLine("----- Book List -----");
foreach (dynamic b in dx.books.book)
{
Console.WriteLine("author='{0}'", b.author.Value);
print(b);
}
Console.WriteLine("------ Book List End ------");

string xml2 = @"<root>
<products>
<product>
<title>iPhone 4</title>
<price>2222.50</price>
<quantity>10</quantity>
</product>
<product>
<title>Lenovo IdeaPad</title>
<price>5432.50</price>
<quantity>15</quantity>
</product>
</products>
</root>";

dx = new DynamicXml(xml2);

Console.WriteLine("----- Product List -----");
foreach (dynamic b in dx.products.product)
{
Console.WriteLine("quantity='{0}'", b.quantity.Value);
print(b);
}
Console.WriteLine("------ Product List End ------");

Console.Read();
}

我把print函数专门拿出来, 故弄玄虚一下, 因为两个XML的结构有类似的地方, 所以可以同时使用下面的函数. -- 当然对于这样的情况,我们也可以为此定义一个interface.

static void print(dynamic b)
{
Console.WriteLine("Title='{0}'", b.title.Value);
Console.WriteLine("price='{0}'", b.price.Value);
}

不是什么很深奥的东西, 但是希望可以为有同样问题的朋友们节省一些时间.

如果可以较好的掌握Dynamic, 可以节省一些反射方面的代码. 不过这是另外一个话题了.

本文来自于喜乐的ASP.NET(Alex Song) 转贴请注明出处

参考文章:

Dynamic XML

Fluent XML Parsing Using C#'s Dynamic Type Part 1 | CapTech ...

本文链接

从 Linq Queries 快速生成数据 HTML, EXCEL, CSV 报表

2011-12-12T21:28:00Z

在CodePlex 上经常可以发现一些好东西, 关键是有没有时间去淘宝.

前几天就发现一个, 并且在实际工作中使用了:

* DoddleReport

你有没有被要求基于来自数据库的数据,生成一个报表? 我们时不时会有类似的需求.

DoddleReport极大的简化了这方面的工作量.

首先你需要下载它的Dll 文件, 可以到 codeplex 中得到http://doddlereport.codeplex.com/

或者直接从这里下载: cnblogs下载地址

得到的是一样的文件, 将它解压到你的一个asp.net 网站的bin目录下. 你就可以引用Doddle的类了.

我们来模拟一个场景(本场景是根据DoddleReport提供的sample 代码改编的):

创建一个aspx页面, 加入下面的代码:

创建一个Product 类:

public class Product
{
public int Id { get; set; }
public string Name { get; set; }
public string Description { get; set; }
public double Price { get; set; }
public int OrderCount { get; set; }
public DateTime LastPurchase { get; set; }
public int UnitsInStock { get; set; }

}

随机生成1000个Product的数据, 方便我们测试结果:

public static List<Product> GetAll()
{
var rand = new Random();
return Enumerable.Range(1, 1000)
.Select(i => new Product
{
Id = i,
Name = "产品 " + i,
Description =
"描述...",
Price = rand.NextDouble() * 100,
OrderCount = rand.Next(1000),
LastPurchase = DateTime.Now.AddDays(rand.Next(1000)),
UnitsInStock = rand.Next(0, 2000)

})
.ToList();
}

下面我们要用到DoddleReport的类:

protected void Page_Load(object sender, EventArgs e)
{
// Get the data for the report (any IEnumerable will work)
var query = GetAll();

// Create the report and turn our query into a ReportSource
var report = new Report(query.ToReportSource());

// Customize the Text Fields
report.TextFields.Title = "报告的标题";
report.TextFields.SubTitle = "副标题";
report.TextFields.Footer = "页脚";
report.TextFields.Header = string.Format(@"制作时间: {0}", DateTime.Now);

// Render hints allow you to pass additional hints to the reports as they are being rendered
report.RenderHints.BooleanCheckboxes = true;

// Customize the data fields
report.DataFields["Id"].Hidden = true;
report.DataFields["Price"].DataFormatString = "{0:c}";
report.DataFields["LastPurchase"].DataFormatString = "{0:d}";

var writer = new HtmlReportWriter();
writer.WriteReport(report, Response.OutputStream);

}

首先用我们的数据生成一个Report的实例; 然后指定Report的一些属性, 例如标题, 页眉, 页脚(很酷,是吗). 再指定一些列的属性, 例如隐藏ID, 和给一些列特殊的格式.

最后调用ReportWriter将数据写出到页面.

下面是生成的截图:

如果你要生成Excel 或者CSV(以逗号或者tab为分隔符的文件)可以简单的修改ReportWriter后面的代码为:

string s = Request.PhysicalApplicationPath;

var exWriter = new ExcelReportWriter();
exWriter.WriteReport(report, System.IO.File.Create(s + "fil7.xls"));

或者

var deWriter = new DelimitedTextReportWriter();
deWriter.WriteReport(report, System.IO.File.Create(s + "fil7.csv"));

可以看看效果:

希望可以帮助到有这方面需要的朋友们.

本文来自于喜乐的ASP.NET(Alex Song) 转贴请注明出处

本文链接

从 Comparison/Converter 到Func 的进化

2011-11-29T21:32:00Z

本篇文章给大家介绍两个在.net2.0 中就已经出现的, 很"老"的委托方式.

通常情况下, 我们在Array 和 List<T> 类中使用这些功能. 明白用法和作用可以帮助你自如的使用它们.

但是你也可以使用和它们作用相同的Func 家族的形式 -- 在.NET 2.0 之后引入的新功能.

通过了解这些基本信息可以帮助我们看到一部分.net 进化的过程. 我称这种内容为"历史".

只是抛砖引玉, 希望大家多多交流

Comparison<T>

它的出现是为了对Array 和 List<T> 执行type-safe 排序.

注意, Linq函数的 OrderBy(), ThenBy() 是不支持comparison<T>委托的.

看下面的实例:

using System;
using System.Collections.Generic;
using System.Linq;

public class Hero
{
public string Name { get; set; }
public int Age { get; set; }
public double Power { get; set; }
}

class Program
{
static void Main(string[] args)
{
var heroes = new List<Hero>
{
new Hero {Name = "Goku", Age = 60, Power = 1000.00},
new Hero {Name = "Vegeta", Age = 65, Power = 800.00},
new Hero {Name = "Ikki", Age = 22,Power = 345.30},
new Hero {Name = "Dr. Slump", Age = 40, Power = 1.23},
};

Console.WriteLine("***** sort by age ****");
heroes.Sort((lhs, rhs) => Comparer<int>.Default.Compare(lhs.Age, rhs.Age));
Print(heroes);
Console.WriteLine("***** sort by name ****");
heroes.Sort((lhs, rhs) => string.Compare(lhs.Name, rhs.Name));
Print(heroes);
Console.WriteLine("***** sort by power ****");
heroes.Sort((lhs, rhs) => Comparer<double>.Default.Compare(rhs.Power, lhs.Power));
Print(heroes);

Console.Read();
}

private static void Print(IEnumerable<Hero> heroes)
{
foreach (var hero in heroes)
{
Console.WriteLine(hero.Name + "(" + hero.Age + ")");
}
}

很容易理解上面几种排序的方法. 那么使用新的Func时, 实现如下:

Console.WriteLine("***** sort by name(Func) ****");
var heroesOrderByName = heroes.OrderBy(t => t.Name);
Print(heroesOrderByName);

在这种情况下Comparison<T> 使用较少的原因, 就是相对代码工作量大, 实现复杂一些.

Converter<TInput, TOutput>

Converter的使用是对某种类型的列表或者数组进行操作, 将其转化为另外一个类型的列表或者数组.

继续使用上面的代码, 插入:

Console.WriteLine("***** TestFunc ****");
TestFunc(heroes);

Console.WriteLine("***** TestConverter ****");
TestConverter(heroes);

Console.WriteLine("***** TestLinqSelect ****");
TestLinqSelect(heroes);

private static void TestFunc(List<Hero> heroes)
{
Func<Hero, string> selector = p => p.Name;

IEnumerable<string> names = heroes.Select(selector);

print(names);
}

private static void TestLinqSelect(List<Hero> heroes)
{
var names = heroes.Select(p => p.Name);

print(names);
}

private static void TestConverter(List<Hero> heroes)
{
var names = heroes.ConvertAll(p => p.Name);

print(names);
}

private static void print(IEnumerable<string> names)
{
foreach (string name in names)
Console.WriteLine(name);
}

其实上面 TestLinqSelect 和 TestFunc 是同一码事, 我只是给大家提供不同的代码方案而已. 一般, 我们不会使用TestFunc 这种形式.

注意, 用 Linq 的Select 和其他一些Linq的函数一样, 是推迟执行, 这意味着, 很多时候, 它们将不执行转换, 直到数值被使用.

这事实上是双刃剑, 有时候它可以获取更好的效率, 但是如果你马上就想要结果就会导致额外的后台工作开销 -- 支持延迟执行的功能本身需要使用到yield return /yield break 来维持当前状态的信息迭代器.

小结

本质上来讲, Comparison/Converter 和与之相对应的Func没有太多区别, 但是为什么.net 让它们同时存在, 或者换句话讲在有了实现方案后, 为什么要"多余"引入后者?

这是因为之后被引入的委托Func<>是一个多功能兵种, 但是在执行具体任务的时候效果稍有区别.

在新项目中, 我们也更倾向于使用新的方法.

参考文章:C#/.NET Little Wonders: The Predicate, Comparison, and Converter Generic Delegates

本文来自于喜乐的ASP.NET(Alex Song) 转贴请注明出处

本文链接

不可不知的C#基础 4. 延迟加载 -- 提高性能

2011-11-23T20:41:00Z

延迟加载(lazy loading) 设计模式是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据(读取属性值)的时候，才真正执行数据加载操作.

有效使用它可以大大提高系统性能.

为了便于理解, 我们来建立一个场景, 假设我们要构造一个Hero(英雄) 类, 每个Hero 有自己的名字和(SpecialSkill)特殊技能.

建模

这是一种建立的方法:

public class Hero
{
public string FullName { get; set; }
public string Name { get; set; }
public SpecialSkill Skill{ get; set; }

public Hero(string name)
{
Name = name;
FullName = "Super " + name;
Skill = new SpecialSkill(name);
}
}
public class SpecialSkill
{
public int Power { get; set; }
public string SkillName { get; set; }
public int StrengthSpent { get; set; }
public SpecialSkill(string name)
{
Console.WriteLine("loading special skill .....");
Power = name.Length;
StrengthSpent = name.Length * 3;
SkillName = name + " Blazing";
Console.WriteLine(SkillName + ",... this's what makes a legend!");
}
}
class Program
{
static void Main(string[] args)
{
Hero hero = new Hero("wukong");
Console.WriteLine("\n\n.......................Press Enter to continue.......................\n\n");
Console.Read();
Console.WriteLine("Hero's special skill: " + hero.Skill.SkillName);
Console.Read();
Console.Read();
}
}

运行程序后输出如下, 这个例子非常的容易理解, 结果也是显然的.

它的缺点是, 当运行Hero 构造函数的时候, SpecialSkill 的所有属性都已经加载了. 如果我们只想获取这个Hero 的FullName, 我们也加载了SpecialSkill 所有值.

属性的加载延迟

在没有Lazy<T> 以前我们可以这样做:

public class Hero
{
public string FullName { get; set; }
public string Name { get; set; }
private SpecialSkill skill;
public SpecialSkill Skill
{
get { return skill ?? (skill = new SpecialSkill(Name)); }
}
public Hero(string name)
{
Name = name;
FullName = "Super " + name;

}
}

即: 修改属性SpecialSkill的加载方法. 那么当我们再运行程序时, 得到的输出就是:

非常好! 这就是我们要的效果, 这样可以让系统更加的有效率.

Lazy<T>

当net framework 引入了Lazy<T> 类后, 我们也可以使用它来实现:

public class Hero
{
    public string FullName { get; set; }
    public string Name { get; set; }
    
    private readonly Lazy<SpecialSkill> skill;
    public SpecialSkill Skill
    {
        get { return skill.Value; }
    }

    public Hero(string name)
    {
        Name = name;
        FullName = "Super " + name;
        
        skill = new Lazy<SpecialSkill>(() => new SpecialSkill(name));
    }
}

Lazy<T>提供对延迟初始化的支持。而 Lazy<T> 中的一个属性 Value, 则是获取当前 Lazy<T> 实例的延迟初始化值。

Lazy<T>的优势

那么既然我们已经可以用属性缓存的方法实现, 为什么还要引入Lazy<T> ?

至少Lazy<T> 有以下几点优势:

它具有 LazyThreadSafetyMode, 但是我们一般不使用它, 除非是很关键的情况下(在此略去181个字)
它使属性的定义行更加简单
从语义上来讲, 它更加明确, 更加具有可读性
它允许null为有效值

本文来自于喜乐的ASP.NET(Alex Song) 转贴请注明出处

一些相关文章:

不可不知的C#基础 1. -- Extension 扩展方法

不可不知的C#基础 2. -–从 struct 和 class的异同说开去

不可不知的C#基础 3. 线程浅析

本文链接

不可不知的C#基础 3. 线程浅析

2011-10-28T22:08:00Z

线程可以使你的项目运行得更加的流畅.

什么是线程呢?

线程(thread)是程序执行流的最小单元, 是程序中一个单一的顺序控制流程. 每个程序最少有一个线程, 那就是程序本身.

在C#中, 你可以使用 System.Threading 提供的类,接口和方法实现线程的所有操作.

单线程操作

想象着你走进快餐店, 大叫一声"来碗兰州拉面", 然后就坐在饭桌上等. 当厨师听到你的要求时,他就开始做兰州拉面了. 理论上讲, 当你叫了以后, 厨师就已经收到了命令.

用代码可以这样表达:

static void Main(string[] args)
{
string name = "兰州拉面";
Console.WriteLine("来碗" + name);
PlaceOrder(name);
Console.WriteLine("坐在饭桌上....");
Console.Read();
}
static void PlaceOrder(string name)
{
Console.WriteLine("开始制作" + name);
}

运行程序, 你会发现输出结果是:

从显示的结果来看, 这个厨师的动作非常的快, 他一听到命令, 马上就开始了. 为了让这个程序的模拟比较真实, 我们可以想象"我的动作"是一个线程, 而"厨师做拉面"是一个线程.

如果我们运用线程来实现就有点意思了:

static void PlaceOrder(string name)
{
Thread thread1 = new Thread(new ThreadStart(Cooking));
thread1.Start();
}
static void Cooking()
{
Console.Write("开始制作");
}

运行程序, 你会发现输出结果是:

这是表示虽然厨师听到你的声音了,但是你坐在饭桌上的动作是在他开始做拉面之前. -- 更加的合情合理, 是吗?

我们还可以引入参数:

static void PlaceOrder(string name)
{
Thread thread1 = new Thread(t => Cooking(name));
thread1.Start();
}
static void Cooking(string name)
{
Console.WriteLine("开始制作" + name);
}

注意上面的参数的传递方法只用于.net 3.5/4

多线程

如果一个饭店有多个厨师, 并且同时有多个人点餐, 我们可以像这样模拟实现:

static void Main(string[] args)
{
string name = "兰州拉面";
int number = 5;
Console.WriteLine("来" + number + "碗" + name);
PlaceOrder(name, 5);
Console.WriteLine("坐在饭桌上....");
Console.Read();
}
static void PlaceOrder(string name, int number)
{

for (int i = 0; i < number; i++)
{
Thread thread1 = new Thread(t => Cooking(name));
thread1.Start();
}
}
static void Cooking(string name)
{
Console.WriteLine("开始制作" + name);
}

运行后, 结果显示:

嗯, 有些厨师动作还是快得像机器人, 让我们给他们一些休息的时间:

static void Cooking(string name)
{
Thread.Sleep(10);
Console.WriteLine("开始制作" + name);
}

再次运行程序, 结果是:

线程的关联性和独立性

线程的运作是相对独立的, 完成不同的工作. 但是它们却是共享进程内的资源.

做个实验:

static void PlaceOrder(string name, int number)
{
int[] array = new int[] {1000,500,300,500,1};
for (int i = 0; i < number; i++)
{

int time = array[i];
Thread thread1 = new Thread(t => Cooking(name, i,time));
thread1.Start();
}
}
static void Cooking(string name, int id, int time)
{
Thread.Sleep(10);
Console.WriteLine(id + "号开始制作" + name);
}

这里我们想给每一个厨师一个编号, 但是当把i 当中参数传递的时候, visual studio 会发出警告:

" Access To Modified Closure “.

这个是什么意思呢? 运行一下程序, 输出是:

发现在运行程序的时候, 错误的读取了厨师的编号, 这就是那个警告发出的原因: 因为线程们共享的名字 i 在不停的变化中, 我们没有办法控制一个特定线程运行时i 的值, -- 它们是相对独立的.

解决方案就是增加一个变量名存放值作为传递:

最后我们来看看, 线程中独立运行的实验:

static void PlaceOrder(string name, int number)
{
int[] array = new int[] {1000,500,300,500,1};
for (int i = 0; i < number; i++)
{
int j = i;
int time = array[i];
Thread thread1 = new Thread(t => Cooking(name, j,time));
thread1.Start();
}
}
static void Cooking(string name, int id, int time)
{
Thread.Sleep(10);
Console.WriteLine(id + "号开始制作" + name);
Thread.Sleep(time);
Console.WriteLine(id + "号准备完毕,花费时间:" + time);
}

每个厨师的速度是不一样的, 他们花费的时间不同, 所以先开始的不一定先完成, 上面的代码运行的结果是:

请仔细读读上面的代码和输出的结果, 应该大家都可以理解.

本文来自于喜乐的ASP.NET(Alex Song) 转贴请注明出处

本文链接

不可不知的C#基础 2. -–从 struct 和 class的异同说开去

2011-10-14T19:17:00Z

我知道很多人都讨论过这个问题, 多我一个不多, 少我一个不少.

最近有人又问到这个问题, 所以想再说说. 万丈高楼平地起, 地基很重要. 懂了的人不要嫌罗嗦, 欢迎补充或者纠正.

从起源/定义说起

Struct 从C 的时代就已经有了(向丹尼斯.里奇致敬), 它是Structure 的缩写 -- 就是结构的意思. 它是一种最初级的数据结构, 它包含一到多个相同类型或不同类型的值或者变量. 它就像是一个存储数据的"包".

Class(类) 是有了面向对象概念之后才有的, 它"是创建对象的蓝图,描述了所创建的对象共同的属性和方法".

从它们被创立的用途可以看出Class 比Struct 负担了更大的使命.

类从出生的那天就被赋予了一个伟大的使命: 模拟真实世界的行为, 拥有继承和多态两种利器.

Struct 到了C#这个领域中有了一个进化, 它甚至可以实现接口(当然,这个也是C时代没有的东西), 在本文中会有一个简单的介绍.

值类型 VS 引用类型

在.net 世界中, System.Object "支持 .NET Framework 类层次结构中的所有类，并为派生类提供低级别服务。这是 .NET Framework 中所有类的最终基类；它是类型层次结构的根。" 从Object再衍生出所有类、结构、枚举和委托。

看看下面这个图对net中两大类型的描述, -- 当然还有一种"指针类型",在这里我们不予讨论.

Struct 是属于值类型这个阵容, 而所有class 都是引用类型.

这意味着什么?

当我们使用等号"赋值"时, 对于Struct而言就是将同样的值复制给另一个变量; 而对于Class而言就只是将它们的名字指向同一个对象.

看下面的实例:

class FooClass
{
public int FooValue;
}
struct FooStruct
{
public int FooValue;
}

class Program
{

static void Main(string[] args)
{
FooClass classObj = new FooClass();

classObj.FooValue = 0;

FooClass classObj2 = classObj;

classObj2.FooValue = 1;

FooStruct structObj = new FooStruct();

structObj.FooValue = 0;

FooStruct structObj2 = structObj;

structObj2.FooValue = 1;

}

}

再最后设个断点, 运行后取值:

structObj2 在初始时, 会创建一个全新的副本, 然后获取structObj 的所有数值;

classObj2 在初始时, 只是指向了classObj. 这就是值类型和引用类型的一个区别. 当修改classObj 或者 classObj2 时, 修改的是同一部分内存.

Struct实现接口

前面提到了Struct可以实现接口, 下面我们引用一个实例:

interface IPromotion
{

void promote();

}

struct Employee : IPromotion
{

public string Name;

public int JobGrade;

public void promote()
{

JobGrade++;

}

public Employee(string name, int jobGrade)
{

this.Name = name;

this.JobGrade = jobGrade;

}

public override string ToString()
{

return string.Format("{0} ({1})", Name, JobGrade);

}

}

class Program
{

static void Main(string[] args)
{

Employee employee = new Employee("Cool Guy", 65);

IPromotion p = employee;

Console.WriteLine(employee);

p.promote();

Console.WriteLine(employee);

}

}

一旦增加了这个功能, 我们就可以在应用Struct之前, 给予其一些接口的定义. 使一类的struct 在形式上保持一致.

不同的用途

使用中在struct 和 class 两者间该选谁?

我们在编程中要实现某种数据结构时, 绝大部分情况下我们会选择class -- 因为它的强大和特定的使命. 但是当我们要传递或存储一些小数据结构时,可以考虑struct.

Net framework 下有很多已经定义好了的struct例如:

System.Drawing.Rectangle
System.Drawing.Color
System.Drawing.Point

使用时要记住struct的特性.

本文来自于喜乐的ASP.NET(Alex Song) 转贴请注明出处

本文链接

不可不知的C#基础 1. -- Extension 扩展方法

2011-10-12T19:13:00Z

背景

前几天有同事问到我一个简单的功能, 就是当你使用枚举时如何给每个一元素增加描述字符串并且可以很容易的读取出来.

比如有一个枚举类型是列出对一个问题给出的选项(例如: 同意?不同意?中立?):

public enum AssessmentAnswer
{
Strongly_Disagree = 1,
Disagree = 2,
Neutral = 3,
Agree = 4,
Strongly_Agree = 5
}

当选择不同的答案时, 希望得到一些描述性的语句比方说:

1. "强烈的反对"

2. "反对"

3. "持中立观点"

4. "同意"

5. "完全的同意"

当然你可以建立一个数据库表格,存放这些信息, 但是我想起几年前,我在网上下载一个 EnumDescription 源码(忘记了是在哪里下载的), 就可以实现这一功能.

让我们一起来看看是怎么样用 Extension 做到的:

实现

首先定义一个EnumDescription 类:

public class EnumDescription : Attribute
{
public string Text
{
get { return _text; }
} private string _text;

public EnumDescription(string text)
{
_text = text;
}
}

注意它的父类是Attribute, 因为我们希望将描述的语句作为每一个对应元素的特性. 然后新建一个文件,命名EnumExtensions.cs

public static class EnumExtensions
{
public static string ToDescription(this Enum enumeration)
{
Type type = enumeration.GetType();
MemberInfo[] memInfo = type.GetMember(enumeration.ToString());

if (null != memInfo && memInfo.Length > 0)
{
object[] attrs = memInfo[0].GetCustomAttributes(typeof(EnumDescription), false);
if (null != attrs && attrs.Length > 0)
return ((EnumDescription)attrs[0]).Text;
}

return enumeration.ToString();
}
}

在这里我们定义了一个扩展函数ToDescription, 就像所有的扩展函数一样,它的参数是类似(this …),

这个函数首先用GetType 得到了当前枚举的类型, 然后借助 GetMember按照元素的名字(值), 得到这个特定的元素, 最后用GetCustomAttributes 得到描述的内容.

这个扩展函数实现后,我们可以修改枚举的定义,加入描述:

public enum AssessmentAnswer
{
[EnumDescription("强烈的反对")]
Strongly_Disagree = 1,

[EnumDescription("反对")]
Disagree = 2,
Neutral = 3,
Agree = 4,
[EnumDescription("完全的同意")]
Strongly_Agree = 5
}

当要获取描述语句时, 你可以轻松的调用ToDescription :

//返回 "强烈的反对"

AssessmentAnswer.Strongly_Disagree.ToDescription()

注意, 如果没有给元素加入特性, 你仍旧可以使用ToDescription, 可以参考上面的代码看看是为什么.

//返回 “Disagree”

AssessmentAnswer.Disagree.ToDescription()

总结

扩展方法作为特殊的静态方法使您能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。

对于用 C# 和 Visual Basic 编写的客户端代码，调用扩展方法与调用在类型中实际定义的方法之间没有明显的差异。

给初学者的话: 一旦当你实现扩展方法后, 你只需要复制dll 添加文件命名空间; 或者复制cs文件到你的项目中, 就可以使用这些方法, 但是建议除非你有充分的理由才实现扩展方法。

很多我们要用到的扩展方法都可以在网上得到, 所以一般在写自己的扩展前请先搜索一下.

本文来自于喜乐的ASP.NET(Alex Song) 转贴请注明出处

本文链接

WebMatrix教程(五) (快速建立数据图表的方案)

2011-09-29T18:29:00Z

很多人都知道使用 Webmatrix -- Microsoft 推出的最新武器可以很容易帮助你在windows下设置安装最常用的php, asp.net 开源网络应用如：wordpress, DNN, Umbraco, mojoportal, Joomla 等。

同时Webmatrix支持的Razor让你可以很快的建立小型动态的.net网站，其实Webmatrix 还有一个卖点就是它有Helper库，熟悉了解这些Helper才可能真正的使用Webmatrix来建立具有应用价值的网站。

今天我们来看看图表的库： Chart。

如果你以前没有接触过Webmatrix，建议你先快速阅读下面的文章：

WebMatrix教程(一) (关注Microsoft 的最新武器：建立你的第一个WebMatrix网站）

WebMatrix教程(二) (关注Microsoft 的最新武器：基于空白项目建立你的WebMatrix网站[上篇]）

WebMatrix教程(三) (关注Microsoft 的最新武器：基于空白项目建立你的WebMatrix网站[下篇]）

WebMatrix教程(四) (读取数据库)

支持多种图表

先建立一个空白站点或者使用WebMatrix 的 Template 建立一个Starter Site：

新建一个cshtml 文件，命名为MyCharts.cshtml

删除自动生成代码，替换成下面的：

@{

var firstChart = new Chart(width: 350, height: 250)
.AddTitle("图表测试")
.AddSeries(
name: "Teams", chartType: "Bar",
xValue: new[] { "China", "USA", "Canada", "UK" },
yValues: new[] { "12", "6", "4", "3"})
.Write();
}

点击 Run，在浏览器中生成的页面如下：

chart 帮助支持多种形式的图表，如饼图，线，填充，柱形图。如果你改变ChartType的值就可以轻松获取不同种类的图表：

将上面代码中的

替换成：

可以得到：

替换成：

或者：

当然数据来源还可以是database table 或者 xml 文件：

从 Database 中读取

在这里，我们建立一个名叫supermen的table，然后定义它的列如下：

再输入一些初始数据：

将mycharts中原来的代码删除，替换成：

@{
var db = Database.Open("StarterSite");
var data = db.Query("SELECT Name, Power FROM Supermen");
var secChart = new Chart(width: 350, height: 250)
.AddTitle("超人大比拼")
.DataBindTable(dataSource: data, xField: "Name")
.Write();

}

DataBindTable 指定了数据源和X轴使用的数据。

或者你也可以分别指定X轴和Y轴：

var secChart = new Chart(width: 350, height: 250)
.AddTitle("超人大比拼")
.AddSeries("Default",
xValue: data, xField: "Name",
yValues: data, yFields: "Power").Write();

都生成下面的图表：

从XML中读取

如果要从XML中读取数据，我们要先建立两个文件：XML 数据文件，和XSD 结构文件。

在App_Data目录下新建一个文件命名为data.xml，编辑并改写文件内容如下:

<?xml version="1.0" standalone="yes" ?>
<NewDataSet xmlns="http://tempuri.org/data.xsd">
    <User>
        <Name>Alex</Name>
        <Age>31</Age>
    </User>
    <User>
        <Name>Adam</Name>
        <Age>30</Age>
    </User>
    <User>
        <Name>Otto</Name>
        <Age>23</Age>
    </User>
    <User>
        <Name>Jessica</Name>
        <Age>8</Age>
    </User>
</NewDataSet>

再生成一个名为data.xsd的文件，使用如下对应的格式：

<?xml version="1.0" ?>
<xs:schema
    id="NewDataSet"
    targetNamespace="http://tempuri.org/data.xsd"
    xmlns:mstns="http://tempuri.org/data.xsd"
    xmlns="http://tempuri.org/data.xsd"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"
    attributeFormDefault="qualified"
    elementFormDefault="qualified">
    <xs:element name="NewDataSet"
        msdata:IsDataSet="true"
        msdata:EnforceConstraints="False">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element name="User">
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element
                                name="Name"
                                type="xs:string"
                                minOccurs="0" />
                            <xs:element
                                name="Age"
                                    type="xs:int"
                                    minOccurs="0" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:choice>
        </xs:complexType>
    </xs:element>
</xs:schema>

最后我们新建一个名为users.cshtml的文件，并且编辑其内容为：

@using System.Data;
@{
var dataSet = new DataSet();
dataSet.ReadXmlSchema(Server.MapPath("~/App_Data/data.xsd"));
dataSet.ReadXml(Server.MapPath("~/App_Data/data.xml"));
var dataView = new DataView(dataSet.Tables[0]);

var myChart = new Chart(width: 350, height: 300)
.AddTitle("用户年龄")
.AddSeries("图表",
xValue: dataView, xField: "Name",
yValues: dataView, yFields: "Age")
.Write();
}

解释一下上面的代码 using System.Data 表示要引用 System.Data 类库.

DataSet.ReadXmlSchema 读取我们将要使用数据的结构,ReadXml读取数据源.

DataView从dataSet中得到第一个表格,即我们要使用的数据:

点击run后,生成的页面如下:

本文来自于喜乐的ASP.NET(Alex Song) 转贴请注明出处

本文链接

博客园_喜乐的ASP.NET(Alex Song)

非常好玩的C#/.NET 基础 -- 安全有效引发事件

如何做一个快乐的ASP.NET程序员

DynamicXml -- 动态读取操作XML (一个从XML到Object的通用实现)

从 Linq Queries 快速生成数据 HTML, EXCEL, CSV 报表

从 Comparison/Converter 到Func 的进化

不可不知的C#基础 4. 延迟加载 -- 提高性能

不可不知的C#基础 3. 线程浅析

不可不知的C#基础 2. -–从 struct 和 class的异同 说开去

不可不知的C#基础 1. -- Extension 扩展方法

WebMatrix教程(五) (快速建立数据图表的方案)

不可不知的C#基础 2. -–从 struct 和 class的异同说开去