博客园_人最大的荣耀不在于从未失败，而在于每次失败以后都能东山再起

如何用正则表达式替换掉所有HTM内容

2012-02-10T09:25:00Z

比如有如下的内容：

<html>

<head>

</head>

<body>

fdfdfds

</body>

</html>

remained content

用正则表达式替换后，如何才能只剩下：

remained content

答案:

用如下的代码：

result = Regex.Replace(result, "<html>(<|>|.|\\n)*?</html>", "");

本文链接

PowerShell中.psl文件不执行

2012-02-07T09:05:00Z

用如下的命令在PowerShell中创建一个psl文件:

notepad .\net.psl

在里面输入命令后保存并关闭.

再在PowerShell中执行如下的命令：

.\net.psl

结果并没有执行命令，而是弹出如下的窗口：

怎么回事那？

解决方法：

后缀名是ps1,而不是psl.一字之差，差之千里啊。

另外需要用下面的命令设置执行策略，.ps1文件才能执行。

Set-ExecutionPolicy remotesigned

本文链接

用windows explorer 从SharePoint上拷贝文件的问题

2012-02-07T06:15:00Z

用explorer视图打开 SharePoint的一个库：

可以看到文件列表，但是拷贝到本地的时候报错：

测试了一下：

用记事本打开的话，也会报错：

看来确实是权限的问题。

只能在网站上send to->download a copy一个文件一个文件的下载了

本文链接

一个写文件的函数

2012-02-03T08:06:00Z

/// <summary>

/// Writes log file.

/// </summary>

/// <param name="filePath">file path</param>

/// <param name="content">file content</param>

/// <param name="append">whether append to end of the file</param>

public static void WriteLogFile(string filePath, string content, bool append)

