博客园_空逸云

计算一个数字有多少种排列可能

2012-02-03T01:14:00Z

现有一数字，例如12345，问这个数字有多少种排列可能，最简单的就是位数的阶乘，5位数字等于5*4*3*2*1=120,这是理论上没有重复数字的情况下，如果现在是11234，11123，11112，11223有重复数字组成的数字怎么计算呢？

若一个数字由所有不相同的数字组成，则该数字的排列可能是该数组位数的阶乘，若该数字中存在重复的数字，例如，有m个1相同，结果就是n! / m!,n值是数字的位数，如果还存在p个相同的数字，那结果就是n! / m! /p!

根据上面的算法，上面的数字计算如下：

11234=5！ / 2！=60

11123=5! / 3!=20

11112=5! / 4! = 4

11223=5! / 2! / 2! = 30

附上C#实现

public class MathHelper
{
/// <summary>
/// 输入一个数字，算出该数值有多少种排列可能.
/// </summary>
/// <param name="num">The num.</param>
/// <returns></returns>
public static long CountPermutation(long num)
{
string number = num.ToString();
IDictionary<char, int> rptNum = new Dictionary<char, int>();
foreach (char ch in number)
{
if (rptNum.Keys.Where(it => it == ch).Count() > 0)
rptNum[ch] += 1;
else
rptNum.Add(ch, 1);
}
long totalFac = Factorial(number.Length);
foreach (var item in rptNum.Where(it => it.Value > 1))
{
totalFac /= Factorial(item.Value);
}
return totalFac;
}
/// <summary>
/// 计算阶乘.
/// </summary>
/// <param name="num">The num.</param>
/// <returns></returns>
public static long Factorial(int num)
{
if (num == 1) return num;
return num * Factorial(--num);
}
}

输出数字的全排列

上面计算出了一个数字有多少种排列可能，下面就要分别列出这些排列结果！网上已经有了很多的算法，最基础的还是迭代循环，但数字一大效率是一个问题，另外一点就是无法去除重复数字，例如计算1123，1122这样数字的全排列结果的时候，本人数学不太好，索性，在博客园找到一个同学的实现：
一组数字的全排列按序输出
 再议“生成全排列算法”

通过第一个同学的思路和实现，完成了一个C#版本，对于低数位的数字来说效率还是挺不错的，性能方面的测试我就先偷个懒，目前先应用上就行，毕竟目前这个实现已经满足我的需求了，呵呵！

C#实现

/// <summary>
/// 全排列算法类
/// </summary>
public class FullArrangementHelper
{
private int _length;
public IList<long> Result { get; private set; }

public FullArrangementHelper()
{
Result = new List<long>();
}

public IList<long> GetFullArrangement(long num)
{
string numStr = num.ToString();
int[] nums = new int[numStr.Length];
for (int i = 0; i < numStr.Length; i++)
nums[i] = int.Parse(numStr[i].ToString());
_length = nums.Length;

nums = nums.OrderBy(it => it).ToArray<int>();//排序
FullArrangement(nums, 0);
return Result;
}

/// <summary>
/// 计算全排列算法
/// </summary>
/// <param name="nums">要计算全排列的数字.</param>
/// <param name="pos">开始计算排列的位置，例如，现在的数字是1234，如果pos为0，就代表计算这四位的全排列，1的下标为0，
/// 如果为1，则计算后3位的全排列，依次下推.</param>
private void FullArrangement(int[] nums, int pos)
{
//将现在的数字添加到结果中
Result.Add(ConvertToNum(nums));

//最大是数字的长度-2是因为按照下标计算，此处pos-1是因为后续的步骤中需要+1来对相邻的两个数字做比较
for (int i = _length - 2; i > pos - 1; i--)
NextArrangement(nums, i);
}

/// <summary>
/// 计算下一轮全排列
/// </summary>
/// <param name="nums">数字的分解数组.</param>
/// <param name="pos">开始计算排列的位置.</param>
private void NextArrangement(int[] nums, int pos)
{
int[] cop = new int[_length];
//根据下标依次计算数字的全排列，实际就是大排列都由小排列一步步扩大
for (int i = pos + 1; i < _length; i++)
if (nums[i] > nums[pos] && nums[i] != nums[i - 1])
{
for (int t = 0; t < _length; t++)
cop[t] = nums[t];
//交换数字位
for (int j = i; j > pos; j--)
{
int temp = cop[j];
cop[j] = cop[j - 1];
cop[j - 1] = temp;
}
FullArrangement(cop, pos + 1);
}
}

private long ConvertToNum(int[] nums)
{
StringBuilder sb = new StringBuilder();
foreach (var n in nums)
sb.Append(n);
return long.Parse(sb.ToString());
}
}

本文链接

跟我做WinForm开发（2）-后台逻辑操作

2012-01-08T04:32:00Z

上一篇中，我简单了介绍了实现自定义UI的步骤和其中一些需要注意的点；详见：跟我做WinForm开发（1）-自定义UI，下面，我就继续完成上篇没完成的逻辑操作；

获取声音

这是一个发音器，声音的来源是Google，打开Google翻译,输入一段英文，并点击发音，Google很快就读取了我所输入的句子，打开HttpWatch，发现，实际上每次发音，都会把输入的句子做一次UrlEncode，然后发往Google服务器，最后返回一个Mp3的流；这个URL如下http://translate.google.cn/translate_tts?ie=UTF-8&q=hello%20world%2C2012&tl=en&prev=input；从上面我们应该可以看到去参数就是你要发音的内容，而tl就是该语言的简写；那么我们需要做的，就是修改q获得我们想要的MP3流；PS：在后面的尝试当中，我发现Google做了限制，只允许长度为100；超出100则无返回结果，这个100是Length；而不是所占字节长度，所以，中文在这里更占优势；

好了；既然目标已确定，那就开始吧；那有什么办法能让我拿到这个MP3流呢？答案不言而喻，就是HttpWebRequest；在这里，我新建了一个叫HttpHelper的类，它主要用于做简单的Http Get请求；

internal static class HttpHelper
{
/// <summary>
/// 发起请求，用于GET.
/// </summary>
/// <param name="url">The URL.</param>
internal static void SendRequest(string url, WebRequestCallBack callBack)
{
Log.Info("Send Request");
try
{
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
request.KeepAlive = false;
request.Method = "GET";
CallbackParam cp = new CallbackParam
{
Request = request,
CallBack = callBack
};
Log.Info("Begin get Responsen.");
request.BeginGetResponse(BeginGetResponse, cp);
}
catch (Exception ex)
{
Log.Info("Error:" + ex.Message);
callBack(null, HttpStatusCode.Continue, WebExceptionStatus.UnknownError, ex);
}
}

static void BeginGetResponse(IAsyncResult ar)
{
Log.Info("Get Response");
CallbackParam cp = ar.AsyncState as CallbackParam;
try
{
using (HttpWebResponse response = (HttpWebResponse)cp.Request.EndGetResponse(ar))
{
using (var responseStream = response.GetResponseStream())
{
MemoryStream ms = new MemoryStream();
byte[] buffer = new byte[1024];
int byteReader;
do
{
byteReader = responseStream.Read(buffer, 0, buffer.Length);
ms.Write(buffer, 0, byteReader);
}
while (byteReader > 0);

ms.Flush();
cp.CallBack(ms, response.StatusCode, WebExceptionStatus.Success, null);
}
}
}
catch (WebException ex)
{
Log.Info("Error:" + ex.Message);
HttpWebResponse response = (HttpWebResponse)ex.Response;
cp.CallBack(null, response.StatusCode, ex.Status, ex);
}
catch (Exception ex)
{
Log.Info("Error:" + ex.Message);
cp.CallBack(null, HttpStatusCode.Continue, WebExceptionStatus.UnknownError, ex);
}
}
}

从上面的代码看到，首先，我创建了一个HttpWebRequest对象，并将其请求方法设置为GET；随后，开始了异步请求；当获取到

服务器响应的时候，便将相应流读出来，发送给回调方法，这里为什么要用异步？一个是避免主线程阻塞，导致UI挂起；另外就是这面编码看起来更有Feel吧! :-)~~

现在就可以直接获取MP3流了吧！等等；还不行！应为我们还没讲输入的字符串UrlEncode，那怎么办？写呗！

public class SpeakTextHandler
{

public static string GetSpeakerUrl(string sourceText)
{
var config = ConfigManger.GetConfig();
return string.Format(config.SpeakerUrl, GetEncodeText(sourceText), GetTextLanguage(config, sourceText));
}

private static string GetEncodeText(string source)
{
if (string.IsNullOrEmpty(source)) return string.Empty;
return HttpUtility.UrlPathEncode(source);
}

private static string GetTextLanguage(Config config, string source)
{

foreach (var language in config.Languages)
{
if (Regex.Match(source, language.Unicode).Success)
return language.Name;
}
return config.DefaultLanguage.Name;
}
}

这里我创建了一个SpeakerTextHandler的类，它主要工作就是将传入的字符串UrlEncode，并获取配置，拼接出相应的Url；到这

里，获取声音就大功告成了！

播放声音

拿到声音之后需要做什么？必然就是将其播放出来；由于没弄过这方面的东西（平时都是些Asp.net）；好吧，就Google吧；网上给出了好几个解决方案；

A:使用SoundPlayer;这个很明显就不行，有使用经验的童鞋应该知道，SoundPlayer只支持wav格式的播放，虽然它能支持传入Stream流参数，但若是传入MP3流，还是报异常；

B：WindowsMediaPlay;但是这个必须是读取文件；先不说是否支持MP3，单单是每次都需要先把流存储到本地再读取；我这懒人就无法忍受了；

