博客园_Frog

关于ExecuteScalar您可能会疏忽的地方

2011-05-12T10:36:00Z

大家都很熟悉SqlCommand的ExecuteScalar方法：

object obj = command.ExecuteScalar();

该方法会返回一个标量值。很多时候，我们需要对obj进行是否为空的验证。这时候问题就来了，到底是该

if( obj != null )

还是

if( obj != DBNull.Value)?

首先我们来看看ExecuteScalar的使用场景

配合T-Sql的聚合函数使用，如Count

当返回某一行特定列时也可以使用

总之就是当查询结果只是一个标量值的时候就可以使用。

接下来我们假定有这样一张数据表(Student)：

ID PK

Name NOT NULL

Age NULL

再假设该表有如下数据：

ID Name Age

1 Tom NULL

2 Mike NULL

如果我们要取得所有Student中Age最大值，可以如下

SELECT MAX(Age) FROM dbo.Student WITH(NOLOCK)

在.NET 这一层我们就可以使用ExecuteScalar来取得值了。我们知道T-Sql的结果是NULL,但在.NET这边呢？我们一跟踪就会发现是DBNull.

因此我们可以就此下结论了么？不能。

紧接着再来看种情形。要求我们获取ID=3的学生的姓名

SELECT TOP 1 Name FROM dbo.Student WITH(NOLOCK)

WHERE ID = 3

很显然，该语句的结果是一个空的结果集。

这时候再去跟踪你就会发现返回值为null.

因此对于很多经常只简单判断！=null 或者!= DNNull.Value的童鞋要注意了，说不定什么时候代码就出问题了。

再简单总结下：当sql语句返回NULL时，.NET这一端的返回值为DBNull.Value

当sql语句这一端为空结果集时，.NET这一端为null.

希望对各位能有帮助。

本文链接

[.Net 4.0]用4.0实现基于Push的Observer模式

2011-02-18T21:26:00Z

在4.0里，微软为我们实现基于Push的观察者模式提供了原生支持：增加了IObserver<T>和IObservable<T>两个接口。

IObserver<T>: 表示接收通知（观察器）的类。

IObservable<T>:表示发送通知（提供程序）的类；

T :表示提供通知信息的类。

下面就应这几个接口来实现常用于解释观察者模式的模型-报纸订阅。

1.创建杂志

class Magazine
{
private string m_Title;

public string Title
{
get { return m_Title; }
set { m_Title = value; }
}
private string m_Issue;

public string Issue
{
get { return m_Issue; }
set { m_Issue = value; }
}

public Magazine(string title, string issue)
{
m_Title = title;
m_Issue = issue;
}
}

2. 接收通知的类即订阅者(这里随便取了哥名字叫Customer)

class Customer : IObserver<Magazine>
{
private string m_Name;

public string Name
{
get { return m_Name; }
set { m_Name = value; }
}

public Customer(string name)
{
m_Name = name;
}
public void OnCompleted()
{
Console.WriteLine("订阅结束");
}

public void OnError(Exception error)
{
throw new NotImplementedException();
}

public void OnNext(Magazine magazine)
{
Console.WriteLine("{0}:新杂志来了!\r\n\t名称:{1}\t期号:{2}",m_Name, magazine.Title, magazine.Issue);
}
}

3.发送通知（提供程序）的类（报摊老板，这里假定这个老板很给力，垄断了报摊生意，全世界以后就他一个人卖报纸，不过他脾气也很怪异，随时都有可能不做生意）

class TheSeller :IObservable<Magazine>
{
private List<IObserver<Magazine>> m_Obervers = new List<IObserver<Magazine>>();

private static readonly TheSeller m_Instance = new TheSeller();

public static TheSeller Instance
{
get { return TheSeller.m_Instance; }
}

private TheSeller()
{
}
public Magazine GetCurrentMagazine()
{
var magazine = new Magazine("测试杂志?", string.Format("第{0}期", IssueSimulator.GenerateIssue()));

foreach (var observer in m_Obervers)
{
observer.OnNext(magazine);
}

return magazine;
}
public IDisposable Subscribe(IObserver<Magazine> observer)
{
m_Obervers.Add(observer);

return observer as IDisposable;
}

public bool IsCrazy()
{
var result = new Random().Next(1, 10) == 5;

if (result)
{
foreach (var observer in m_Obervers)
{
observer.OnCompleted();
}

}
return result;
}
}