{

FileInfo fi = new FileInfo(filePath);

if (fi.Exists)

{

if (!append)

{

fi.Delete();

}

else

{

using (FileStream fs = fi.Create())

{ }

}

using (StreamWriter sw = fi.AppendText())

{

sw.WriteLine(content);

}

其中这一句：

using (FileStream fs = fi.Create())

{ }

一定要用using, 否则FileStream不会被释放，导致后面的文件操作提示："The process cannot access the file <file name> because it is being used by another process."

本文链接

DotNetZip使用简介

2012-02-02T09:54:00Z

DotnetZip是一个开源类库，可以用donet开发语言来操作文件来生成zip文件。功能强大，操作方便。

下载地址在这里：

http://dotnetzip.codeplex.com/

下载到的包里有很多个dll文件，一般引用Ionic.Zip.dll就可以：

然后引用这个命名空间：

using Ionic.Zip;

以下是一个简单的例子：

using (ZipFile zip = new ZipFile())

{

// add this map file into the "images" directory in the zip archive

zip.AddFile("c:\\images\\personal\\7440-N49th.png", "images");

// add the report into a different directory in the archive

zip.AddFile("c:\\Reports\\2008-Regional-Sales-Report.pdf", "files");

zip.AddFile("ReadMe.txt");

zip.Save("MyZipFile.zip");

}

更详细的例子在这里，可以看到这东东支持的开发语言很多：

http://dotnetzip.codeplex.com/wikipage?title=Examples&referringTitle=Home

本文链接

SharePoint中的RPC调用

2012-02-02T09:45:00Z

SharePoint中的RPC，其原理是用post方法向sharepoint服务器发送如下的URL请求：

http://[site_name]/_vti_bin/owssvr.dll?Cmd=Method_name[&Parameter1=Value1&Parameter2=Value2...]

这个一个请求URL的例子：

POST /site_url/_vti_bin/_vti_aut/author.dll HTTP/1.0

method=list+documents:6.0.n.nnnn

&service_name=/

&listHiddenDocs=false

&listExplorerDocs=false

&listRecurse=false

&listFiles=true

&listFolders=true

&listLinkInfo=true

&listIncludeParent=true

&listDerived=false

&listBorders=false

&listChildWebs=true

&initialUrl=url

这个一个请求服务器返回数据的例子，是HTML格式，需要自己来解析以便得到想要的数据：

Content-type: application/x-vermeer-rpc..X-FrontPage-User-Name:

usernameCRLF

CRLF

<html><head><title>vermeer.RPC

packet</title></head>LF<body>.

LF<p>method=list documents:

6.0.x.xxxxLF<p>document_list=

LF<ul>

LF<ul>LF<li>document_name=Default.htm

LF<li>meta_info=

LF<ul>

LF<li>vti_author

LF<li>SR|author

LF<li>vti_title

LF<li>SW|Home Page

LF<li>vti_timecreated

LF<li>TR|10 Sep 1998 10:07:54 -0700

LF<li>vti_filesize

LF<li>IX|277

LF<li>vti_modifiedby

LF<li>SR|author

LF<li>vti_nexttolasttimemodified

LF<li>TR|10 Sep 1998 10:07:54 -0700

LF<li>vti_timelastmodified

LF<li>TR|10 Sep 1998 10:07:55 -0700

LF<li>vti_timelastwritten

LF<li>TX|10 Sep 1998 10:07:56 -0700

LF</ul>

LF<ul>

LF<li>document_name=new1.htm

LF<li>meta_info=

LF<ul>

LF<li>vti_author

LF<li>SR|IUSR_author

</body>

</html>

有三种方法来使用RPC：

使用ASPX页面：
http://msdn.microsoft.com/en-us/library/ms470842.aspx
发送URL和发送CAML。这两种方法的原理在这里。
http://msdn.microsoft.com/en-us/library/ms463030.aspx
自己定制类发送请求。
已经有了写了现成的类，在这里：
http://www.java2s.com/Open-Source/CSharp/Web/portalsolutions/PS/Utils/FPRPC/FrontPageRPC.cs.htm
为了防止链接的页面被删除，在这里做一个备份。

using
									System;

using
									System.Collections.Generic;

using
									System.IO;

using
									System.Net;

using
									System.Security.Principal;

using
									System.Text;

using
									System.Text.RegularExpressions;

using
									System.Collections.Specialized;

using
									System.Web;

namespace PS.Utils.FPRPC{


									/// <summary>


									/// Client for calling Front Page Server Extensions.


									/// </summary>


									public
									class
									FrontPageRPC


									private
									readonly ICredentials credentials;


									private
									static
									string serverExtensionsVersion;


									private
									const
									string STR_AUTHOR_DLL_PATH = "/_vti_bin/_vti_aut/author.dll";


									private
									const
									string STR_VTI_RPC_PATH = "/_vti_bin/shtml.dll/_vti_rpc";


									private
									const
									string defaultServerVersion = "6.0.2.5614";


									public
									FrontPageRPC()

            : this(CredentialCache.DefaultCredentials)


									public
									FrontPageRPC(ICredentials credentials)

            this.credentials = credentials;


									/// <summary>


									/// Has WSS parse the site vs. file/folder portion of a URL.


									/// </summary>


									/// <param name="uri"></param>


									/// <returns></returns>


									public
									WebUrl UrlToWebUrl(string uri)


									WebUrl webUrl = new
									WebUrl();


									Uri aUri = new
									Uri(uri);


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "url to web url:" + defaultServerVersion);

            methodData.Add("url", aUri.AbsolutePath);

            methodData.Add("flags", "0");


									string response = SendSimpleRequest(GetVtiRPC(aUri.GetLeftPart(UriPartial.Authority)), methodData);

            webUrl.SiteUrl = aUri.GetLeftPart(UriPartial.Authority) + GetReturnValue(response, "webUrl");

            webUrl.FileUrl = HttpUtility.UrlDecode(GetReturnValue(response, "fileUrl"));


									return webUrl;


									public
									DocumentInfo GetDocument(WebUrl webUrl, Stream outStream)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "get document:" + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name", "");

            methodData.Add("document_name", webUrl.FileUrl);

            methodData.Add("get_option", "none");

            methodData.Add("timeout", "10");


									using (Stream responseStream = StartWebRequest(GetAuthorURL(webUrl), methodData))


									BufferedStream bufferedResponseStream = new
									BufferedStream(responseStream, 4096);


									string metaInfo = GetDocumentResponse(bufferedResponseStream);

                bufferedResponseStream.CopyTo(outStream);


									return ParseMetaInformationResponse(metaInfo);


									private
									static
									string GetDocumentResponse(Stream responseStream)


									if (null == responseStream)


									throw
									new
									ArgumentException("responseStream is null");


									string metaInfo = ExtractResponsePreamble(responseStream);


									if (string.IsNullOrEmpty(metaInfo))


									throw
									new
									FrontPageRPCException("unable to parse responseData");

            CheckForInternalErrorMessage(metaInfo);

            CheckForSuccessMessage(metaInfo);


									return metaInfo;


									public
									string GetDocumentMetaInfoRaw(WebUrl webUrl)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "getDocsMetaInfo:" + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name", "");

            methodData.Add("listHiddenDocs", "true");

            methodData.Add("listLinkInfo", "false");

            methodData.Add("validateWelcomeNames", "false");

            methodData.Add("url_list", "[" + webUrl.FileUrl + "]");


									return SendSimpleRequest(GetAuthorURL(webUrl), methodData);


									public
									DocumentInfo GetDocumentMetaInfo(WebUrl webUrl)


									string response = GetDocumentMetaInfoRaw(webUrl);


									DocumentInfo docInfo = ParseMetaInformationResponse(response);


									return docInfo;


									public
									string GetDocumentHash(WebUrl webUrl)


									string response = GetDocumentMetaInfoRaw(webUrl);


									return HashUtil.GetHash(response);


									public
									List<WebUrl> ListFolders(WebUrl webUrl)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "list documents:" + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name", "/");

            methodData.Add("listHiddenDocs", "true");

            methodData.Add("listExplorerDocs", "false");

            methodData.Add("listRecurse", "false");

            methodData.Add("listFiles", "false");

            methodData.Add("listFolders", "true");

            methodData.Add("listLinkInfo", "true");

            methodData.Add("listIncludeParent", "false");

            methodData.Add("listDerived", "false");

            methodData.Add("listBorders", "false");

            methodData.Add("listChildWebs", "false");

            methodData.Add("initialUrl", webUrl.FileUrl);


									string response = SendSimpleRequest(GetAuthorURL(webUrl), methodData);


									return ParseFileList(webUrl.SiteUrl, response, "url");


									public
									string ListWebs(WebUrl webUrl)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "get manifest:" + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name", "/");

            methodData.Add("options", "structure,files,userlists,list_data,globallists,subscriptions, discussions,userinfo,webparts,security,nontemplatizable_data");

//            methodData.Add("options", "[structure]");


									return SendSimpleRequest(GetAuthorURL(webUrl), methodData);

//            return ParseWebList(webUrl.SiteUrl, response, "url");


									public
									List<WebUrl> ListDocuments(WebUrl webUrl, bool recursive)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "list documents:" + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name", "/");

            methodData.Add("listHiddenDocs", "true");

            methodData.Add("listExplorerDocs", "false");

            methodData.Add("listRecurse", recursive ? "true" : "false");

            methodData.Add("listFiles", "true");

            methodData.Add("listFolders", "false");

            methodData.Add("listLinkInfo", "false");

            methodData.Add("listIncludeParent", "false");

            methodData.Add("listDerived", "false");

            methodData.Add("listBorders", "false");

            methodData.Add("listChildWebs", "true");

            methodData.Add("initialUrl", webUrl.FileUrl);


									string response = SendSimpleRequest(GetAuthorURL(webUrl), methodData);


									return ParseFileList(webUrl.SiteUrl, response, "document_name");


									private
									static
									List<WebUrl> ParseFileList(string siteUrl, string responseData, string attributeName)


									Regex fileMatchRegEx = new
									Regex(@"\<li\>" + attributeName + @"=(?<name>.*?)\n\<li\>", RegexOptions.Compiled | RegexOptions.Singleline);


									List<WebUrl> aRet = new
									List<WebUrl>();


									MatchCollection fileInfoMatches = fileMatchRegEx.Matches(responseData);


									foreach (Match m in fileInfoMatches)


									string fileUrl = HttpUtility.UrlDecode(DecodeString(m.Groups["name"].Value));

                aRet.Add(new
									WebUrl { SiteUrl = siteUrl , FileUrl = fileUrl});


									return aRet;


									private
									static
									string DecodeString(string source)


									if (!string.IsNullOrEmpty(source))


									Regex rg = new
									Regex("&#([0-9]{1,3});&#([0-9]{1,3});");


									foreach (Match match in rg.Matches(source))


									byte[] bytes = new[] { byte.Parse(match.Groups[1].Value), byte.Parse(match.Groups[2].Value) };

                    source = source.Replace(match.Value, Encoding.UTF8.GetString(bytes));

                source = HttpUtility.HtmlDecode(source);


									return source;


									public
									void CreateDirectory(WebUrl webUrl)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "create url-directories:" + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name", "/");

            methodData.Add("urldirs", "[[url=" + webUrl.FileUrl + "]]");


									string response = SendSimpleRequest(GetAuthorURL(webUrl), methodData);

            CheckForSuccessMessage(response);


									public
									string GetServerExtensionsVersion(WebUrl siteUrl)


									if (null == serverExtensionsVersion)


									NameValueCollection methodData = new
									NameValueCollection();

                methodData.Add("method", "server version:" + defaultServerVersion);

                methodData.Add("service_name", "/");


									string responseData = SendSimpleRequest(GetAuthorURL(siteUrl), methodData);

                serverExtensionsVersion = ExtractServerExtensionsVersion(responseData);


									return serverExtensionsVersion;


									public
									void CheckInDocument(WebUrl webUrl, string comment)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "checkin document: " + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name", "/");

            methodData.Add("document_name", webUrl.FileUrl);

            methodData.Add("comment", comment);

            methodData.Add("keep_checked_out", "false");

            SendSimpleRequest(GetAuthorURL(webUrl), methodData);


									public
									void CheckOutDocument(WebUrl webUrl)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "checkout document: " + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name", "/");

            methodData.Add("document_name", webUrl.FileUrl);

            methodData.Add("force", "0");

            methodData.Add("timeout", "0");

            SendSimpleRequest(GetAuthorURL(webUrl), methodData);


									public
									void UnCheckOutDocument(WebUrl webUrl)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "uncheckout document: " + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name","/");

            methodData.Add("document_name", webUrl.FileUrl );

            methodData.Add("force", "false");

            SendSimpleRequest(GetAuthorURL(webUrl), methodData);


									public
									void PutDocument(WebUrl webUrl, Stream file)

            PutDocument(webUrl, file, null);


									public
									void PutDocument(WebUrl webUrl, Stream file, DocumentPropertyCollection properties)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "put document:" + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name", "");

            methodData.Add("put_option", "overwrite,createdir,migrationsemantics");

            methodData.Add("keep_checked_out", "false");


									using (Stream responseStream =

                StartWebRequest(

                    GetAuthorURL(webUrl),

                    reqStream => WriteDocumentData(reqStream, webUrl.FileUrl, file, properties, methodData)


									string response = GetResponseString(responseStream);

                CheckForInternalErrorMessage(response);

                CheckForSuccessMessage(response);


									public
									void SetDocumentMetaInfo(WebUrl webUrl, DocumentInfo docInfo)


									NameValueCollection methodData = new
									NameValueCollection();

            methodData.Add("method", "setDocsMetaInfo:" + GetServerExtensionsVersion(webUrl));

            methodData.Add("service_name", "");

            methodData.Add("listHiddenDocs", "true");

            methodData.Add("listLinkInfo", "true");

            methodData.Add("url_list", "[" + webUrl.FileUrl + "]");

            methodData.Add("metaInfoList", "[" + docInfo.GetMetaInfoList(false) + "]");


									string responseData = SendSimpleRequest(GetAuthorURL(webUrl), methodData);


									if (!SetMetaDataResponseSuccess(responseData))


									throw
									new
									FrontPageRPCException("SetDocumentMetaInfo failed", webUrl.FileUrl);


									private
									static
									bool SetMetaDataResponseSuccess(string responseString)


									return responseString.IndexOf("method") > -1 && -1 == responseString.IndexOf("failedUrls");


									private
									static
									void AddCollectionData(TextWriter tw, NameValueCollection data)


									string separator = string.Empty;


									foreach(string key in data)

                tw.Write(separator);

                tw.Write("{0}={1}", key, HttpUtility.UrlEncode(data[key]));

                separator = "&";


									private
									static
									void CheckForInternalErrorMessage(string response)


									string message = DecodeString(GetReturnValue(response, "msg"));


									if (!string.IsNullOrEmpty(message))


									throw
									new
									FrontPageRPCException(message);


									private
									static
									void CheckForSuccessMessage(string response)


									string message = GetReturnValue(response, "message");


									if (null == message || !message.StartsWith("successfully"))


									throw
									new
									FrontPageRPCException("Failed to perform operation.");


									/// <summary>


									/// Extract the &lt;html&gt;&lt;/html&gt; preamble in the response stream.


									/// </summary>


									/// <remarks>


									/// We're using the ReadStreamLine method instead of wrapping the stream in a StreamReader because we only


									/// want to consume up to the end of the preamble; the remaining stream is other, potentially binary, data.


									/// </remarks>


									/// <param name="stream"></param>


									/// <returns></returns>


									private
									static
									string ExtractResponsePreamble(Stream stream)


									// locate <html></html> response and extract.


									StringBuilder responseData = new
									StringBuilder();


									string line = ReadStreamLine(stream);


									if (line.StartsWith("<html>"))

                responseData.Append(line);


									while (!line.EndsWith("</html>\n"))

                    line = ReadStreamLine(stream);

                    responseData.Append(line);


									return responseData.ToString();


									private
									static
									string ReadStreamLine(Stream stream)


									StringBuilder result = new
									StringBuilder();


									int bytesRead = 0;


									for (byte[] buffer = new
									byte[1]; stream.Read(buffer, 0, 1) > 0; )

                bytesRead++;

                result.Append((char)buffer[0]);


									if (buffer[0] == '\n')


									break;


									if (bytesRead == 0)


									throw
									new
									FrontPageRPCException("unexpected end of response");


									return result.ToString();


									private
									static
									string GetResponseString(Stream responseStream)


									StreamReader sr = new
									StreamReader(responseStream, Encoding.UTF8);


									return sr.ReadToEnd();


									private
									static
									string GetAuthorURL(WebUrl url)


									return url.SiteUrl + STR_AUTHOR_DLL_PATH;


									private
									static
									string GetVtiRPC(string url)


									return url + STR_VTI_RPC_PATH;


									private
									static
									string GetReturnValue(string response, string key)

            key = key.TrimEnd('=') + "=";


									int startPos = response.IndexOf(key);


									if (-1 == startPos)


									return
									null;

            startPos += key.Length;


									int endPos = response.IndexOf("\n", startPos);


									return response.Substring(startPos, endPos - startPos);


									public
									static
									DocumentInfo ParseMetaInformationResponse(string responseData)


									Regex proprtyInfoRegEx = new
									Regex(@"\<li\>(?<propName>.*?)\n\<li\>(?<propType>.*?)\|(?<propValue>.*?)\n", RegexOptions.Compiled | RegexOptions.Multiline);


									Regex metaInfoMatchRegEx = new
									Regex(@"\<li\>meta_info=\n\<ul\>\n(?<metaInfo>.*?)\<\/ul\>", RegexOptions.Compiled | RegexOptions.Singleline);


									Regex nameAndTypeRegeEx = new
									Regex(@"\<li\>(?<type>(document_name|url)?)=(?<name>.*?)\n", RegexOptions.Compiled | RegexOptions.Multiline);


									DocumentInfo docInfo = new
									DocumentInfo();


									Match nameAndType = nameAndTypeRegeEx.Match(responseData);


									Match metaInfoMatch = metaInfoMatchRegEx.Match(responseData);


									if (metaInfoMatch.Success && nameAndType.Success)

                docInfo.IsFolder = nameAndType.Groups["type"].Value == "url";

                docInfo.DestinationFileName = nameAndType.Groups["name"].Value;


									MatchCollection propMatches = proprtyInfoRegEx.Matches(metaInfoMatch.Value);


									foreach(Match propMatch in propMatches)


									DocumentProperty prop = new
									DocumentProperty(

                        propMatch.Groups["propName"].Value,

                        propMatch.Groups["propType"].Value,

                        HttpUtility.UrlDecode(DecodeString(propMatch.Groups["propValue"].Value))

);

                    docInfo.Properties.Add(prop);


									return docInfo;


									private
									Stream StartWebRequest(string url, Action<Stream> writeData)


									//Debug.WriteLine("URL: " + url);


									HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);

            request.Credentials = credentials;

            request.Method = "POST";

            request.KeepAlive = true;

            request.PreAuthenticate = true;

            request.ContentType = "application/x-www-form-urlencoded";

            request.Headers.Add("X-Vermeer-Content-Type", "application/x-www-form-urlencoded");


									using (Stream reqStream = request.GetRequestStream())

                writeData(reqStream);

                reqStream.Flush();


									WebResponse response = request.GetResponse();


									return response.GetResponseStream();


									private
									Stream StartWebRequest(string url, NameValueCollection methodData)


									return StartWebRequest(url, reqStream =>


									StreamWriter sw = new
									StreamWriter(reqStream);

                                                AddCollectionData(sw, methodData);

                                                sw.Flush();

});


									private
									string SendSimpleRequest(string fullUrl, NameValueCollection methodData)


									using (Stream responseStream = StartWebRequest(fullUrl, methodData))


									string response = GetResponseString(responseStream);

                CheckForInternalErrorMessage(response);


									return response;


									private
									static
									void WriteDocumentData(Stream stream, string destinationFileName, Stream file, DocumentPropertyCollection properties, NameValueCollection methodData)


									StreamWriter sw = new
									StreamWriter(stream);


									WindowsIdentity currentUser = WindowsIdentity.GetCurrent();


									if (null == currentUser)


									throw
									new
									FrontPageRPCException("unable to get current user from context");


									DocumentInfo docInfo = new
									DocumentInfo

                                           ModifiedBy = currentUser.Name,

                                           ModifiedDate = DateTime.Now.ToUniversalTime(),

                                           DestinationFileName = destinationFileName,

                                           Title = Path.GetFileName(destinationFileName)

};


									if (null != properties)

                docInfo.Properties.Add(properties);

            AddCollectionData(sw, methodData);

            docInfo.WriteDocumentData(sw);

            sw.Flush();

            file.CopyTo(stream);

            stream.Flush();


									//Helper method for GetServerExtensionsVersion()


									//The response from the server is in the format :


									//<html><head><title>vermeer RPC packet</title></head>\n<body>\n


									//<p>method=server version:6.0.0.0\n


									//<p>server version=\n<ul>\n


									//<li>major ver=6\n <li>minor ver=0\n<li>phase ver=2\n<li>ver incr=5528\n


									//</ul>\n<p>source control=1\n


									//</body>\n</html>\n


									private
									static
									string ExtractServerExtensionsVersion(string response)


									int index = 0;


									string majorVer = GetVersionComponent(response, "major ver", ref index);


									string minorVer = GetVersionComponent(response, "minor ver", ref index);


									string phaseVer = GetVersionComponent(response, "phase ver", ref index);


									string verIncr = GetVersionComponent(response, "ver incr", ref index);


									return string.Format("{0}.{1}.{2}.{3}", majorVer, minorVer, phaseVer, verIncr);


									private
									static
									string GetVersionComponent(string text, string part, ref
									int index)

            index = text.IndexOf(part, index);


									if (-1 == index)


									throw
									new
									FrontPageRPCException("Could not retrieve the server extension version");


									int startIndex = index + part.Length + 1;


									int endIndex = text.IndexOf("<", index);


									return text.Substring(startIndex, endIndex - startIndex).Trim();

MSDN上的参考在这里：

http://msdn.microsoft.com/en-us/library/ms442469.aspx

或者在MSDN上搜索关键字：Remote Procedure Call Protocol

本文链接

dotNet中的多线程

2012-02-02T06:11:00Z

基本原理来自这篇msdn上的文章：
http://msdn.microsoft.com/en-us/library/ee789351.aspx

具体步骤如下：

新建一个类LimitedConcurrencyLevelTaskScheduler

/// <summary>
/// Provides a task scheduler that ensures a maximum concurrency level while
/// running on top of the ThreadPool.
/// </summary>
public class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
{
/// <summary>Whether the current thread is processing work items.</summary>
[ThreadStatic]
private static bool _currentThreadIsProcessingItems;
/// <summary>The list of tasks to be executed.</summary>
private readonly LinkedList<Task> _tasks = new LinkedList<Task>(); // protected by lock(_tasks)
/// <summary>The maximum concurrency level allowed by this scheduler.</summary>
private readonly int _maxDegreeOfParallelism;
/// <summary>Whether the scheduler is currently processing work items.</summary>
private int _delegatesQueuedOrRunning = 0; // protected by lock(_tasks)
/// <summary>
/// Initializes an instance of the LimitedConcurrencyLevelTaskScheduler class with the
/// specified degree of parallelism.
/// </summary>
/// <param name="maxDegreeOfParallelism">The maximum degree of parallelism provided by this scheduler.</param>
public LimitedConcurrencyLevelTaskScheduler(int maxDegreeOfParallelism)
{
if (maxDegreeOfParallelism < 1) throw new ArgumentOutOfRangeException("maxDegreeOfParallelism");
_maxDegreeOfParallelism = maxDegreeOfParallelism;
}
/// <summary>Queues a task to the scheduler.</summary>
/// <param name="task">The task to be queued.</param>
protected sealed override void QueueTask(Task task)
{
// Add the task to the list of tasks to be processed. If there aren't enough
// delegates currently queued or running to process tasks, schedule another.
lock (_tasks)
{
_tasks.AddLast(task);
if (_delegatesQueuedOrRunning < _maxDegreeOfParallelism)
{
++_delegatesQueuedOrRunning;
NotifyThreadPoolOfPendingWork();
}
}
}
/// <summary>
/// Informs the ThreadPool that there's work to be executed for this scheduler.
/// </summary>
private void NotifyThreadPoolOfPendingWork()
{
ThreadPool.UnsafeQueueUserWorkItem(_ =>
{
// Note that the current thread is now processing work items.
// This is necessary to enable inlining of tasks into this thread.
_currentThreadIsProcessingItems = true;
try
{
// Process all available items in the queue.
while (true)
{
Task item;
lock (_tasks)
{
// When there are no more items to be processed,
// note that we're done processing, and get out.
if (_tasks.Count == 0)
{
--_delegatesQueuedOrRunning;
break;
}
// Get the next item from the queue
item = _tasks.First.Value;
_tasks.RemoveFirst();
}
// Execute the task we pulled out of the queue
base.TryExecuteTask(item);
}
}
// We're done processing items on the current thread
finally { _currentThreadIsProcessingItems = false; }
}, null);
}
/// <summary>Attempts to execute the specified task on the current thread.</summary>
/// <param name="task">The task to be executed.</param>
/// <param name="taskWasPreviouslyQueued"></param>
/// <returns>Whether the task could be executed on the current thread.</returns>
protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
{
// If this thread isn't already processing a task, we don't support inlining
if (!_currentThreadIsProcessingItems) return false;
// If the task was previously queued, remove it from the queue
if (taskWasPreviouslyQueued) TryDequeue(task);
// Try to run the task.
return base.TryExecuteTask(task);
}
/// <summary>Attempts to remove a previously scheduled task from the scheduler.</summary>
/// <param name="task">The task to be removed.</param>
/// <returns>Whether the task could be found and removed.</returns>
protected sealed override bool TryDequeue(Task task)
{
lock (_tasks) return _tasks.Remove(task);
}
/// <summary>Gets the maximum concurrency level supported by this scheduler.</summary>
public sealed override int MaximumConcurrencyLevel { get { return _maxDegreeOfParallelism; } }
/// <summary>Gets an enumerable of the tasks currently scheduled on this scheduler.</summary>
/// <returns>An enumerable of the tasks currently scheduled.</returns>
protected sealed override IEnumerable<Task> GetScheduledTasks()
{
bool lockTaken = false;
try
{
Monitor.TryEnter(_tasks, ref lockTaken);
if (lockTaken) return _tasks.ToArray();
else throw new NotSupportedException();
}
finally
{
if (lockTaken) Monitor.Exit(_tasks);
}
}
}
}