C：利用DX库来操作；这个淡淡看解决方案就很复杂；虽然可控性可能比较强；但这复杂度。。懒人望而生畏！:-(

难道就没其他解决方案了吗？几经波折，终于在StackOverflow中找到了一个可行方案；

Play Audio from a Stream using C#

其中使用的是一个叫NAudio的开源组件，那么，它的确是可以解决我现在的窘境；照着StackOverflow上的代码来写，的确是可以播放出软件了，但是随后关闭软件的时候，都会出现一个错误的断言，跟踪NAudio的实现，发现是流没释放；囧；最终几次尝试；终于把这个错误断言去掉了；

if (stream != null && ex == null)
{
stream.Position = 0;
var mp3Reader = new Mp3FileReader(stream);
var pcmStream = WaveFormatConversionStream.CreatePcmStream(mp3Reader);
using (WaveStream blockAlignedStream = new BlockAlignReductionStream(pcmStream))
{
using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
waveOut.Init(blockAlignedStream);
waveOut.PlaybackStopped += (sender, e) =>
{
waveOut.Stop();
};
waveOut.Play();
while (waveOut.PlaybackState == PlaybackState.Playing)
{
System.Threading.Thread.Sleep(100);
}
waveOut.Dispose();
}
}

该实现在HttpHelper的回调当中（更多代码请看后面放出的下载）；

快捷键支持

除了仅仅能发音，那还需要支持快捷键放大/缩小；或者是快捷键发音等；那还等什么？Come On！实际上，对这方面有经验的同学应该就能很自然的想到利用的就是“钩子”，当然，这个钩子的概念和我们平时编写代码时所使用的钩子这个概念有所区别，例如，Asp.net中控件/Page中有很多事件，OnLoad，OnCompleted等等。我们写代码的时候也可能会写一些空实现，让子类来做实现；这就是编程概念上的“钩子”，而这里的“钩子”，是指在触发系统一些事件的时候，也把我们所依附上的方法也执行了；其中的实现主要还是依靠与Win32API；

public delegate void HotkeyEventHandler(int hotKeyID);
public class Hotkey : System.Windows.Forms.IMessageFilter
{
Hashtable keyIDs = new Hashtable();
IntPtr hWnd;

public event HotkeyEventHandler OnHotkey;

[DllImport("user32.dll")]
public static extern UInt32 RegisterHotKey(IntPtr hWnd, UInt32 id, UInt32 fsModifiers, UInt32 vk);

[DllImport("user32.dll")]
public static extern UInt32 UnregisterHotKey(IntPtr hWnd, UInt32 id);

[DllImport("kernel32.dll")]
public static extern UInt32 GlobalAddAtom(String lpString);

[DllImport("kernel32.dll")]
public static extern UInt32 GlobalDeleteAtom(UInt32 nAtom);

public Hotkey(IntPtr hWnd)
{
this.hWnd = hWnd;
Application.AddMessageFilter(this);
}

public int RegisterHotkey(Keys Key, KeyFlags keyflags)
{
UInt32 hotkeyid = GlobalAddAtom(System.Guid.NewGuid().ToString());
RegisterHotKey((IntPtr)hWnd, hotkeyid, (UInt32)keyflags, (UInt32)Key);
keyIDs.Add(hotkeyid, hotkeyid);
return (int)hotkeyid;
}

public void UnregisterHotkeys()
{
Application.RemoveMessageFilter(this);
foreach (UInt32 key in keyIDs.Values)
{
UnregisterHotKey(hWnd, key);
GlobalDeleteAtom(key);
}
}

public bool PreFilterMessage(ref System.Windows.Forms.Message m)
{
if (m.Msg == 0x312)
{
if (OnHotkey != null)
{
foreach (UInt32 key in keyIDs.Values)
{
if ((UInt32)m.WParam == key)
{
OnHotkey((int)m.WParam);
return true;
}
}
}
}
return false;
}
}

[Flags]
public enum KeyFlags
{
Alt = 0x1,
Ctrl = 0x2,
Shift = 0x4,
Win = 0x8
}

调用方法很简单；

Hotkey hotkey = new Hotkey(handle);
int speakHotkey = hotkey.RegisterHotkey(System.Windows.Forms.Keys.Q, KeyFlags.Ctrl);
hotkey.OnHotkey += new HotkeyEventHandler(it =>
{
if (it == speakHotkey)
{
SendCtrlC(Win32.GetForegroundWindow());
Thread.Sleep(500);
Speaker.Speak(Clipboard.GetText());
}
});

屏幕取词

相信大部分同学都有使用过翻译软件，其中的屏幕取词不可谓不是一大杀器，如果你想翻译一个单词都必须要先复制，然后在打开翻译软件，粘贴，这样的话效率未免也太低了，对于用户体验也不好；于是，我便想着自己实现这方面的功能；Google许久，得出主要的实现方式如下：

[讨论]关于C#屏幕取词的技术实现
 200分求[C#屏幕取词]
屏幕取词技术实现原理与关键源码
 如何获取鼠标选中文本内容，请赐教
 C# 如何获取鼠标选中文本内容

其中可行的方法就是利用金山词霸的dll，可惜，最终尝试都失败了！不过，其中单选记事本，编辑器中的文字成功，但浏览器/其他软件读词失败；看来，屏幕取词，不涉及到底层，单单用C#来实现还是很有难度；那我就换个思路吧，也只能通过选中文字，按下快捷键，先复制到剪贴板中，再将其读取出来；经过几番努力，最后可行方案如下：

public class HotKeyManager
{
public static void RegistSelectedSectionHotKey(IntPtr handle)
{
Hotkey hotkey = new Hotkey(handle);
int speakHotkey = hotkey.RegisterHotkey(System.Windows.Forms.Keys.Q, KeyFlags.Ctrl);
hotkey.OnHotkey += new HotkeyEventHandler(it =>
{
if (it == speakHotkey)
{
SendCtrlC(Win32.GetForegroundWindow());
Thread.Sleep(500);
Speaker.Speak(Clipboard.GetText());
}
});
}

private static void SendCtrlC(IntPtr hWnd)
{
Win32.SetForegroundWindow(hWnd);
Win32.keybd_event(0x11, 0, 0, 0);
Win32.keybd_event(67, 0, 0, 0);
Win32.keybd_event(0x11, 0, 2, 0);
Win32.keybd_event(67, 0, 2, 0);
}
}

我新建了一个HotKeyManager的类，里面的RegistSelectedSectionHotKey方法注册了热键，事件先通过

Win32API发送复制指令，线程阻塞500毫秒（将文字复制到剪贴板中需要一定的延迟时间）；然后获取剪切板的文字就大功告成了！

尾声

项目虽小，却多有趣味；其中更是应用到了一些我从来没接触过的东西；也学到了不少东西；故写下备忘；也给需要这方面资料的童鞋一个帮助；总是如此，写下来时总觉无什么可写；但其中的收获和感言却不少；只有亲自动手才能有所收获；以后还需多多写！多多益善～～

源码下载：Speaker.rar

本文链接

跟我做WinForm开发（1）-自定义UI

2012-01-07T04:03:00Z

前言

前阵子，学英文的时候听发音，意外之中发现Google的发音相比大部分TTS发音更准确，而且读句子也没有普通TTS那种一听就是机器人的声音，心血来潮，想利用Google发音做一个小软件，所以就有了本文。

这是最后的UI成品图，可以看到，没有了常见的按钮，也没有了常见的Title框，整个布局随心所欲，GDI+？No。下面，就带大家跟我一起来用最简单的方式开发你所期望的UI吧！

自定义窗体

WinForm开发中，我们都知道窗体和控件的作用，实际上，以上的UI实现也是通过自定义窗体和用户控件实现，那该如何做，才能让窗体变成我们所想要的样子呢？

首先，新建一个窗体，在这里，我命名为MainForm.cs，打开我们就可以见到以往的样子：

选中窗体，右键=》属性，将FormBorderStyle设置成None，窗体就变成了右图所示；接着，我再将其拖拉成我需要的长度和宽度，此时若编译运行，会发现实际上什么都东西都看不到，这正是我们所需要的效果，接着，就防止我们想呈现的元素。接着，我将其拉成一个长方形，并在四周放4个PictureBox，正中间放一个Panel。

这里需要注意的就是4个PictureBox的宽度，长度和未知，实际上我也不是拖控件，而是通过修改控件是属性，这里就需要精确到像素，聪明的你应该想到它们就是4条边框线和中间的内容块了，在这里我推荐一个软件，MarkMan，传说中的标注神器，做UI方面，特别是开发人员，很有帮助。

在将所需的图片填充上去就可以了。

private Image GetResourceImg(string name)
{
return Image.FromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(name));
}
void InitFormStyle()
{
//边框
var borderImg = GetResourceImg(@"Speaker.Resource.Images.border.jpg");
Bitmap borderMap = new Bitmap(borderImg);
borderMap.MakeTransparent(Color.FromArgb(255, 0, 255));
this.pb_borderLeft.BackgroundImage = borderMap;
this.pb_borderRight.BackgroundImage = borderMap;
this.pb_borderTop.BackgroundImage = borderMap;
this.pb_borderBottom.BackgroundImage = borderMap;
//主面板
var mainImg = GetResourceImg(@"Speaker.Resource.Images.main.jpg");
this.pl_main.BackgroundImage = new Bitmap(mainImg);
//Logo
var logoImg = GetResourceImg(@"Speaker.Resource.Images.logo.jpg");
this.btn_setting.NormalImage = new Bitmap(logoImg);
btn_setting.Reset();
//Speak Button
var normalImg = GetResourceImg(@"Speaker.Resource.Images.button.png");
var moveImg = GetResourceImg(@"Speaker.Resource.Images.buttonMove.png");
var downImg = GetResourceImg(@"Speaker.Resource.Images.buttonDown.png");
btn_speak.NormalImage = normalImg;
btn_speak.MoveImage = moveImg;
btn_speak.DownImage = downImg;
btn_speak.Reset();
}

编译通过之后，边框雏形就出现了～:-)

自定义控件

窗体我们已经有了，接下来就是里面一些控件的实现，这里，我主要用到了两个控件，ImageButton和LightTextBox，顾名思义，ImageButton就是一个图片按钮，但它还提供鼠标按下，悬移时的图片选择；LightTextBox是一个TextBox，鼠标悬移的时候，边框高亮；

LightTextBox

新建用户控件LightTextBox，选中控件，右键=》属性，将BorderStyle改为None，这样，控件也不可见了！拖出一个TextBox，并标注为MultiLine,至此，UI就这样了，接着是控件的绘制编码；

public LightTextBox()
{
SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
InitializeComponent();
BackColor = Color.Transparent;

txt.Location = new Point(3, 6);
txt.MouseEnter += new EventHandler(txt_MouseEnter);
txt.MouseLeave += new EventHandler(txt_MouseLeave);
}

实现TextBox的鼠标悬移事件就是为了实现边框高亮效果；

#region Events

void txt_MouseLeave(object sender, EventArgs e)
{
_isFouse = false;
this.Invalidate();
}

void txt_MouseEnter(object sender, EventArgs e)
{
_isFouse = true;
this.Invalidate();
}
#endregion

方法部分（控件实现的主要方法）

#region Methods
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
g.SmoothingMode = SmoothingMode.HighQuality;

txt.Width = Width-6;
CalculateSizeAndPosition();
Draw(e.ClipRectangle, e.Graphics);

base.OnPaint(e);
}

private void CalculateSizeAndPosition()
{
if (!txt.Multiline)
{
Height = txt.Height + 9;
}
else
{
txt.Height = Height - 9;
}
}
private void Draw(Rectangle rectangle, Graphics g)
{

#region 画背景
using (SolidBrush backgroundBrush = new SolidBrush(Color.White))
{
g.FillRectangle(backgroundBrush, 2, 2, this.Width - 4, this.Height - 4);
}
#endregion

#region 画阴影(外边框)

Color drawShadowColor = _shadowColor;
if (!_isFouse) //判断是否获得焦点
{
drawShadowColor = Color.Transparent;
}
using (Pen shadowPen = new Pen(drawShadowColor))
{
if (_radius == 0)
{
g.DrawRectangle(shadowPen, new Rectangle(rectangle.X, rectangle.Y, rectangle.Width - 1, rectangle.Height - 1));
}
else
{
g.DrawPath(shadowPen, DrawHelper.DrawRoundRect(rectangle.X, rectangle.Y, rectangle.Width - 2, rectangle.Height - 1, _radius));
}
}
#endregion

#region 画边框
using (Pen borderPen = new Pen(_borderColor))
{
if (_radius == 0)
{
g.DrawRectangle(borderPen, new Rectangle(rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 3, rectangle.Height - 3));
}
else
{
g.DrawPath(borderPen, DrawHelper.DrawRoundRect(rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 3, rectangle.Height - 2, _radius));
}
}
#endregion
}