4.其他辅助类型(IssueSimulator用生成模拟期号)

static class IssueSimulator
{
private static int m_Issue = 1;

public static int GenerateIssue()
{
return m_Issue++;
}
}

5.调用代码

class Program
{
static void Main(string[] args)
{
var customer1 = new Customer("张三");
var customer2 = new Customer("李四");

TheSeller.Instance.Subscribe(customer1);
TheSeller.Instance.Subscribe(customer2);

while (!TheSeller.Instance.IsCrazy())
{
TheSeller.Instance.GetCurrentMagazine();
Thread.Sleep(2000);
}
}
}

本文链接

用FileSystemWatcher监听自定义配置文件

2010-12-30T05:50:00Z

一、问题描述

我经常会遇到这样的场景：系统中有些自定义的配置文件，为了提升性能，可能会对已解析的配置做缓存。这样造成的结果就是每次更改配置都不得不重启应用程序，配置才会生效。但有时又不希望应用重启，于是问题来了：怎样才能不重启应用就让配置生效？

幸运的是，微软提供了FileSystemWatcher类来完成这个功能。下面就先来说说FileSystemWatcher。

二、关于FileSystemWatcher

FileSystemWatcher: 侦听文件系统更改通知，并在目录或目录中的文件发生更改时引发事件。

FileSystemWatcher有几个重要且常用的属性：

属性名称	描述
Path	获取或设置要监视的目录的路径
Filter	获取或设置筛选字符串，用于确定在目录中监视哪些文件
NotifyFilter	获取或设置要监视的更改类型
EnableRaisingEvents	获取或设置一个值，该值指示是否启用此组件

Path和Filter用于指定监视的内容，NotifyFilter用于指定监视哪些变更，EnableRaisingEvents则用于指定监听器是否已启动。

FileSystemWatcher还有几个重要的事件：

事件名称	描述
Changed	当更改指定 Path中的文件和目录时发生
Created	当在指定 Path中创建文件和目录时发生
Deleted	删除指定 Path中的文件或目录时发
Renamed	重命名指定 Path中的文件或目录时发

在这个问题中，Changed事件就可以完成任务。

三、解决方案

在做维护工具时，我喜欢把sql放到配置文件：

如：

<?xml version="1.0" encoding="utf-8" ?>
<sqls>
  <sql name="getData">
   <![CDATA[
      Select * from table
    ]]>
  </sql>
</sqls>

我的sqlManager可能如下:

    public class SqlManager
    {
        private static XmlDocument SqlDoc;
        private static readonly string ConfigPath = AppDomain.CurrentDomain.BaseDirectory + "\\Sqls\\Sql.xml";
        static SqlManager()
        {
            SqlDoc = new XmlDocument();

            SqlDoc.Load(ConfigPath);
        }

        public static string GetSql(string name)
        {
            var nodes = SqlDoc.SelectNodes("/sqls/sql");

            foreach (XmlNode node in nodes)
            {
                if (node.Attributes["name"].Value.Equals(name, StringComparison.InvariantCultureIgnoreCase))
                {
                    return node.InnerText;
                }
            }

            return string.Empty;
        }
    }

为了实现开篇的要求,我将SqlManager修改如下:

    public class SqlManager
    {
        private static XmlDocument SqlDoc;
        private static readonly string ConfigPath = AppDomain.CurrentDomain.BaseDirectory + "\\Sqls\\Sql.xml";
        private static FileSystemWatcher watcher;
        static SqlManager()
        {
            SqlDoc = new XmlDocument();

            SqlDoc.Load(ConfigPath);

            watcher = new FileSystemWatcher(AppDomain.CurrentDomain.BaseDirectory + "\\Sqls", "*.*");
            watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.Size ;
            watcher.Changed += (obj, e) =>
            {
                SqlDoc.Load(ConfigPath);
            };
        }

        public static string GetSql(string name)
        {
            var nodes = SqlDoc.SelectNodes("/sqls/sql");

            foreach (XmlNode node in nodes)
            {
                if (node.Attributes["name"].Value.Equals(name, StringComparison.InvariantCultureIgnoreCase))
                {
                    return node.InnerText;
                }
            }

            return string.Empty;
        }
    }

这样以后每次修改sql语句就不用再重启应用了。

四、小结