2．初始化TaskScheduler并指定线程数，初始化TaskFactory

            LimitedConcurrencyLevelTaskScheduler lcts = new LimitedConcurrencyLevelTaskScheduler(1);

            TaskFactory factory = new TaskFactory(lcts);

3．用如下的方法启动新线程：

            factory.StartNew(()=>

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

                        Console.Write("{0} on thread {1}", i, Thread.CurrentThread.ManagedThreadId);

);

4．还可以等待所有线程结束后做一些操作：

lcts.Wait();

Console.WriteLine("Execute success!");

本文链接

很好的一款监控web请求的工具，fiddler.

2012-02-02T05:54:00Z

所有请求一目了然，又细又准确。

下载地址：

http://www.fiddler2.com/fiddler2/

本文链接

Xpath特殊应用一例

2012-02-02T05:48:00Z

如下的xml代码：

<?xml version="1.0" encoding="utf-16" ?>

<Title>Events</Title>

<Description>Use the Events list to post information about meetings, deadlines, and other events related to this area.</Description>

<ZoneID>MiddleTopZone</ZoneID>

<FrameState>Normal</FrameState>

<DetailLink>/Lists/Events</DetailLink>

<HelpMode>Modeless</HelpMode>

<Dir>Default</Dir>

</WebPart>