#endregion

由于字段，属性比较多，我就不贴出来了，感兴趣的可以在后续的源码中查看；此时，若将该控件放到窗体中，鼠标移

动上去，则可发现边框有一层光晕；

ImageButton

这里的自定义控件实现方式一致，都先去掉了BorderStyle，再自己控制呈现内容，所以才能达到显示特殊UI的目的；ImageButton的UI设计就不详述了，直接放出后台实现主代码；

public ImageButton()
{
this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer, true);
InitializeComponent();
Reset();
}

#region Methods
public void Reset()
{
if (_normalImage != null)
{
this.BackgroundImage = _normalImage;
this.Size = new Size(_normalImage.Width, _normalImage.Height);
}
}
private void MakeTransparent(Image image)
{
Bitmap bitmap = image as Bitmap;
bitmap.MakeTransparent(Color.FromArgb(255, 0, 255));
}
#endregion

private void ImageButton_MouseEnter(object sender, EventArgs e)
{
if (_moveImage != null)
this.BackgroundImage = _moveImage;
}

private void ImageButton_MouseLeave(object sender, EventArgs e)
{
this.BackgroundImage = _normalImage;
}

private void ImageButton_MouseDown(object sender, MouseEventArgs e)
{
if (_downImage != null)
this.BackgroundImage = _downImage;
}

private void ImageButton_MouseUp(object sender, MouseEventArgs e)
{
if (_moveImage != null)
this.BackgroundImage = _moveImage;
}

MainForm

万事俱备，只欠东风；把控件都放入MainForm中，并初始其状态即可（上面第一部分代码已放出）；此时，编译运行；已达到我们预期的UI效果；但是，UI效果是有了，移动效果，缩小（点击任务栏图标）等却都失效了，该怎么办？Win32API千呼万唤使出来～

private void pl_main_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
Win32.ReleaseCapture();
Win32.SendMessage(Handle, 274, 61440 + 9, 0);
}
}

这里实际上是调用了Win32API，在这里，又有一个好东西分享；平时做这些Win32API交互/C#与C++交互，需

要做类型转换，特别是C++里面一些指针什么的，很是纠结，http://clrinterop.codeplex.com能帮到你；它能根据你输入的C++函数生成C#的代码；不可谓不是一大杀器啊！

移动解决了，那缩小的问题，也必须解决了；

protected override CreateParams CreateParams
{
get
{
const int WS_MINIMIZEBOX = 0x00020000; // Winuser.h中定义
CreateParams cp = base.CreateParams;
cp.Style = cp.Style | WS_MINIMIZEBOX; // 允许最小化操作
return cp;
}
}

重写CreateParams属性就可以了；到这里，我们的应用已经能正常显示出我们所想要的UI；但还不够，大部

分辅助类型的软件都有最小化的功能，那，我们也将其加上去吧；

NotifyIcon

这个其实很简单，就是拖一个NotifyIcon到窗体中，并绑定一个ContextMenu到这个NotifyIcon中就可以了；然后在触发一些事件；

private void MainForm_Resize(object sender, EventArgs e)
{
if (WindowState == FormWindowState.Minimized)
{
this.Visible = false;
}
}

后面，我还主要用NotifyIcon来通知用户，做提示，错误提示等；到这里，整个UI方面就已经完成了；只

剩下后面的逻辑处理，就是输入句子能发音，并且支持快捷键屏幕取词等；

更多资料

跟我学做c#皮肤美化

WinAPI使用大全

跟我做WinForm开发（2）-后台逻辑操作

本文链接

删除项目文件/文件夹IIS重启，Session丢失问题

2011-12-08T09:53:00Z

最近在做一个项目，涉及到大量文件中转（先上传到本项目的某个文件夹中，在移动到FTP中），后面发现每次一删除文件之后在做操作都会提示未登录，刚开始以为是WebService Session丢失问题，后面发现缓存也更新了。仔细一看，SSO返回的ticket也不相同，才发现原来IIS重启了，最后解决方案如下：

新建一个类继承IHttpModule