本篇大致介绍了用FileSystemWatcher监听自定义配置文件，在配置文件发生更改自动应用最新配置的问题。关于FileSystemWatcher更详细的介绍请参见MSDN。

本文链接

深入浅出设计模式读书笔记系列

2010-10-28T09:14:00Z

深入浅出设计模式读书笔记—Template Method

深入浅出设计模式读书笔记—Iterator

深入浅出设计模式读书笔记—Composite

深入浅出设计模式读书笔记—状态模式

深入浅出设计模式读书笔记—代理模式(1)

以上为在读深入浅出设计模式这本书时所记录的笔记和心得，方便管理查阅。

本文链接

JQuery UI DatePicker默认z-index为1的解决办法

2010-09-27T07:33:00Z

用到JQuery UI的DatePicker时，发现如果页面有其他z-index比较大的控件，datepicker就会被遮住而不能操作。在网上也没能找到有效的解决办法，下面我提供一种看似投机的办法：

  $("#txtFillInDate").datepicker({
            monthNames: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月'],
            dayNamesMin: ['日', '一', '二', '三', '四', '五', '六'],
            dateFormat: 'yy-mm-dd',
            beforeShow: function () {
                setTimeout(
                    function () {
                        $('#ui-datepicker-div').css("z-index", 15);
                    }, 100
                );
            }
        });

关键就在于beforeShow的使用上，大家一看就明白，这里就不多说了，希望能给您带来帮助。

本文链接

如何将按钮点击后禁用

2010-08-26T13:35:00Z

有时候为了不让用户连续的点击某按钮，我们会选择将其在点击后禁用。

一、让按钮在点击后用脚本使其禁用：
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="DisableButton.WebForm1" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
<script type="text/javascript" src="Scripts/jquery-1.4.1.min.js"></script>
<script type="text/javascript">
function enableButton(flag) {
$("#btnTest").attr("disabled", flag? "" : "disabled");
}
$(document).ready(
function () {
$("#btnTest").click(
function () {
enableButton( false );//点击后禁用
}
);
}
);
</script>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Button ID="btnTest" Text="点击后禁用" runat="server" OnClick="Test" />
</div>
</form>
</body>
</html>然而事实很遗憾的告诉我们这种方式行不通：页面根本不会回发。于是，我们不得不寻找其他方式。二、让回发的按钮退居二线: <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="DisableButton.WebForm1" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
<script type="text/javascript" src="Scripts/jquery-1.4.1.min.js"></script>
<script type="text/javascript">
function enableButton(flag) {
$("#btnTest").attr("disabled", flag? "" : "disabled");
}
$(document).ready(
function () {
$("#btnTest").click(
function () {
enableButton(false);
$("#btnTest2").click();//禁用掉自身并调用真正触发回发的按钮的click事件
}
);
}
);
</script>
</head>
<body>
<form id="form1" runat="server">
<div>
<input type="button" value="点击后禁用" id="btnTest" />
<asp:Button ID="btnTest2" Text="点击后禁用" runat="server" OnClick="Test" style="display:none"/>
</div>
</form>
</body>
</html>

这样一来我们的目的达到了。最后再介绍一种方式：三、利用setTimeout实现 <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="DisableButton.WebForm1" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
<script type="text/javascript" src="Scripts/jquery-1.4.1.min.js"></script>
<script type="text/javascript">
function enableButton(flag) {
$("#btnTest").attr("disabled", flag? "" : "disabled");
}
$(document).ready(
function () {
$("#btnTest").click(
function () {
setTimeout(function () {
enableButton(false);
},
50);
}
);
}
);
</script>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Button ID="btnTest" Text="点击后禁用" runat="server" OnClick="Test"/>
</div>
</form>
</body>
</html>

这样不用引入辅助控件我们也实现了需求。

注：为了更好的观察试验效果，可以在按钮的Click时间处理函数中Sleep几秒。

本文链接

排序算法之快速排序

2010-08-25T15:10:00Z

   快速排序实现:
namespace QuickSort
{
class QuickSort
{
public static void Sort(int[] array)
{
DoSort(array,0, array.Length-1);
}
private static void DoSort( int[] array, int start, int end)
{
if( start < end)
{
int temp = Partition(array, start, end);

DoSort(array, start, temp-1);
DoSort(array, temp + 1, end);
}
}
private static int Partition(int[] array,int start, int end)
{
int index = start - 1;

for( var i=start; i< end; i++)
{
if( array[i] < array[end])
{
index++;
Swap(array, index, i);
}
}

Swap(array, index +1, end);

return index + 1;
}

private static void Swap(int[] array, int index1, int index2)
{
var temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}
}
}
以上即为快速排序的代码，这里有两个重要的方法：