想获取ZoneID里面的值，用如下的代码：

XmlDocument xmlDoc = new XmlDocument();

xmlDoc.LoadXml(strResult);

XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);

nsmgr.AddNamespace("WebPart", "http://schemas.microsoft.com/WebPart/v2");

XmlNode webPartZoneNode = xmlDoc.DocumentElement.SelectSingleNode("WebPart:ZoneID", nsmgr);

其中这两句是精髓：

nsmgr.AddNamespace("WebPart", "http://schemas.microsoft.com/WebPart/v2");

xmlDoc.DocumentElement.SelectSingleNode("WebPart:ZoneID", nsmgr);

本文链接

程序数据层研究(三) NHibernate中的API

2011-05-15T11:05:00Z

本篇文章介绍的是NHibernate的各种API及其作用。

下图描述了NHibernate的API在分层架构中的作用，下面将进行详细说明。

NHibernate的接口大致分为四类：
1. 被应用程序调用进行基本数据操作(增、删、改、查)的接口。这些接口是应用程序的业务逻辑层和控制层与NHibernate的主要交互点。ISession, ITransaction, IQuery和ICriteria属于此类。
2. 被应用程序用来配置NHibernate的接口。Configuration就属此类。
3. 回调接口。应用程序用回调接口来响应NHibernate中触发的事件。这类接口包括Interceptor, ILifecycle和IValidatable等。
4. 用于扩展NHibernate的强大映射功能的接口。这类接口通常被应用程序的基础架构来实现。IUserType, ICompositeUserType, 和IIdentifierGenerator属于此类。