/// <summary>
/// Stops the ASP.NET AppDomain being restarted (which clears
/// Session state, Cache etc.) whenever a folder is deleted.
/// </summary>
public class StopAppDomainRestartOnFolderDeleteModule : IHttpModule
{
private static bool DisableFCNs = false;
public void Init(HttpApplication context)
{
if (DisableFCNs) return;
PropertyInfo p = typeof(HttpRuntime).GetProperty("FileChangesMonitor", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
object o = p.GetValue(null, null);
FieldInfo f = o.GetType().GetField("_dirMonSubdirs", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.IgnoreCase);
object monitor = f.GetValue(o);
MethodInfo m = monitor.GetType().GetMethod("StopMonitoring", BindingFlags.Instance | BindingFlags.NonPublic);
m.Invoke(monitor, new object[] { });
DisableFCNs = true;
}
public void Dispose() { }
}

随后在Web.Config中加入Module配置

<add name="stopAppDomainRestartOnFolderDelete" type="DeployAssistant.Facade.Web.StopAppDomainRestartOnFolderDeleteModule,DeployAssistant.Facade"/>

这样每次再删除文件/文件夹AppDomain都不会重启了，Session也不会丢失了。世界也变得更美好了！

PS：Web.Config和bin文件夹下的改动依然会让Web重启，这也是必须保留的！

本文链接

细说文件读写操作（读写锁）

2011-11-14T16:20:00Z

开发过程中，我们玩玩需要大量与文件交互，读文件，写文件已成家常便饭，本地运行完美，但一上到投产环境，往往会出现很多令人措手不及的意外，或开发中的烦恼，因此，我对普通的C#文件操作做了一次总结，问题大部分如下：

1：写入一些内容到某个文件中，在另一个进程/线程/后续操作中要读取文件内容的时候报异常，提示 System.IO.IOException: 文件“XXX”正由另一进程使用，因此该进程无法访问此文件。

2：在对一个文件进行一些操作后（读/写），随后想追加依然报System.IO.IOException: 文件“XXX”正由另一进程使用，因此该进程无法访问此文件。次问题与1相似。

3：对一个文件进行一些操作后，想删除文件，依然报System.IO.IOException: 文件“XXX”正由另一进程使用，因此该进程无法访问此文件。

看到这些，有经验的同学应该就会说资源没被释放掉，但也存在如下可能性。我们对文件的操作非常频繁，所以写了特定的操作类/组件来维护文件之间的操作，知道特定的时刻才结束，常见的如日志，随着程序的启动便开始写日志，直到程序关闭。但此中也存在我们需要提供一个特殊的操作（读/写/删除）来操作文件，例如我们需要提供一个日志查看器来查看当前日志或所有日志，这时，便无可避免的发生了以上的问题。

static void WriteFile(FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
{
Console.WriteLine("please input your content.");
var content = Console.ReadLine();
FileStream fs = new FileStream(FILEPATH, fileMode, fileAccess, fileShare);
var buffer = Encoding.Default.GetBytes(content);
fs.Write(buffer, 0, buffer.Length);
fs.Flush();
}

首先，我声明了一个写文件方法，并调用它，它将我输入的内容写入指定的文件当中。

WriteFile(FileMode.Create, FileAccess.Write, FileShare.Read);
Console.ReadKey();

但是，在写文件操作结束之后，我并没有释放掉文件流的资源。所以，此时会对文件造成一个锁。我尝试在windows中删除它。

很明显我无法删除掉这个文件，接下来，我尝试读取它。

static void ReadFile(FileAccess fileAccess, FileShare fileShare)
{
FileStream fs = new FileStream(FILEPATH, FileMode.Open, fileAccess, fileShare);
var buffer = new byte[fs.Length];
fs.Position = 0;
fs.Read(buffer, 0, buffer.Length);
Console.WriteLine(Encoding.Default.GetString(buffer));
}

我实现了一个读文件方法，并调用了它。

WriteFile(FileMode.Create, FileAccess.Write, FileShare.Read);
ReadFile(FileAccess.Read, FileShare.Read);

一切都很简单，访问模式为只读，这样应该就不会与上面的写锁进行冲突！

但是，结果并非我们所预想的那样，为什么会提示无法访问？回想一下，在前面，我用windows的记事本打开了这个文件，并没有提示说文件被锁定，我也的确能访问，那为何到了程序里就无法访问了呢？或许，我们应该把重点放在FileMode，FileAccess，FileShare这三个枚举身上，说不定就是它们搞的鬼。

FileMode

MSDN上的解释是指定操作系统打开文件的方式，我想这个应该不需要解释了，大家平时用得比较多了。MSDN的表格也很好的阐述了各个枚举值的作用，我就不在解释了。

FileAccess

定义用于文件读取、写入或读取/写入访问权限的常数。

这个枚举也用得比较多了，描述也很通俗易懂，我也不便再解释了。^_^!

FileShare

相信这个枚举类型大家会比较陌生，甚至有同学见都没见过（惭愧的是，我也是才认识它没多久），陌生归陌生，但它的作用力也是不可低估，只是.Net帮我们把它封装得比较好，以至于我们一度认为它不是什么重要角色。好吧，进入主题！

包含用于控制其他 FileStream 对象对同一文件可以具有的访问类型的常数。这句话是什么意思呢？说实话，我现在看句话还是觉得很纠结，相信很多同学看到也是一头雾水，没关系，我们先跳过！

看它的成员描述，和FileAccess很是相似，那我们就尝试着来揭开它暂时神秘的面纱吧！

FileShare.Read

从字面上的意思，我们可以理解为首先打开一个文件之后（资源未释放），我们可以再用只读的方式读取文件从而不会抛出文件无法访问的异常。利用刚才实现的方法，可以轻易的再完成这个实验：

WriteFile(FileMode.Create, FileAccess.Write, FileShare.Read);
ReadFile(FileAccess.Read, FileShare.Read);

这是什么回事？不是都设置成已读了吗？或许只能在读文件的时候才能设置为只读共享。我们再尝试一下：

ReadFile(FileAccess.Read, FileShare.Read);
ReadFile(FileAccess.Read, FileShare.Read);

这次的确是能在第一次没释放资源时再读，那我们再试试能否在设置只读共享后写文件：

ReadFile(FileAccess.Read, FileShare.Read);
WriteFile(FileMode.Create, FileAccess.Write, FileShare.Read);

首先正确的读出了文件的内容，但当我尝试写入一些内容的时候却又报错了。那么，根据以上的实验，就可以得知这个只读的共享只有是在连续读取文件才有效！

FileShare.Write

结合Read的经验，字面上的意思应该可以理解为，只有在写文件时设置共享方式为Write，随后才能继续写入文件，否则会抛出异常。这里比较好玩的时，设置Write之后，万能的Window记事本也打不开文件了。

FileShare.ReadWrite

有了以上的经验，从字面上理解，可以认为这个ReadWrite一定是结合了Read和Write的特性。那到底它有什么用呢？上面我们知道，在读文件设置Read共享能继续读而不能写，在写文件时设置Write共享则能继续写而不能读，但是当我们设置了写共享后并想读取文件时怎么办？只能先释放资源再重新加载了吗？不需要，ReadWrite就是为此而生的。

WriteFile(FileMode.Create, FileAccess.Write, FileShare.Read);
ReadFile(FileAccess.Read, FileShare.ReadWrite);

不过这里写文件的时候并不允许把共享设置成Write，否则读文件时用ReadWrite则无效（报异常），但都设置为ReadWrite可以。这一定，便可以解决很多日常开发中的烦恼。

FileShare.None/FileShare.Delete

有了上面的经验，相信这两个你也很容易的就理解了，None则为不允许后续有任何操作，而Delete则是允许你随后进行删除操作。

黑箱子里的内容

对于文件操作，我们平常使用的比较多的可能是以下几种：

File.AppendAllText("......");
File.AppendAllLines(...);
File.AppendText(...);
FileStream fs = new FileStream(path, FileAccess.Write);
fs.Write(....);

实际上它们也是在内部初始化了FileMode/FileAccess/FileShare，例如File的静态方法最后都会生成一

个Stream实例，其中便调用了私有方法

尾声

现在，我们明白了，其实/FileShare就是控制文件流的“访问权限”，当然，这仅仅是入门的文件操作，自己做了笔记，也希望能给大家带来帮助，高级篇园子里已经有不少前辈写了文件读写锁方面的文章，感兴趣的同学可有搜索一下，前去观摩！！

本文链接

您真的了解类型转换吗？请止步，解惑！

2011-08-28T16:11:00Z

不久前，因为对类型转换CLR的底层实现很朦胧，万不得已下，发了一篇博文请园里的各位同学，大大解惑。

您真的了解类型转换吗？请止步，求解！

很多热心的园友纷纷发表了自己的意见和见解，在各位童鞋的帮助下，逐渐理清了类型转换的内幕（也可能并不是很正确！），于是想再整理一次，欢迎大家指正，而且也延发了其他的问题，想与大家一起讨论。

类型转换的疑惑

在上个问题中，我声明了两个类，父类Person，子类Employee，当我实例化一个子类实例，并将其赋给父类的一个变量时，我很好奇，且不了解明明是子类的实例，结果能识别到父类的方法，也就是为什么能知道是父类调用了方法。

public class ClassConvert
{
public static void Main()
{
new ClassConvert().Run();
}

Employee kinsen;
object obj;
Person kong;

public void Run()
{
kinsen = new Employee("Kinsen", "Chan");
kinsen.SayHello();
kong = kinsen;
kong.SayHello();
obj = kong;

Console.ReadLine();

Console.WriteLine(kinsen.GetType());
Console.WriteLine(kong.GetType());
Console.WriteLine(obj.GetType());
Console.ReadLine();
}
}
public class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
public Person(string firstname, string lastName)
{
this.FirstName = firstname;
this.LastName = lastName;
}
public void SayHello()
{
Console.WriteLine("Hello,Word");
}

public override string ToString()
{
return FirstName + " " + LastName;
}
}
public class Employee : Person
{
public Employee(string firstname, string lastname) : base(firstname, lastname) { }
new public void SayHello()
{
Console.WriteLine("Hello,Word!My Name is " + base.FirstName);
}

运行结果如下：

我们知道，引用类型主要数据信息是存放在托管堆中，而这块内存中包含三大块，同步快，类型句柄已经实例信息，对于类型转换也仅仅是一个isinst或castclass指令（相见《.Net本质论 79页》）。最后把块托管堆上的地址赋给线程栈上的变量，也就是说线程栈上的内存仅仅保存了一个指向托管堆上的实例地址，而托管堆上仅有该实例的数据，已经类型句柄等数据，其中类型句柄又指向该实例的具体方法实例，其中包含了方法表等类型信息。于是最后我们看到三个变量的GetType都是第一个New出来的对象。但是为什么调用的方法输出却不同，父类变量能正确的调用它的方法，这又是为什么呢？

方法表与方法槽表

这其中涉及到方法表与方法槽表等方面的知识，然而关于这块内部的实现，MSDN却没有什么官方资料，仅仅只能从一些MVP和开发者的笔下了解到这块的存在。在上篇博文中，Anders Tan大哥对这方面做了一个解释：

方法表并不是指简单的方法列表。它包含了很多的东西，它代表了一个class（不是class的实例对象），其中既有方法列表也有static成员等等，所以这也就解释了为什么同一个class的实例中的static都是一样的，因为static成员就存放在方法表中，而每个实例的type handle都指向自身class的方法表。接着方法表是一个包含很多元素的一个对象，所以在其中的方法列表也就是给了另外一个概念，就是方法槽表，在方法槽表中的方法也是按一定顺序排列的。首先是父类的virtual方法，然后是自身的virtual方法，如果是override了父类的方法，那么父类的virtual方法就会被子类的方法所覆盖(这也就解释了在polymorphism下，向上转型后调用virtual方法会执行真正实例的方法)，接着是实例方法和静态方法。在方法槽后就是static成员。单是方法槽表本身并不包含其中各个方法的地址，我们知道.net程序在编译后是IL代码，但是在执行的时候由JIT再编译为本地代码，那么在方法调用和方法体的关联就会在执行后发生变化，而这个变化并不在方法槽表中处理，而是交给了方法描述。

《.Net本质论》对这块也有详细的描述：

方法表是一个带有长度前缀的内存地址数组，每个方法都有一个入口项。CLR方法表既包含实例来方法的入口，有包括静态方法的入口。（《.Net本质论》P155第一段倒数第三行，以下若无特别说明，则都摘自《.Net 本质论》）

CLR通过方法的声明类型的方法表路由（route）所有的方法调用。（P155第二段）

类型方法表的每个入口项指向一个唯一的存根例程（stub routine）。初始化时，每个存根例程包含一个对于CLR的JIT编译器的调用（它由内部的PreStubWorker程序公开）P156第二段

在这里，我并不打算深究方法表与方法槽表，仅仅是对于它们做一个简单的介绍，了解它们是什么，好方便我进一步的探究。

那什么是方法槽表，本质论中没有对槽表做一个明确的定义，但是从描述中我们也可以“想象”出它该有的形象，方法槽表顾名思义，是一张表结构的数据类型，可以将其想象成一排排的USB接口（槽口）,槽口上插入（保存）的就是方法表上的偏移量（定位了方法表上的方法）。方法槽表上的顺序首先是父类的virtual方法，然后是自身的virtual方法,再是自身的方法。

多态方法表（槽表）的内在模式

CLR中，声明一个方法，都会为该方法加上一个newslot标记，表明这是一个新方法，若一个方法声明为virtual且没有标明newslot标记，那么CLR就将其看成是一个新方法，否则就看成是基类同名方法的重写，如果标明了newslot,那槽表上开辟多一个槽位来保存这个新方法，若虚方法没有标明newslot，则把方法槽表上相应的“槽位”变成新方法的方法表偏移量，否则（没有重写虚方法），保存了基类方法的方法表偏移量。

具体调用

那么说了那么多，到底类型是怎么转换的？原来，我都过多的把中心放在数据中（内存）,期望从托管堆，线程栈上找到什么。当然，这注定失败，我完全忽略了代码的作用，毕竟，程序的执行也就是逐步执行代码（指令/机器码）,上篇博文中qmxle童鞋提到IL的实现，让我醍醐灌顶，茅舍顿开。

楼主，SayHello()方法不是虚方法的话，是在编译时绑定的。看看IL代码就明白了：
IL_000b: newobj instance void ConsoleApplication15.Program/Employee::.ctor(string,
string)
IL_0010: stloc.0
IL_0011: ldloc.0
IL_0012: callvirt instance void ConsoleApplication15.Program/Employee::SayHello()
IL_0017: nop
IL_0018: ldloc.0
IL_0019: stloc.1
IL_001a: ldloc.1
IL_001b: callvirt instance void ConsoleApplication15.Program/Person::SayHello()
第一个SayHello()方法，绑定的是Employee类型；第二个SayHello()方法，绑定的是Person类型。

这也就符合了《.Net本质论》中的说法。

当从一个对象引用的类型转换到另一个对象引用的类型时，必须考虑两个类型之间的关系。如果初始化引用的类型被认定与新引用的类型兼容，那么，CLR所要做的转换只是一个简单的IA-32 mov指令。这通常出现于这样的赋值情形中；当一个派生类型的引用到一个直接或间接基类的引用，或则到一个一直兼容的接口引用。

所以引用类型之间的类型转换并不存在什么效率消耗的问题，它们之间的效率消耗仅仅在转换之前做一个兼容性检查时会消耗CPU时间，而不像装箱，拆箱那样很大的性能消耗。对于新类型的操作，就是依靠CPU指令（代码）来识别了。看最后生成的IL：

//省略前面...
IL_000c: newobj instance void DebugTest.Employee::.ctor(string,
string)
IL_0011: stfld class DebugTest.Employee DebugTest.ClassConvert::kinsen
IL_0016: ldarg.0
IL_0017: ldfld class DebugTest.Employee DebugTest.ClassConvert::kinsen
IL_001c: callvirt instance void DebugTest.Employee::SayHello()
IL_0021: nop
IL_0022: ldarg.0
IL_0023: ldarg.0
IL_0024: ldfld class DebugTest.Employee DebugTest.ClassConvert::kinsen
IL_0029: stfld class DebugTest.Person DebugTest.ClassConvert::kong
IL_002e: ldarg.0
IL_002f: ldfld class DebugTest.Person DebugTest.ClassConvert::kong
IL_0034: callvirt instance void DebugTest.Person::SayHello()
//省略后面...

从上面可以看出,kinsen变量调用的是Employee的SayHello方法，而Kong变量调用的是Person的SayHello方法。这是因为

SayHello方法不是虚方法，且Employee类对SayHello方法用了new关键字，CLR识别了它们不是同一个方法，但是这样，我又引发了另一个问题。

新问题！您知道吗？

从上面的IL中，可以看到，分别调用了Employee和Person类SayHello，下面，我们把SayHello改成虚方法，并重写。

public class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
public Person(string firstname, string lastName)
{
this.FirstName = firstname;
this.LastName = lastName;
}
public virtual void SayHello()
{
Console.WriteLine("Hello,Word");
}

public override string ToString()
{
return FirstName + " " + LastName;
}
}
public class Employee : Person
{
public Employee(string firstname, string lastname) : base(firstname, lastname) { }
override public void SayHello()
{
Console.WriteLine("Hello,Word!My Name is " + base.FirstName);
}
}

结果如下：

现在他们的输出一样了，我们再看看生成的IL。

IL_000c: newobj instance void DebugTest.Employee::.ctor(string,
string)
IL_0011: stfld class DebugTest.Employee DebugTest.ClassConvert::kinsen
IL_0016: ldarg.0
IL_0017: ldfld class DebugTest.Employee DebugTest.ClassConvert::kinsen
IL_001c: callvirt instance void DebugTest.Person::SayHello()
IL_0021: nop
IL_0022: ldarg.0
IL_0023: ldarg.0
IL_0024: ldfld class DebugTest.Employee DebugTest.ClassConvert::kinsen
IL_0029: stfld class DebugTest.Person DebugTest.ClassConvert::kong
IL_002e: ldarg.0
IL_002f: ldfld class DebugTest.Person DebugTest.ClassConvert::kong
IL_0034: callvirt instance void DebugTest.Person::SayHello()

现在，它们调用的都是Person类的SayHello了，为什么会变成Person呢？预想中应该是Employee类的SayHello才对，如果调用

Employee类的SayHello方法，那一切都能合理的解释，但调用Person，程序是如何确定是Employee的SayHello方法呢？另外，我知道每个类型维护一张方法表，依稀记得一篇MSDN杂志上的文章说，如果在子类中找不到相关调用的方法，则会去父类的方法表中找，那么也就是子类和父类维护的方法表不一样，子类的方法表中不会出现父类的方法？或许，在这里的调用程序如此，首先，会根据当前实例instance找到类型句柄，定位到方法槽表，然后寻找槽表中匹配的方法，随后调用？如果是如我猜想的这般，子类重写的虚方法在方法槽表中的名称还是父类方法的全名，而非子类的名称？

尾声

希望各位童鞋发表自己的见解，也希望各位大大能抒发所学，不吝解答！对于上篇文章，很多童鞋都给出了自己的见解，给我理清概念有很大的帮助，在此很感谢大家，希望大家继续发光发热！：-）

本文链接

您真的了解类型转换吗？请止步，求解！

2011-08-24T15:57:00Z

前阵子，一名同事问及类型转换的问题，我也仅仅说出目前自己的了解。但回头想想，其中的确大有学问，以前只看到了表面，其内在的表现如何，苦苦翻书，Google几番之后，依然无所收获，故大胆写下，求园中各位大牛不吝解答。

类型转换的疑惑

首先，我们知道类型转换也就那点事（表面的说），总归而言，C#下有几种转换，装箱，拆箱，向上类型转换，向下类型转换，平行类型转换几种。这几种的区别目前也不细说了，感兴趣的童鞋可移步C# 装箱和拆箱[整理],向上类型转换，向下类型转换，平行类型(.Net本质论79页-运行时的类型)。

依照以往的知识，现在我们假设有一个Person类，再有一个Employee类，Employee继承Person，声明一个Employee的实例，并将其赋给一个Person的实例，由于类型是引用类型，则实际上它们都是指向同一个对象实例。代码如下：

Employee kinsen = new Employee("Kinsen", "Chan");
Person kong = kinsen;

这一点应该是毫无疑问的。问题是，已知在构造一个实例的时候，实际上是在堆栈上开辟一块空间，这块空间包含三块，分别是同步

块，类型句柄，以及实例具体信息。我们就是通过类型句柄来获得该实例的具体对象。但此时Person类实例kong指向的是kinsen实例的地址，那么该类型句柄的信息也应该是Employee而非Person的。但偏偏我们却能正确的获取到Person的方法，也能正确的执行，看一下代码

public class Program
{
static void Main(string[] args)
{
Employee kinsen = new Employee("Kinsen", "Chan");
kinsen.SayHello();
Person kong = kinsen;
kong.SayHello();
}

public class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
public Person(string firstname, string lastName)
{
this.FirstName = firstname;
this.LastName = lastName;
}
public void SayHello()
{
Console.WriteLine("Hello,Word");
}

public override string ToString()
{
return FirstName + " " + LastName;
}
}
public class Employee : Person
{
public Employee(string firstname, string lastname) : base(firstname, lastname) { }
new public void SayHello()
{
Console.WriteLine("Hello,Word!My Name is " + base.FirstName);
}
}
}