Partition:该方法是以数组的某个元素为参考元素（轴元素或主元素），将数组划分成三个区域：

                  【<=参考元素】【参考元素】【>=参考元素】

2.   DoSort:该方法会调用Partition将数组分区，并在新产生的子数组上递归调用最终达到有序的目的。

上面给出的代码是以数组最后一个元素作为参考元素，这仅是参考元素选取的方式之一。我们也可以随即选取数组的元素或者数组中间的元素作为参考元素。事实上参考元素的选取对快速排序的性能有很大影响。如果每次选取的参考元素能将数组分成相对均衡的区域，快速排序将成为最快的排序算法；但在另一种极端情形下，每次分成的数组都是1和n-1的关系，快速排序又会变的很慢。具体的性能数据后面再来讨论研究。

参考书籍：算法导论

本文链接

Advanced .Net Remoting读书笔记(1)—Introduction to Remoting

2010-08-17T14:44:00Z

Remoting是什么？

简言之,remoting就是程序或组件跨越特定边界进行交互的过程。这里的边界一般指计算机与计算机之间，进程与进程之间。在.Net下应该还要包括应用程序域与应用程序域之间。

Remoting的实现大致分两种形式：remote objects and mobile objects。

remote objects ：每次只会有一个对象的引用被发送至客户端，在这个引用上调用方法最终会被传送回服务器一端的真实对象并在该对象上执行。

mobile objects：这种对象会被序列化并跨越边界真实的被发送到客户端。当在客户端调用方法时，并不会想remote objects那样被传回服务器端，方法会在客户端立即执行。亦即客户端会拥有服务器端对象的一份拷贝，此拷贝与服务器端对象没有分别。

.Net Remoting的使用场景

让业务逻辑更集中：将业务逻辑放到几台核心的服务器上，其他服务器或应用程序通过remoting的方式访问这些业务逻辑。当业务逻辑发生变化时，就只需更新几台核心服务器。如果不这样做，就必须将程序分发到很多太终端上去。
层与层之间的物理分隔
访问其他平台的应用

Remoting的演化

主要的remoting frameworks：DCE/RPC,CORBA,DCOM,MTS/COM+,Java RMI,Java EJB,Web Services/SOAP/XML-RPC,.NET Remoting。

参考书籍:《Advanced .Net Remoting》

本文链接

排序算法之堆排序

2010-08-15T13:05:00Z

一、基本概念

堆：这里是指一种数据结构，而不是我们在C#中提到的用于存储引用类型对象的地方。它可以被当成一棵完全二叉树。

    为了将堆用数组来存放，这里对每个节点标上顺序。事实上，我们可以用简单的计算公式得出父节点，左孩子，右孩子的索引：
    parent(i) =
    left(i) = 2i
    right(i)=2i + 1

最大堆和最小堆: 最大堆是指所有父节点的值都大于其孩子节点的堆，即满足以下公式：
                      A[parent[i]]A[i](A是指存放该堆的数组)
    最小堆相反。
    最大堆和最小堆是堆排序的关键，可知最大堆的根节点是堆中最大的节点。因此只要我们构造出最大(小)堆，最大(小)的元素也就得到了，然后再对剩下的元素继续构造最大(小)堆，就可以取出第二大(小)的元素，依此类推，直到排序完成。

二、构造最大(小)堆

我们已经得知构造最大(小)堆是堆排序的关键，下面就来看看如何构造最大堆。

    万事开头难，首先来看一种特殊的情形吧：堆的根节点的左子树和右子树都已经是最大堆了，然而根节点却比孩子节点小，当然，这个堆不满足最大堆的定义。为了⑩这个堆成为最大堆，我们可以按如下步骤操作：
    （1）将根节点与左右孩子中最大的交换
    （2）交换之后可能会面临左或右子树不是最大堆的问题，但由于整个左(右)子树一开始就是最大堆，问题又回到了最开始的状态，因此只要如此反复即可得到最大堆。
    对于上面的特殊堆已经找到了解决办法，但对于一般意义上的堆呢？
    我们可以选择自底向上来构造：叶子节点是特殊的最大堆，举个例子有叶子节点a,b,它们的父节点是p;a,b肯定已经是最大堆了，这是要保证a,b,p组成的子树是最大堆。这个堆很眼熟是不是？没错，它就是前面提到的特殊的堆。在a,b,p组成的子树变成最大堆后，我们又可以类似的使该子树，该子树的父节点，以及同胞子树（或节点）组成的新子树成为最大堆，如此类推，最终使堆变为最大堆。

    对于求解最小堆与此类似。