NHibernate充分利用.NET中已有的API, 包括ADO.NET和与之对应的ITransaction API，由于ADO.NET提供了针对不同数据库的抽象功能，这就使NHibernate几乎支持所有的数据库。

下面详细介绍NHibernate中的核心接口：

一、核心接口：

1. ISession.

ISession是NHibernate应用程序的主要接口，它提供NHibernate用于查询，更新，存储和删除对象的方法。ISession是轻量级的对象，易于创建和销毁。这一点很重要，因为在NHibernate应用程序中随时都可能需要创建session, 也许每一次页面请求都需要。需要注意的是，NHibernate session不是线程安全的，所以在设计的时候只能同时被一个线程使用。
NHibernate中session的含义介于传统的connection和transaction之间，可以把它看做与一个工作单元相关的对象的缓存或集合，NHibernate能够检测到这个工作单元中对象的变化。有时，Isession也被称作永久化管理器，因为它也是用于永久化操作的一个接口，比如存取对象。需要注意的是，NHibernate中的session和ASP.NET中的session没有任何关系.

2. ISessionFactory.
应用程序从ISessionFactory中获取ISession, ISessionFactory不是轻量级的对象，它被用来在多个应用程序线程中共享。通常整个应用程序中只有一个ISessionFactory的实例, 比如可以在应用程序初始化的时候创建。但是如果你的应用程序需要使用NHibernate访问多个数据库，就需要为每一个数据库创建一个ISessionFactory的实例。
ISessionFactory缓存了NHibernate运行过程中创建的SQL语句和其他的映射数据，它还可以放置一个工作单元中读取并且下一次工作单元或者session中可能用到的数据。ISessionFactory也可以用来配置类和集合的映射来使用二级缓存。