执行结果如下：

在这里我并没有采用虚方法，否则结果都是第一个了。可见，即使kong引用的是kinsen，但实际上它执行的还是Person类的方法。那么，到底是从哪里得知kong是Person类对象的呢？再见一个实验。

Employee kinsen = new Employee("Kinsen", "Chan");
kinsen.SayHello();
Person kong = kinsen;
kong.SayHello();
object obj = kong;

Console.WriteLine(kinsen.GetType());
Console.WriteLine(kong.GetType());
Console.WriteLine(obj.GetType());

除了Employee和Person类实例，我们还将kong赋给了一个object，然后输出实例的类型，结果如下：

可以看到，三个实例的实际类型都是Employee，但是Person类实例的确是执行了Person类的SayHello方法啊。这到底是为什么？

到处寻找答案，在《.Net本质论》79页中找到这么一段话：

当从一个对象引用的类型转换到另一个对象引用的类型时，必须考虑两个类型之间的关系。如果初始化引用的类型被认定与新引用的类型兼容，那么，CLR所要做的转换只是一个简单的IA-32 mov指令。这通常出现于这样的赋值情形中；当一个派生类型的引用到一个直接或间接基类的引用，或则到一个一直兼容的接口引用。

从这段话中，了解到为什么结果三个实例的类型都是Employee，但我想解决的问题还没解决，为何指向Employee实例引用的Person类实例还能准确的找到它的类型呢？目前我已知的信息如下：

实例地址，也就是线程栈上的地址，它只包含一个指向堆栈引用的指针。

堆栈内存块，也就是线程栈上保存那个指针指向的地址，它包含三部分，同步快，类型句柄，实例信息。其中类型句柄起到标识该实例所属类型，所拥有方法表等信息，但现状是三个实例指向的都是同一个内存地址，也就是它们是一模一样的。那它们到底是如何识别的？

内存中的表现形式

我再借助SOS来探查具体的信息，稍微改动了下代码，以便在SOS中更好查看。

static void Main(string[] args)
{
new Program().Run();
}
Employee kinsen;
object obj;
Person kong;

public void Run()
{
kinsen = new Employee("Kinsen", "Chan");
kinsen.SayHello();
kong = kinsen;
kong.SayHello();
obj = kong;

Console.WriteLine(kinsen.GetType());
Console.WriteLine(kong.GetType());
Console.WriteLine(obj.GetType());
}

通过！ClrStack命令得到当前对象的地址

000000000023e7e0 000007ff00190163 DebugTest.ClassConvert.Run()
PARAMETERS:
this = 0x00000000023c5ad0
0:000> !dumpobj 0x00000000023c5ad0
Name: DebugTest.ClassConvert
MethodTable: 000007ff00033b68
EEClass: 000007ff00182250
Size: 40(0x28) bytes
(E:\Projects\ClassConvert.exe)
Fields:
MT Field Offset Type VT Attr Value Name
000007ff00033d68 4000001 8 DebugTest.Employee 0 instance 00000000023c5b48 kinsen
000007fef43773f8 4000002 10 System.Object 0 instance 00000000023c5b48 obj
000007ff00033ca0 4000003 18 DebugTest.Person 0 instance 00000000023c5b48 kong

这里能看到DebugTest.ClassConvert类有三个实例，分别是kinsen,obj和kong,它们的value都相同（00000000023c5b48），这里

的确与程序中看到的一模一样，但是注意，它们的MT，也就是方法表却不一样了。再分别把他们解析一下。

//Name=kinsen
0:000> !dumpvc 000007ff00033d68 00000000023c5b48
Name: DebugTest.Employee
MethodTable 000007ff00033d68
EEClass: 000007ff00183498
Size: 32(0x20) bytes
(E:\Projects\ClassConvert.exe)
Fields:
MT Field Offset Type VT Attr Value Name
000007fef4377b08 4000004 0 System.String 0 instance 000007ff00033d68 <FirstName>k__BackingField
000007fef4377b08 4000005 8 System.String 0 instance 00000000023c5af8 <LastName>k__BackingField

//Name=obj
0:000> !dumpvc 000007fef43773f8 00000000023c5b48
Name: System.Object
MethodTable 000007fef43773f8
EEClass: 000007fef3f42200
Size: 24(0x18) bytes
(C:\Windows\assembly\GAC_64\mscorlib\2.0.0.0__b77a5c561934e089\mscorlib.dll)
Fields:

//Name=kong
0:000> !dumpvc 000007ff00033ca0 00000000023c5b48
Name: DebugTest.Person
MethodTable 000007ff00033ca0
EEClass: 000007ff001833f0
Size: 32(0x20) bytes
(E:\Projects\ClassConvert.exe)
Fields:
MT Field Offset Type VT Attr Value Name
000007fef4377b08 4000004 0 System.String 0 instance 000007ff00033d68 <FirstName>k__BackingField
000007fef4377b08 4000005 8 System.String 0 instance 00000000023c5af8 <LastName>k__BackingField

或许到这里，的确能解释为什么即使指向的对象是同一个，但却能在转换成其他类型之后做该类型的操作，但是

其中还是如一个黑匣子，我对此依然不明不白。

令人向往的方法表，方法槽表

此外，还有一张图，

这张图出自微软，对于一些概念，我还是比较模糊，例如方法表，方法槽表，SOS中的MT应该是方法表呢？还是方法槽表？从图上看来，方法表的分布比较散，看起来好像没什么规则，这样又如何确定方法槽表，方法表与方法槽表之间的关系又是如何呢？很希望大家能踊跃回答，如果有详细的资料就更好了。

渴望音讯

关于这个类型转换，类型句柄，方法表的问题纠结折腾了我许久，实在没办法了。才大胆发出来，恳求各位前辈，大大能帮小弟解惑。

可能也有童鞋也和我有一样的疑问，以下是一些我查找的知识点来源

揭示同步块索引（上）：从lock开始

揭示同步块索引（中）：如何获得对象的HashCode

揭示同步块索引(下):总结

关于CLR内存管理一些深层次的讨论[上篇]

深入探索.NET框架内部了解CLR如何创建运行时对象

本文链接

基于AppDomain的"插件式"开发

2011-08-01T01:58:00Z

很多时候,我们都想使用(开发)USB式(热插拔)的应用,例如,开发一个WinForm应用,并且这个WinForm应用能允许开发人员定制扩展插件,又例如,我们可能维护着一个WinService管理系统,这个WinService系统管理的形形色色各种各样的服务,这些服务也是各个"插件式"的类库,例如:

public interface IJob
{
void Run(DateTime time);
}

public class CollectUserInfo : IJob
{

public void Run(DateTime time)
{
//doing some thing...
}
}

我们提供了一个IJob接口,所有"服务"都继承该接口,然后做相关的配置,在服务启动时,就可以根据配置,反射加载程序集,执行我们预期的任务.

更新程序集(dll/exe)

服务/插件程序(后面只称为服务,虽然两者应用不同,但是在此处他们所运用的原理和作用是相同的 :-) )很健稳的运行着.但在服务/插件程序运行一段时间之后,某些"插件"的业务需求发生的变化,或者版本升级等种种外部原因,导致我们对原本的"插件"程序集进行了升级(可能从v1.0升级至v2.0).当我们想像Asp.net应用一样.把新的dll替换旧dll的时候,错误发生了.