三、实现

完整代码:

namespace HeapSort
{
using System;
class Program
{
static int heapSize =0;
static void Main(string[] args)
{
var heap = new[] { -1, 10, 5, 12, 77, 54, 7, 34, 23, 11 };//为了方便，索引0处不存放元素（或存放无用元素）
heapSize = heap.Length - 1;
BuildMaxHeap(heap);
for (var i = heap.Length - 1; i >= 2; i--)
{
//1.每次在构建好最大堆后，将第一个元素和最后一个元素交换；
//2.第一次以索引1到length-1出的元素组成新的堆，第二次1到length-2，直到剩下最后两个元素组成堆
//3.每次新组成的堆除了根节点其他节点都能保持最大堆的特性，因此只要DoBuildMaxHeap(heap, 1)就可以得到新的最大堆
Swap(heap, 1, i);
heapSize--;
MaxHeapfy(heap, 1);
}
foreach (var i in heap)
Console.Write(i + " ");
}
static void BuildMaxHeap(int[] heap)
{
for (var i = (heap.Length - 1) / 2; i >= 1; i--)
{
MaxHeapfy(heap, i);
}
}
static void MaxHeapfy(int[] heap, int index)
{
var largerItemIndex = index;
var leftChildIndex = index << 1;
var rightChildIndex = (index<<1) + 1;
if (leftChildIndex <= heapSize && heap[leftChildIndex] > heap[index])
{
largerItemIndex = leftChildIndex;
}
if (rightChildIndex <= heapSize && heap[rightChildIndex] > heap[largerItemIndex])
{
largerItemIndex = rightChildIndex;
}
if( index != largerItemIndex)
{
Swap(heap, index, largerItemIndex);
MaxHeapfy(heap, largerItemIndex);
}
}
static void Swap(int[] heap, int index1, int index2)
{
var temp = heap[index1];
heap[index1] = heap[index2];
heap[index2] = temp;
}
}
}

1.MaxHeapfy:该方法的前提是index处节点的左右子树已经是最大堆，最终的目的是使以index处节点为根的堆成为最大堆

2.BuildMaxHeap：该方法涉及一个事实：如果一个对含n个元素，那么从开始的元素（假设节点下表从1开始）就一定是叶子节点（这一点可以用反证法证明，假设处节点不是叶子节点，那么该节点必包含子节点，从而可以得出其左孩子的索引2 *() > n的结论，显然这是错误的）。在这个前提下，该方法至底向上通过MaxHeapfy将堆构建成最大堆。

参考资料：算法导论

本文链接

dynamic和匿名类型结合

2010-08-11T13:29:00Z

经常使用js的朋友会发现，我们经常需要返回一些‘临时’的类型的实例。举个例子，当我们在定位一个元素时，我们的方法的结束处可能会是这样：

function getOffset(obj)
{
    ...
    var offset = new object();
    offset.top = top;
    offset.left = left;

    return offset;
}

得益于js的动态特性，我们不用再去定义一个包含top和left属性的类型。然而在C#中，我们却不得不去定义这样一个类型，尽管这个类型可能就使用那么一次。

不过，在C# 4.0里，ms为我们引入了dynamic，这决定了我们可以如同使用js一般来使用C#。

比如上面这个问题，我们可以使用dynamic和匿名类型来实现:

private dynamic GetOffset()
{
    ...
    dynamic offset= new{Top = top, Left=left};
    return offste;
}

这样一来是不是方便了不少？

当然，dynamic引入的问题就是如果使用了dynamic类型不包含的属性在编译时并不会被发现，而在运行时则会以异常的形式表现出来。这也是让我觉得在使用时畏首畏尾的缘由。不过，个人认为C#不适宜过多的采用动态语言的编程方式。而一旦用了则一定要做好注释，比如上面的方法只要对返回值多详细的说明我相信就不会出现被人无用的情形。

本文链接