3. Configuration接口。
Configuration类是用来配置NHibernate的。应用程序用Configuration的实例在ISessionFactory创建前配置映射文件的位置以及设置NHibernate特定的属性。
虽然Configuration类在整个NHibernate应用程序中只占很小的一部分，但是它是我们开始用NHibernate时用到的第一个对象。

4. ITransaction接口。
这是一个可选接口，NHibernate应用程序可以不使用这个接口，而自己在基础架构代码中管理事务。NHibernate transaction从底层的事务（比如ADO.NET Transaction或者其他的Transaction）中抽象出来应用程序代码，这样应用程序代码就可以通过一系列连贯的客户端API来控制事务的边界，从而使NHibernate应用程序可以在不同的执行环境和容易中实现可移植性。

5. IQuery和ICriteria接口。
IQuery接口提供了强大的数据库查询能力，同时可以控制查询如何执行，是NHibernate获取数据的基本接口。查询写成HQL或者数据库原始的SQL语句。IQuery是轻量级的，只能在创建它的ISession内使用。它的作用是：绑定参数，限定查询返回的结果条数，然后执行查询。
ICriteria接口是一个与IQuery类似的接口，可以用来创建和执行面向对象的条件查询。

二、回调接口。

当一个对象发生一个事件(比如这个对象被加载、存储和删除)时，回调接口可以让应用程序收到一个通知。NHibernate应用程序并不需要实现这些事件，但是在执行一些通用的任务的时候它们很有用，比如创建审核记录的时候。