发生该错误的原因很简单,因为我们的程序中已经调用了该dll,那么在CLR加载该dll到文件流中也给其加了锁,所以,当我们要进行覆盖,修改,删除的时候自然就无法操作该文件了.那我们该怎么做?为什么Asp.net可以直接覆盖?

AppDomain登场

我们知道,AppDomain是.Net平台里一个很重要的特性,在.Net以前,每个程序是"封装"在不同的进程中的,这样导致的结果就造就占用资源大,可复用性低等缺点.而AppDomain在同一个进程内划分出多个"域",一个进程可以运行多个应用,提高了资源的复用性,数据通信等.详见应用程序域

CLR在启动的时候会创建系统域(System Domain),共享域(Shared Domain)和默认域(Default Domain),系统域与共享域对于用户是不可见的,默认域也可以说是当前域,它承载了当前应用程序的各类信息(堆栈),所以,我们的一切操作都是在这个默认域上进行."插件式"开发很大程度上就是依靠AppDomain来进行.

"热插拔"实现说明

当加载了一个程序集之后,该程序集就会被加入到指定AppDomain中,按照原来的想法,要实现"热插拔",只要在需要使用该"插件"的时候,加载该"插件"的程序集(dll),使用结束后,卸载掉该程序集便可达到我们预期的效果.加载程序集很简单,.C#提供一个Assembly类,方便又快捷.

var _assembly = Assembly.LoadFrom(assemblyFile);

Assembly提供了数个加载方法详见Assembly类.

然后,C#却没有提供卸载程序集的方法,唯一能卸载程序集的方法只有卸载该程序集所在的AppDomain,这样,该AppDomain下的程序集都会被释放.知道这一点,我们便可以利用AppDomain来达到我们预期的效果.

AppDomain实现"热插拔"

首先,我们需要先实例化一个新AppDomain作为"插件"的宿主.在实例化一个Domain之前,先声明该Domain的一些基本配置信息

AppDomainSetup setup = new AppDomainSetup();
setup.ApplicationName = "ApplicationLoader";
setup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
setup.PrivateBinPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "private");
setup.CachePath = setup.ApplicationBase;
setup.ShadowCopyFiles = "true"; //启用影像复制程序集
setup.ShadowCopyDirectories = setup.ApplicationBase;
AppDomain.CurrentDomain.SetShadowCopyFiles();

setup.ShadowCopyFiles = "true";这句很重要,其作用就是启用影像复制程序集,什么是影像复制程序集,复制程序集是保证"热插拔"

实现的主要工作.AppDomain加载程序集的时候,如果没有ShadowCopyFiles,那就直接加载程序集,结果就是程序集被锁定,相反,如果启用了ShadowCopyFiles,则CLR会将准备加载的程序集拷贝一份至CachePath,再加载CachePath的这一份程序集,这样原程序集也就不会被锁定了. AppDomain.CurrentDomain.SetShadowCopyFiles();的作用就是当前AppDomain也启用ShadowCopyFiles,在此,当前AppDomain也就是前面我们说过的那个默认域(Default Domain),为什么当前域也要启用ShadowCopyFiles呢?

主AppDomian在调用子AppDomain提供过来的类型,方法,属性的时候,也会将该程序集添加到自身程序集引用当中去,所以,"插件"程序集就被主AppDomain锁定,这也是为什么创建了单独的AppDomain程序集也不能删除,替换(释放)的根本原因

利用SOS,可以很清楚的看到这一点

0:018> !dumpdomain
--------------------------------------
System Domain: 5b912478
LowFrequencyHeap: 5b912784
HighFrequencyHeap: 5b9127d0
StubHeap: 5b91281c
Stage: OPEN
Name: None
--------------------------------------
Shared Domain: 5b912140
LowFrequencyHeap: 5b912784
HighFrequencyHeap: 5b9127d0
StubHeap: 5b91281c
Stage: OPEN
Name: None
Assembly: 00109de0 [C:\Windows\Microsoft.Net\assembly\GAC_32\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll]
ClassLoader: 00110f68
Module Name
58631000 C:\Windows\Microsoft.Net\assembly\GAC_32\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll

--------------------------------------
Domain 1: 000f4598
LowFrequencyHeap: 000f4914
HighFrequencyHeap: 000f4960
StubHeap: 000f49ac
Stage: OPEN
SecurityDescriptor: 000f5568
Name: AppDomainTest.exe
Assembly: 00109de0 [C:\Windows\Microsoft.Net\assembly\GAC_32\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll]
ClassLoader: 00110f68
SecurityDescriptor: 001097b0
Module Name
58631000 C:\Windows\Microsoft.Net\assembly\GAC_32\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll

Assembly: 0011d448 [E:\Test\AppDomainTest\AppDomainTest\bin\Debug\AppDomainTest.exe]
ClassLoader: 00117fd0
SecurityDescriptor: 0011d3c0
Module Name
001c2e9c E:\Test\AppDomainTest\AppDomainTest\bin\Debug\AppDomainTest.exe

Assembly: 00131370 [C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Windows.Forms\v4.0_4.0.0.0__b77a5c561934e089\System.Windows.Forms.dll]
ClassLoader: 0011fa00
SecurityDescriptor: 001299a0
Module Name
579c1000 C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Windows.Forms\v4.0_4.0.0.0__b77a5c561934e089\System.Windows.Forms.dll

Assembly: 00131400 [C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Drawing\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Drawing.dll]
ClassLoader: 00131490
SecurityDescriptor: 0012e9c0
Module Name
62661000 C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Drawing\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Drawing.dll

Assembly: 00131d20 [C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System\v4.0_4.0.0.0__b77a5c561934e089\System.dll]
ClassLoader: 00133d08
SecurityDescriptor: 0012f078
Module Name
5aa81000 C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System\v4.0_4.0.0.0__b77a5c561934e089\System.dll

Assembly: 00131ed0 [C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Configuration\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Configuration.dll]
ClassLoader: 001415a8
SecurityDescriptor: 0012f430
Module Name
5a981000 C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Configuration\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Configuration.dll

Assembly: 00132080 [C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Xml\v4.0_4.0.0.0__b77a5c561934e089\System.Xml.dll]
ClassLoader: 00141620
SecurityDescriptor: 0012f5c8
Module Name
546e1000 C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Xml\v4.0_4.0.0.0__b77a5c561934e089\System.Xml.dll

Assembly: 00132ce0 [E:\Test\AppDomainTest\AppDomainTest\bin\Debug\CrossDomainController.dll]
ClassLoader: 001b3450
SecurityDescriptor: 06f94560
Module Name
001c7428 E:\Test\AppDomainTest\AppDomainTest\bin\Debug\CrossDomainController.dll

Assembly: 00132350 [C:\Users\kong\AppData\Local\assembly\dl3\6ZYK3XE9.86Q\2AQ35O7C.VHE\1f704bbb\b7cca5cf_8c4fcc01\ShowHelloPlug.DLL]
ClassLoader: 001b32e8
SecurityDescriptor: 070a8620
Module Name
001c7d78 C:\Users\kong\AppData\Local\assembly\dl3\6ZYK3XE9.86Q\2AQ35O7C.VHE\1f704bbb\b7cca5cf_8c4fcc01\ShowHelloPlug.DLL

--------------------------------------
Domain 2: 06fd0238
LowFrequencyHeap: 06fd05b4
HighFrequencyHeap: 06fd0600
StubHeap: 06fd064c
Stage: OPEN
SecurityDescriptor: 06724510
Name: ApplicationLoaderDomain
Assembly: 00109de0 [C:\Windows\Microsoft.Net\assembly\GAC_32\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll]
ClassLoader: 00110f68
SecurityDescriptor: 06f93bd0
Module Name
58631000 C:\Windows\Microsoft.Net\assembly\GAC_32\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll

Assembly: 00132e90 [E:\Test\AppDomainTest\AppDomainTest\bin\Debug\ApplicationLoader\assembly\dl3\c91a2898\f6f7f865_9a4fcc01\CrossDomainController.DLL]
ClassLoader: 001b3540
SecurityDescriptor: 06f92be0
Module Name
00a833c4 E:\Test\AppDomainTest\AppDomainTest\bin\Debug\ApplicationLoader\assembly\dl3\c91a2898\f6f7f865_9a4fcc01\CrossDomainController.DLL

Assembly: 001330d0 [E:\Test\AppDomainTest\AppDomainTest\bin\Debug\ApplicationLoader\assembly\dl3\32519346\b7cca5cf_8c4fcc01\ShowHelloPlug.DLL]
ClassLoader: 001b39f0
SecurityDescriptor: 06f92f98
Module Name
00a83adc E:\Test\AppDomainTest\AppDomainTest\bin\Debug\ApplicationLoader\assembly\dl3\32519346\b7cca5cf_8c4fcc01\ShowHelloPlug.DLL

除了新建的AppDomain(Domain2)中的Module引用了ShowHelloPlug.dll,默认域(Domian1)也有ShowHelloPlug.dll的

程序集引用.

应用程序域之间的通信

每个AppDomain都有自己的堆栈,内存块,也就是说它们之间的数据并非共享了.若想共享数据,则涉及到应用程序域之间的通信.C#提供了MarshalByRefObject类进行跨域通信,那么,我们必须提供自己的跨域访问器.

public class RemoteLoader : MarshalByRefObject
{
private Assembly _assembly;

public void LoadAssembly(string assemblyFile)
{
try
{
_assembly = Assembly.LoadFrom(assemblyFile);
//return _assembly;
}
catch (Exception ex)
{
throw ex;
}
}

public T GetInstance<T>(string typeName) where T : class
{
if (_assembly == null) return null;
var type = _assembly.GetType(typeName);
if (type == null) return null;
return Activator.CreateInstance(type) as T;
}

public void ExecuteMothod(string typeName, string methodName)
{
if (_assembly == null) return;
var type = _assembly.GetType(typeName);
var obj = Activator.CreateInstance(type);
Expression<Action> lambda = Expression.Lambda<Action>(Expression.Call(Expression.Constant(obj), type.GetMethod(methodName)), null);
lambda.Compile()();
}
}

为了更好的操作这个跨域访问器,接下来我构建了一个名为AssemblyDynamicLoader的类,它内部封装了RemoteLoader类

的操作.

public class AssemblyDynamicLoader
{
private AppDomain appDomain;
private RemoteLoader remoteLoader;
public AssemblyDynamicLoader()
{
AppDomainSetup setup = new AppDomainSetup();
setup.ApplicationName = "ApplicationLoader";
setup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
setup.PrivateBinPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "private");
setup.CachePath = setup.ApplicationBase;
setup.ShadowCopyFiles = "true";
setup.ShadowCopyDirectories = setup.ApplicationBase;
AppDomain.CurrentDomain.SetShadowCopyFiles();
this.appDomain = AppDomain.CreateDomain("ApplicationLoaderDomain", null, setup);
String name = Assembly.GetExecutingAssembly().GetName().FullName;
this.remoteLoader = (RemoteLoader)this.appDomain.CreateInstanceAndUnwrap(name, typeof(RemoteLoader).FullName);
}

public void LoadAssembly(string assemblyFile)
{
remoteLoader.LoadAssembly(assemblyFile);
}

public T GetInstance<T>(string typeName) where T : class
{
if (remoteLoader == null) return null;
return remoteLoader.GetInstance<T>(typeName);
}

public void ExecuteMothod(string typeName, string methodName)
{
remoteLoader.ExecuteMothod(typeName, methodName);
}

public void Unload()
{
try
{
if (appDomain == null) return;
AppDomain.Unload(this.appDomain);
this.appDomain = null;
}
catch (CannotUnloadAppDomainException ex)
{
throw ex;
}
}
}

这样我们每次都是通过AssemblyDynamicLoader类进行跨域的访问.

AppDomain.CurrentDomain.SetShadowCopyFiles();
this.appDomain = AppDomain.CreateDomain("ApplicationLoaderDomain", null, setup);
String name = Assembly.GetExecutingAssembly().GetName().FullName;
this.remoteLoader = (RemoteLoader)this.appDomain.CreateInstanceAndUnwrap(name, typeof(RemoteLoader).FullName);

通过我们前面构造的一个AppDomainSetup,构建了一个我们所需的AppDomain,并且在这个appDomain中构建了

一个RemoteLoader类的实例(此时该实例已具备跨域访问能力,也就是说我们在主域能获取子域内部的数据信息).目前RemoteLoader只提供了少数的几个方法.

跨域操作

下面,我们就模拟一次"插件式"的跨域操作.首先我们构造了一个窗体,其有以下元素.

选择程序集路径之后,加载程序集,然后就触发程序集指定类型(通过配置获取)的特定操作.这里我们定义了一个公共接口,它是所有"插件"操作的主要入口了.

public interface IPlug
{
void Run();
}

随后定义了一个实现该接口的类.

[Serializable]
public class ShowHelloPlug : IPlug
{
public void Run()
{
MessageBox.Show("Hello World...");
}
}

这个"插件"的工作很简单.仅仅弹出一个对话框,说声"Hello World…",接下来将其编译成一个dll.

回到界面,选择刚才编译的Dll,然后直接加载.

到这里,我们的工作完成了一半了.呼呼.OK.我们的需求发生了变化,不再是弹出Hello World了.而时候弹出Hi,I'm Kinsen,我们修改刚才的子类,并再编译一次.再将Dll替换刚才的Dll,这次,Dll没有没锁定(因为我们前面启用了ShadowCopyFiles.).再加载一下程序集,你会发现结果并不是"Hi,I'm Kinsen",而是"Hello World.."为什么会这样呢?这时候,借助SOS的力量(前面有SOS结果).

我们发现Domain1(Default Domain)和Domain2(新创建Domain)都引用了程序集ShowHelloPlug.DLL,但是两个引用的Dll地址却不相同,这是因为启用了ShadowCopyFiles,它们加载的都是各自程序集的备份,我们根据Domain2的Assembly地址查看ShowHelloPlug的编译代码.

0:011> !dumpmt 00fc40ac
00fc40ac is not a MethodTable
0:011> !dumpmd 00fc40ac
Method Name: Plug.ShowHelloPlug.Run()
Class: 046812b4
MethodTable: 00fc40bc
mdToken: 06000001
Module: 00fc3adc
IsJitted: no
CodeAddr: ffffffff
Transparency: Critical

从IsJitted为no可以看出,该程序集并没有被调用,那调用的是谁?我们再次查看Domain1(Default Domain

)中的ShowHelloPlug.

0:011> !dumpmd 001f8240
Method Name: Plug.ShowHelloPlug.Run()
Class: 004446e4
MethodTable: 001f8250
mdToken: 06000001
Module: 001f7d78
IsJitted: yes
CodeAddr: 00430de0
Transparency: Critical

已知每个AppDomain都有自己的堆栈信息,各自不互相影响,所以,当我们在主域中获取到了子域中的数据,并非新建一个指向该实例的引用,而是在自己的堆栈上开辟出一块空间"深度拷贝"该实例,那么必然就达不到我们我需的结果.

子域内部调用

那么为了达到我们预期的效果,我们必须在子域内部执行我们所需的操作(调用),所以在RemoteLoader类中增加了一个Execute方法

public void ExecuteMothod(string typeName, string methodName)
{
if (_assembly == null) return;
var type = _assembly.GetType(typeName);
var obj = Activator.CreateInstance(type);
Expression<Action> lambda = Expression.Lambda<Action>(Expression.Call(Expression.Constant(obj), type.GetMethod(methodName)), null);
lambda.Compile()();
}

此处我暂时只想到了利用反射调用,这样的代价就是调用所需消耗的资源更多,效率低下.目前还没有

想出较好的解决方案,有经验的童鞋欢迎交流.

这样外部的调用就变成以下

loader = new AssemblyDynamicLoader();
loader.LoadAssembly(txt_dllName.Text);
//var obj = loader.GetInstance<IPlug>("Plug.ShowHelloPlug");
//obj.Run();
loader.ExecuteMothod("Plug.ShowHelloPlug", "Run");

现在在将Dll替换,结果正常.

尾声

做"插件式"开发,除了利用AppDomain之外,也有童鞋给出了另一种解决方案,也就是在加载Dll的时候,先将Dll在内存中复制一份,这样原来的Dll也就不会被锁定了.详见插件的“动态替换”.

以上实例本人皆做过实验,但可能还存在一定不足或概念错误,若有不当之处,欢迎各位童鞋批评指点.

通过应用程序域AppDomain加载和卸载程序集

什么是的AppDomain

本文链接

青梅煮酒论C#:Specification pattern

2011-01-16T05:56:00Z

Specification模式早在3个多月前,阅读一个开源博客的时候便接触到了.但并没多少深入.最近,抽空将其好好研究了一番,果然,其魅力的确能让你回味无穷,那现在,就让我们零距离接触Specification模式吧!

何为Specification?

Specification,中文有翻译规格,虽然有很多争论,但目前叫得最多的,还是规格模式,既然说到了规格,那其作用估计就能不言而喻了.

Specification模式的作用是构建可以自由组装的业务逻辑元素.

上面这句话可以完整的概括Specification的作用,但第一次理解或许会有些许困难,没关系,可以这么理解,Specification模式起作用的,是每个Specification类,每一个Specification类,可以看成一张"规格书",或者说是某种"规格约束",而通过这张"规格书"或者"规格约束",我们能得到我们所想要的这种"规格"的对象,并且,不同的规格是可以组合起来,形成新的规格.如果还不明白.好吧,您知道乐高积木吧?我们形象的把每个规格想象成一个不同的乐高模型,而不同的乐高模型组合在一起了,就形成了新的模型,以达到我们所需的结果.

如何实现Specification

了解了什么是Specification,那接下去,您肯定会问,该怎么实现?其实很简单,Specification模式里面只有一个方法,我们有了"规格书",下一步,当然就是从不同的对象中得到符合"规格书"的对象,那这个匹配的过程就形成了一个动作抽象.IsSatisfiedBy就是帮助你从"对象堆"中找到你所需"规格"的动作.如此.我们可以实现的Specification接口如下

public interface ISpecification<T>
{

bool IsSatisfiedBy(T candidate);

}

但是,一般的Specification都提供了几个基本的组合操作,例如Add,Or,Not,可以利用它们分别组合成一个新的Specification.经过初步改动,最后ISpecification如下

public interface ISpecification<T>
{

bool IsSatisfiedBy(T candidate);

ISpecification<T> Add(ISpecification<T> other);

ISpecification<T> Or(ISpecification<T> other);

ISpecification<T> Not();

}

为了重用可复用逻辑,我们定义了一个抽象类CompositeSpecification

public abstract class CompositeSpecification<T> : ISpecification<T>
{

public abstract bool IsSatisfiedBy(T candidate);

public ISpecification<T> Add(ISpecification<T> other)
{

return new AddSpecification<T>(this, other);

}

public ISpecification<T> Or(ISpecification<T> other)
{

return new OrSpecification<T>(this, other);

}

public ISpecification<T> Not()
{

return new NotSpecification<T>(this);

}

}

并定义了基本的几个"组合"类

public class AddSpecification<T> : CompositeSpecification<T>
{

private ISpecification<T> one;

private ISpecification<T> other;

public AddSpecification(ISpecification<T> one, ISpecification<T> other)
{

this.one = one;

this.other = other;

}

public override bool IsSatisfiedBy(T candidate)
{

return one.IsSatisfiedBy(candidate) && other.IsSatisfiedBy(candidate);

}

}

public class OrSpecification<T> : CompositeSpecification<T>
{

private ISpecification<T> one;

private ISpecification<T> other;

public OrSpecification(ISpecification<T> one, ISpecification<T> other)
{

this.one = one;

this.other = other;

}

public override bool IsSatisfiedBy(T candidate)
{

return one.IsSatisfiedBy(candidate) || other.IsSatisfiedBy(candidate);

}

}

public class NotSpecification<T> : CompositeSpecification<T>
{

private ISpecification<T> one;

public NotSpecification(ISpecification<T> one)
{

this.one = one;

}

public override bool IsSatisfiedBy(T candidate)
{

return !one.IsSatisfiedBy(candidate);

}

}

最后,我们定义我们所需要的规格,在这里,我们定义一个基数规格与正数规格

public class OddSpecification : ComsptionSpecification<int>
{

public override bool IsSatisfiedBy(int candidate)
{

return candidate % 2 != 0;

}

}

public class PlusSpecification : ComsptionSpecification<int>
{

public override bool IsSatisfiedBy(int candidate)
{

return candidate > 0;

}

}

现在,万事俱备,只欠东风.就差你来调用了.

static void Main(string[] args)
{

var items = Enumerable.Range(-5, 10);

ISpecification<int> oddSpec = new OddSpecification();

var spec = MoreCandidate(oddSpec);

foreach (var i in items.Where(it => spec.IsSatisfiedBy(it)))
{

Console.WriteLine(i);

}

}

static ISpecification<int> MoreCandidate(ISpecification<int> spec)
{

ISpecification<int> plusSpec = new PlusSpecification();

return spec.Or(plusSpec);

}

这个逻辑还是十分简单的.我们先定义了一个基数规格,后面我们发现这个规格不足以得到我们所需要的,我们想OrWhere它是正数.于是,我们"组合"成了一个新的规格.结果

这里应该注意的是.在这里我们提供了一种OrWhere功能,这是在一条条件的基础上再匹配多另一条条件,有同学说直接Where(it=>it%2!==0||it>0)就可以了.必须指明的是,后者就变成了一个条件.你把两个条件合并写死成一个条件了.不是将其"组合"成一个新条件.就像你用乐高堆砌出一架跑车模型和直接浇铸出一架跑车模型的概念是完全不同的.

优雅实现