ILifeCycle和IValidatable接口让一个永久化对象能够响应与它的永久化生命周期相关的事件。永久化生命周期包含在一个对象的CRUD操作中，也就是在这个对象被创建，提取，更新和删除的时候。
（注意，NHibernate开发团队当初受其他具有这些接口的ORM解决方案的影响，后来他们意识到让永久化类实现这些NHibernate特定的接口会影响可移植性，所以这两个接口已经过期。）

IInterceptor接口可以让应用程序处理事件，同时又不必实现NHibernate特定的接口。IInterceptor接口的实现以参数的形式传递给永久化实例。

三、类型。

NHibernate种类型的概念在架构中是一个基本而有强大的元素。.NET的Type对象将.NET中的类型映射到数据库的列类型（一个类型可能扩展到多个数据表列）。所有永久化类的永久化属性，包括关联在内，都有对应的NHibernate类型。这种设计让NHibernate具有很强的灵活性和可扩展性，因为每一种关系型数据库都有一套NHibernate类型对应。
NHibernate包含了丰富的类型，涵盖了.NET基础类和很多CLR的类，包括DateTime, System.Enum, byte[], 和Serializable 类对应的类型。
NHibernate还支持用户自定义的类型。IUserType, ICompositeUserType和IParameterizedType这些接口就是用来给我们创建自己的类型用的，我们也可以用IUserCollectionType创建自己的集合类。NHibernate的这个特性，可以让我们很方便而简洁的处理应用程序中用到的类，比如Address,Name和MoneyAccount。自定义类型是NHibernate的一个核心属性，NHibernate团队鼓励我们尽量多并且有创造性的使用它。

四、扩展接口

NHibernate提供的大部分功能都是可配置的，这就允许我们在一些内置策略之间进行选择。当内置的策略足以满足我们的需要时，NHibernate还允许我们通过实现一些接口来插入我们自己的功能实现。插入点包括：
1. 主键的生成(IIdentifierGenerator接口)
2. SQL语言的支持（Dialect抽象类）
3. 缓存策略（ICache和ICacheProvider接口）。
4. ADO.NET连接管理(IConnectionProvider接口)。
5. 事务管理(ITransactionFactory和ITransaction接口)。
6. ORM策略（IClassPersister接口层级）
7. 属性访问策略(IPropertyAccessor接口)。
8. 代理创建(IProxyFactory接口)。
对于上述接口，NHibernate已经带了至少一种实现，所以，如果我们想扩展这些内置的功能，并不需要从头开始。

本文链接