虽然我们完美的实现了Specification模式,但是,聪明的你应该能看到它的弊病了.就是传统的Specification模式实在是太"重量级"了,如果你想实现一个新的"规格",那么你必须需要新增一个新的Specification类.这样下来,最终我们的类库中必然堆积了许许多多的Specification类.既然如此,有没有什么方法可以让其的实现变得更加的轻易?答案是肯定的.我们再一次解析Specification模式,其重点是IsSatisfiedBy方法.遵守我们一贯的思路,改进必然是在重点实现处.于是,一种优雅的实现便诞生了.

public interface ISpecification<T>
{

bool IsSatisfiedBy(T candidate);

}

我们还是必须定义一个ISpecification接口.与前面不同的是,该接口里不再有Add,Or,Not等方法.为何?后面讲解.

public class Specification<T> : ISpecification<T>
{

private Func<T, bool> m_isSatisfiedBy;

public bool IsSatisfiedBy(T candidate)
{

return m_isSatisfiedBy(candidate);

}

public Specification(Func<T, bool> isSatisfiedBy)
{

this.m_isSatisfiedBy = isSatisfiedBy;

}

}

接下来,我们定义了Specification<T>类继承了ISpecification<T>接口,此处要注意的是.在其构造函数中.我们传入了一个委托,然后,将该委托赋给私有变量m_isSatisfiedBy,最后.IsSatisfiedBy方法只是简单的调用了该Func,这实际上了也是依赖了注入.只不过我们注入的是一种特殊的类,委托.如此一来,只要我们需要新的"规格"时,只需要传入相应不同委托便可以实现.那么传统实现中Add,Or,Not等组合实现该如何实现.在次我们利用C#3.5的特性--扩展方法.我们实现了一个扩展类,并将所有的"组合"方法变成扩展方法.

public static class SpecificationExtensions
{

public static ISpecification<T> Add<T>(this ISpecification<T> one, ISpecification<T> other)
{

return new Specification<T>(candidate => one.IsSatisfiedBy(candidate) && other.IsSatisfiedBy(candidate));

}

public static ISpecification<T> Or<T>(this ISpecification<T> one, ISpecification<T> other)
{

return new Specification<T>(candidate => one.IsSatisfiedBy(candidate) || other.IsSatisfiedBy(candidate));

}

public static ISpecification<T> Not<T>(this ISpecification<T> one)
{

return new Specification<T>(candidate => !one.IsSatisfiedBy(candidate));

}

}

至于为什么要生成一个新的扩展类,并将方法提取出来.站在面向对象的角度上并不能说哪种更"面向对象",实际上,并没有纯粹意义上的"面向对象标准".只是我们习惯上会不知不觉把一些"良好的面向对象实践"当成"标准",开发者站在不同的位置上,看到的东西,细节必然不同.如此,"面向对象"的结果也就不同.老赵说得很对(个人观点),当我们执行Add,Or,Not等操作的时候,并不是对象本身去Add,Or,Not,一般比较而言,更多的我们不会拿自己与别人比较,这样未免有失公正,而是有个"第三方",由它来进行比较,拿"你"和"他"进行比较.这里,我们也是借鉴现实生活的抽象,完成类的抽象.至此,这个轻量级的实现已经完成.

static void Main(string[] args)
{

var items = Enumerable.Range(-5, 10);

ISpecification<int> oddSpec = new Specification<int>(it => it % 2 != 0);

var spec = MoreCandidate(oddSpec);

foreach (var i in items.Where(it => spec.IsSatisfiedBy(it)))
{

Console.WriteLine(i);

}

}

static ISpecification<int> MoreCandidate(ISpecification<int> spec)
{

ISpecification<int> plusSpec = new Specification<int>(it => it > 0);

return spec.Or(plusSpec);

}

轻量级实现

即使前面的实现已经足够"轻量级",但对于懒人而言却往往还是不够的.那么是否还有更"懒"的实现方法?答案是肯定的.再一想一下,Specification模式的实现其实就是IsSatisfiedBy方法的实现.那么我们直接把IsSatisfiedBy提取出来,形成一种更"懒"的实现.聪明的你应该想到了.答案就是利用委托.我们新建了一个委托.

public delegate bool Spec<T>(T candidate);

命名为Spec完全只是为了说明这是一个Specification,它接受一个参数,并返回一个布尔值.只不过这种实现是在太过于简单.简单到没有提供一定的约束.所以,必须遵守一种约定,这也是约定大于约束的一种实现.和第二种实现同理,我们还实现一个SpecificationExtension类.

public static class SpecExtensitions
{

public static Spec<T> Add<T>(this Spec<T> one, Spec<T> other)
{

return candidate => one(candidate) && other(candidate);

}

public static Spec<T> Or<T>(this Spec<T> one, Spec<T> other)
{

return candidate => one(candidate) || other(candidate);

}

public static Spec<T> Not<T>(this Spec<T> one)
{

return candidate => !one(candidate);

}

}

这样一来.我们就实现了一套"超轻量级"的Specification实现.

static void Main(string[] args)
{

var items = Enumerable.Range(-5, 10);

Spec<int> oddSpec = it => it % 2 != 0;

var spec = MoreCandidate(oddSpec);

foreach (var i in items.Where(it => spec(it)))
{

Console.WriteLine(i);

}

}

static Spec<int> MoreCandidate(Spec<int> spec)
{

return spec.Or(it => it > 0);

}

结语

Specification模式的应用能很大程度上减少我们的工作量,目前应用的比较多的是在LINQ2SQL上,查询数据时采用不同的Specification从而获取你所需要的数据.MVC下的Reposity+Specification能大大提高项目的扩展性.不过,世上没有万能的灵丹妙药,如一把双刃剑,能伤人,也能伤己.任何一种模式的滥用都会造成不良的影响.所以,只有该需要它的时候使用它才是最合理的.那什么时候该使用呢?当你发现你的条件实在是太过千变万化,当你需要OrWhere,当你.....(欢迎你留下你认为合适的时候,:-) )

扩展阅读

Specification模式

依赖注入（控制反转）

趣味编程：C#中Specification模式的实现

趣味编程：C#中Specification模式的实现（参考答案 - 上）

趣味编程：C#中Specification模式的实现（参考答案 - 下）

本文链接

应届毕业生面试失败之谈

2010-12-14T10:34:00Z

即将毕业,学校里也不断的施加压力找工作,找单位实习.身边的同学也一个接一个的实习了.压力就更大了.每天都形成了一个习惯,一开机就打开51job看看有没适合自己的单位.

经过好几周挑选.发了10多份简历,却没一份回信.那个焦急啊.迫不得已.只能打电话联系了..今天联系了一家公司.问是否还需要asp.net程序员.他们说要.问到应届毕业生能否实习时.说到实习的话可能有一定问题.我就说已经有了两年的.net开发经验.对方听到两年就说可以.那就过来面试看看吧.于是就下午过去了.而且也想看看宝安(深圳)的环境.该公司的要求如下:

1、 2年以上ASP.NET编程经验（WEB开发）
2、熟练使用VS.NET2005/2008 开发工具
3、熟悉中小型网站的开发模式和流程
4、熟悉Javascript、Ajax开发,熟悉DIV+CSS布局
5、熟悉SQL SERVER数据库，能熟练进行数据库编程
6、具有大型网站项目开发经验者优先
素质要求：
1、较强的逻辑思维能力、学习能力，有良好的沟通和团队协作能力，具备独立完成工作能力，能快速适应新的工作环境
2、具备高度的责任心，有诚实守信、刻苦钻研和吃苦耐劳精神

恩,基本都信心满满的就过去了.坐了一个小时的车.终于到了.一见面.那个负责人给我的感觉就是对应聘者(我),或者说对应聘这件事不太重视吧!一见面就问我有没带简历.我说,是web版的.打印出来就没有原先的风格了,再过去之前,我发了两次简历给他.但是却一次都没看.令人心寒..他说没关系.视觉呈现没所谓,就叫一个文员MM打印下来.粗略浏览了一下.说,刚刚毕业,算法应该不错,给几道题你做..我瞬间就急了.想说,我对算法没多大研究,主要是面向对象/设计模式......还没来得及开口,人走了..回来拿了一张A4纸,正反两页都是题目.说你先做着,说完又离开了.一看题目.我傻眼了.满页的SQL题目..偏偏对SQL并不是很熟悉,普通的查询还写得出来.但是自从LINQ出现后.再也没碰过T-SQL.更别说复杂查询了..第一道题是跨表查询,第二道是3表查询.第三道是递归查询.我承认.我很菜,对SQL本来就不多使用.并且现在还是跨表查询..T-SQL是写不出来了.算了,用LINQ实现吧.用LINQ实现还是没什么难度的.基本上查找的数据都能得到,只是第三道没做过,一时也没什么想法.往下是两道正则表达式的题目.IP和电话号码.用简单的实现搞定了.翻页.三道"算法"题,应该能算算法吧.

第一道是写个方法,该方法传入两个参数,第一个是浮点型,第二个是整数,要求根据把该浮点数的第N位小数位四舍五入..并且不使用.Net的Math类.一时之间没什么想法.第二道是求22/7的小数点后300位数字,要求递归实现..递归实现不出.直接就ToString然后截取了.第三道忘记了.但是实现挺简单的.往后是要求实现单例模式.OK.搞定.再来是给一个方法,该方法有个Lock.问会不会死锁..感觉不会发生死锁,在下就是要用Ajax实现截取一个RSS的内容,并且指定用HttpXMLRequest实现..完全忘记那几个兼容的object了.JQ用多了的坏处啊.往会一看,挂了N题了.再下就是问Remoting和WebServices的区别和应用.Remoting没用过.不知道.对WebService有一点点使用心得吧.但是占的比例少得可怜.往下就叫你说说自己用过的MVC框架和实体框架.这个比例.不想说了.请注意.都是答题的形式写的.不是问答.

一看时间,已经快4点了.在不走,回到学校估计6点多了.叫那个负责人..敲了门,示意做完了.他点头.我回去继续等.还要等了个10多分钟才出来.在这10多分钟里面纠结了N久.是不是该直接离开,估计不可能留下来了.负责人出来后也就是初略的看了一下答的题..跟他说对T-SQL没深入.就用LINQ实现了.反应不强力.还是漫不经心的看着.我看着就觉得没戏了.然后就跟我说他们公司主要是SQL方面应用比较多.一个项目下来几百个存储过程都有...然后就说实习的话要求很低之类的.说住的地方远不适合实习之类的...然后就说以后有机会再合作之类的...我没多说.离开了.从头到尾没说过一点Web方面的东西.唉.

这次学到一点东西..临近毕业,心态就更显着急了.每天逛招聘网站.但招聘网站找应届的少得可怜,大专的就更少了..以后找工作,投简历.要过去面试之前最好先问一下他们对哪方面的技术看得比较重.这样就不至于发生今天这种牛头不对马嘴的事了..而且要做好准备吧.不单单是平时用的东西,市场需要的技术都要适当的了解一下.这样才会大大的提高成功率吧!末了.不知有没有在深圳工作的前辈,需要找工的呢?有的话可以联系我,给个机会我试试.专注于.Net开发.多谢各位前辈的关照了.也看能否给其他我这种状态的同学提供一个机会.其实.我们并不比外面的程序员差多少!

本文链接