雪狼领地 - DotNet框架

C#IO文件读写和流

329084470@qq.com() — Wed, 02 Mar 2011 16:18:04 GMT

一流的概念
在.NET中Stream 是所有流的抽象基类。流是字节序列的抽象概念，或者说是计算机在处理文件或数据时产生的二进制序列。例如文件、输入/输出设备、内部进程通信管道或者 TCP/IP 套接字。Stream 类及其派生类提供这些不同类型的输入和输出的一般视图，使程序员不必了解操作系统和基础设备的具体细节。简单的说流提供了不同介质之间的数据交互功能。

在.NET中常用的流有BufferedStream 、FileStream、MemoryStream

和NetworkStream，他们都是位于System.IO和System.Net命名空间下。流涉及三个基本操作：读取，写入和查找。根据基础数据源或储存库，流可能只支持这些功能中的一部分。有些流实现执行基础数据的本地缓冲以提高性能。对于这样的流，Flush 方法可用于清除所有内部缓冲区并确保将所有数据写入基础数据源或储存库。

二文件读写
对于文件的读写，实际是把硬盘中的数据读入内存和把内存的数据写入硬盘，他们数据之间的交换就是通过流来完成的。在.NET中这个功能是由FileStream类完成的。他提供的Write和Read方法可以对文件进行读写操作。

1：FileStream读写文件
使用 FileStream 类对文件系统上的文件进行读取、写入、打开和关闭操作，并对其他与文件相关的操作系统句柄进行操作，如管道、标准输入和标准输出。读写操作可以指定为同步或异步操作。FileStream 对输入输出进行缓冲，从而提高性能。

view plaincopy to clipboardprint?
static void Main(string[] args)
{
try
{
      FileStream fs = new FileStream(@"c:\text.txt", FileMode.Create);
      string message = "This is example for filestream";
      byte[] writeMesaage = Encoding.UTF8.GetBytes(message);
      fs.Write(writeMesaage, 0, writeMesaage.Length);
}
catch (Exception ex)
{
      Console.WriteLine(ex.Message);
}
finally
{
      Console.ReadKey();
}
}
static void Main(string[] args)
{
try
{
      FileStream fs = new FileStream(@"c:\text.txt", FileMode.Create);
      string message = "This is example for filestream";
      byte[] writeMesaage = Encoding.UTF8.GetBytes(message);
      fs.Write(writeMesaage, 0, writeMesaage.Length);
}
catch (Exception ex)
{
      Console.WriteLine(ex.Message);
}
finally
{
      Console.ReadKey();
}
}

上面是一个简单的例子，把一条字符串写入到文件中。首先建立一个FileStream对象，指定文件和读写方式（具体读写方式和权限可以参加MSDN）。接下来把要写入的字符串以一定的编码格式存入一个字节数组中，然后调用Writer方法写入文件。运行程序，当程序执行到Console.ReadKey方法时去查看文件发现文件中内容是空的。也就是说调用Writer方法后内容并没有被写入到文件中。

这里就要谈到流中的缓冲区的问题了。缓冲区是为了提高I/O效率而设置的，我们知道读写的I/O操作是很费时的，如果每一个字节都马上写入到文件中整个过程就会很慢，所以设置缓冲区，写把要写入的内容写入到缓冲区中，然后在一次性写入到文件中，来提高写入的效率和速度。而Write方法实际上只是把数据写入到流的缓冲区中，而不是真正的写入到文件中。所以调用Writer方法并不能完成文件的写入。于是FileStream对象提供了一个把缓冲区写入文件的方法，那就是Flush方法。

Flush：清除该流的所有缓冲区会使得所有缓冲的数据都将写入到文件系统。这是MSDN给出的定义，可以看到，只有调用了Flush方法后数据才会被真正的写入到文件中。所以这里就又另外一个问题，那就是可能存在写入失败。比如上面在Writer方法结束后发生了异常，那么数据就无法写入到文件中了。所以我们在调用Writer方法后可以显式的调用Flush方法来把数据写入到文件中。但是上面的方法结束后又会发现数据被写入了。其实这是因为在程序结束时，销毁FileStream对象时，系统自动调用了Flush方法来保证内容被写入到文件中。而在FileStream对象中，很多地方都调用了这个方法，比如Close方法和Dispose方法。所以在程序中，调用这2个方法销毁对象时也会把数据从缓冲区写入文件。所以使用FileStream对象Writer方法后只要不抛出异常，缓冲区数据总会被写入文件（当然也可能因为磁盘已满而在写入是抛出异常）。但是我们最好还是显示的调用Close方法或使用using块关闭对象，使数据写入。或是调用Flush方法。Flush方法内部调用API的internal static extern unsafe int WriteFile方法实现文件写入。

对于读取文件内容也是类似的，要先把数据读取到字节数组中。而且还提供了BeginRead和BeginWrite方法进行异步读写操作。

2 StreamWriter写文件
上面的FileStream操作文件读写，每次都需要使用字节数组，因为FileStream操作对象是字节。而.NET提供了StreamWriter和StreamReader对象来对流进行读写操作。

他的构造函数可以接受一个Stream对象。从而对流进行操作。他们的内部有个一Stream对象来维护传入的各种流对象。并且也提供了Write和Read方法。实际上这2个类是对流读写的的一个包装，方便我们使用。当我们传一个流对象时，调用读写方法是，实际调用该对象自己重写的方法。而当我们在构造函数中传入的是文件路径时，他就成为了对文件读写的操作。因为他在内部构建了一个FileStream对象，并交给内部的Stream对象维护。

view plaincopy to clipboardprint?
public StreamWriter(string path) : this(path, false, UTF8NoBOM, 0x400)
{
}


public StreamWriter(string path, bool append, Encoding encoding, int bufferSize) : base(null)
{
if ((path == null) || (encoding == null))
{
      throw new ArgumentNullException((path == null) ? "path" : "encoding");
}
if (bufferSize <= 0)
{
      throw new ArgumentOutOfRangeException("bufferSize", Environment.GetResourceString("ArgumentOutOfRange_NeedPosNum"));
}
Stream stream = CreateFile(path, append);
this.Init(stream, encoding, bufferSize);
}


private static Stream CreateFile(string path, bool append)
{
return new FileStream(path, append ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.Read, 0x1000, FileOptions.SequentialScan);
}
public StreamWriter(string path) : this(path, false, UTF8NoBOM, 0x400)
{
}

public StreamWriter(string path, bool append, Encoding encoding, int bufferSize) : base(null)
{
if ((path == null) || (encoding == null))
{
      throw new ArgumentNullException((path == null) ? "path" : "encoding");
}
if (bufferSize <= 0)
{
      throw new ArgumentOutOfRangeException("bufferSize", Environment.GetResourceString("ArgumentOutOfRange_NeedPosNum"));
}
Stream stream = CreateFile(path, append);
this.Init(stream, encoding, bufferSize);
}

private static Stream CreateFile(string path, bool append)
{
return new FileStream(path, append ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.Read, 0x1000, FileOptions.SequentialScan);
}

通过上面的代码，可以看到我们使用 public StreamWriter(string path)构造方法和我们自己新建一个FileStream对象传递给StreamWriter(Stream)构造方法是一样的。不同的是后者还可对其他继承与Stream的流进行操作。而且可以指定文件读取的方式和访问权限以及缓冲区大小。

view plaincopy to clipboardprint?
static void Main(string[] args)
{
try
{
      StreamWriter sw = new StreamWriter(@"c:\text.txt");
      sw.Write("This is StreamWriter");
}
catch (Exception ex)
{
      Console.WriteLine(ex.Message);
}
finally
{
      Console.ReadKey();
}
}
static void Main(string[] args)
{
try
{
      StreamWriter sw = new StreamWriter(@"c:\text.txt");
      sw.Write("This is StreamWriter");
}
catch (Exception ex)
{
      Console.WriteLine(ex.Message);
}
finally
{
      Console.ReadKey();
}
}

上面的代码是使用StreamWriter对文件进行写操作，当执行到ReadKey时，我们发现文件没有被写入，这个和FileStream是一样的，但是当程序执行完后我们发现，数据还是没有被写入。如果我们写入的数据量比较大时，数据也被写入到文件中，但是会发现写入的数据可能并不完整。因为只有当StreamWriter内部的缓冲区充满或调用Flush时，才会把数据写入Stream对象中。StreamWriter 未将最后 1 至 4 KB 数据写到文件。后面会具体解释。

MSDN中对此的解释是：

StreamWriter 在内部缓冲数据，这需要调用 Close 或 Flush 方法将缓冲数据写到基础数据存储区。如果没有适当地调用 Close 或 Flush，StreamWriter 实例中缓冲的数据可能不会按预期写出。

在StreamWriter中也有Flush方法，清理当前编写器的所有缓冲区，并使所有缓冲数据写入基础流。对于StreamWriter来说，也有自己的缓冲区，而不同的是StreamWriter缓冲区是char[]而不是byte[]。而StreamWriter的write方法只是把数据写入到自己的缓冲区中，所以我们必须条用Flush方法来写入到文件中，而Flush方法中则是先调用了FileStream的write方法把StreamWriter缓冲区的数据写入到FileStream的缓冲区中，最后在调用FileStream的Flush方法写入文件。

view plaincopy to clipboardprint?
//StreamWriter.write把数据写入StreamWriter缓冲区中
public override void Write(string value)
{
if (value != null)
{
      int length = value.Length;
      int sourceIndex = 0;
      while (length > 0)
      {
         if (this.charPos == this.charLen)
         {
            this.Flush(false, false);
         }
         int count = this.charLen - this.charPos;
         if (count > length)
         {
            count = length;
         }
         value.CopyTo(sourceIndex, this.charBuffer, this.charPos, count);
         this.charPos += count;
         sourceIndex += count;
         length -= count;
      }
      if (this.autoFlush)
      {
         this.Flush(true, false);
      }
}
}

//StreamWriter.Flush把StreamWriter缓冲区内容写入Stream的缓冲区
private void Flush(bool flushStream, bool flushEncoder)
{
if (this.stream == null)
{
      __Error.WriterClosed();
}
if (((this.charPos != 0) || flushStream) || flushEncoder)
{
      if (!this.haveWrittenPreamble)
      {
         this.haveWrittenPreamble = true;
         byte[] preamble = this.encoding.GetPreamble();
         if (preamble.Length > 0)
         {
            this.stream.Write(preamble, 0, preamble.Length);
         }
      }
      int count = this.encoder.GetBytes(this.charBuffer, 0, this.charPos, this.byteBuffer, 0, flushEncoder);
      this.charPos = 0;
      if (count > 0)
      {
         this.stream.Write(this.byteBuffer, 0, count);
      }
      if (flushStream)
      {
         this.stream.Flush();
      }
}
}
//StreamWriter.write把数据写入StreamWriter缓冲区中
public override void Write(string value)
{
if (value != null)
{
      int length = value.Length;
      int sourceIndex = 0;
      while (length > 0)
      {
         if (this.charPos == this.charLen)
         {
            this.Flush(false, false);
         }
         int count = this.charLen - this.charPos;
         if (count > length)
         {
            count = length;
         }
         value.CopyTo(sourceIndex, this.charBuffer, this.charPos, count);
         this.charPos += count;
         sourceIndex += count;
         length -= count;
      }
      if (this.autoFlush)
      {
         this.Flush(true, false);
      }
}
}

//StreamWriter.Flush把StreamWriter缓冲区内容写入Stream的缓冲区
private void Flush(bool flushStream, bool flushEncoder)
{
if (this.stream == null)
{
      __Error.WriterClosed();
}
if (((this.charPos != 0) || flushStream) || flushEncoder)
{
      if (!this.haveWrittenPreamble)
      {
         this.haveWrittenPreamble = true;
         byte[] preamble = this.encoding.GetPreamble();
         if (preamble.Length > 0)
         {
            this.stream.Write(preamble, 0, preamble.Length);
         }
      }
      int count = this.encoder.GetBytes(this.charBuffer, 0, this.charPos, this.byteBuffer, 0, flushEncoder);
      this.charPos = 0;
      if (count > 0)
      {
         this.stream.Write(this.byteBuffer, 0, count);
      }
      if (flushStream)
      {
         this.stream.Flush();
      }
}
}

通过上面的代码可以明白，真正完成写入文件的也是Flush方法，因为它的工作是调用了FileStream的write和flush方法。而在StreamWriter的Close和Dispose的方法中则是调用了StreamWriter的Flush方法写入文件，然后用FileStream.Close方法关闭流。

所以在关闭具有 StreamWriter 的实例的应用程序或任何代码块之前，确保调用 StreamWriter 的 Close 或 Flush。达到此目的的最佳机制之一是用 C# using 块创建该实例，这样将确保调用编写器的 Dispose 方法，从而正确关闭该实例。另外在StreamWriter中有一个AutoFlush属性，如果设置为True，则在调用writer方法后会自动调用Flush方法。

3 FileStream和StreamWriter的依赖关系
如果我们使用public StreamWriter(string path)构造方法不会存在这个问题，因为FileStrem对象是内部控制的，如果我们用StreamWriter(Stream)构造方法就可能存在一些问题。

view plaincopy to clipboardprint?
static void Main(string[] args)
{
FileStream fs = null；
      StreamWriter sw = null；
try
{
      fs = new FileStream(@"c:\text.txt", FileMode.Create);
      sw = new StreamWriter(fs);
      string message = "This is StreamWriter\r\n";
      for (int i = 0; i < 10; i++)
      {
         message += message;
      }
      sw.Write(message);
}
catch (Exception ex)
{
      Console.WriteLine(ex.Message);
}
finally
{
      fs.Close();
      sw.Close();
      Console.ReadKey();
}
}
static void Main(string[] args)
{
FileStream fs = null；
      StreamWriter sw = null；
try
{
      fs = new FileStream(@"c:\text.txt", FileMode.Create);
      sw = new StreamWriter(fs);
      string message = "This is StreamWriter\r\n";
      for (int i = 0; i < 10; i++)
      {
         message += message;
      }
      sw.Write(message);
}
catch (Exception ex)
{
      Console.WriteLine(ex.Message);
}
finally
{
      fs.Close();
      sw.Close();
      Console.ReadKey();
}
}

执行上面的代码的时候会出现Dispose异常，无法访问已经关闭的文件。这是因为我们先关闭了文件流，然后在关闭StreamWriter对象。而StreamWriter对象的Close方法实际是关闭当前的 StreamWriter 对象和基础流。也就是说我们只需调用这一个方法就可以了。而如果在数据写入前调用了FileStream的Close方法，那么数据最终是无法写入的，还会引发异常。所以在写入文件时，最好只调用StreamWriter对象的Close方法就行了。

上面说过了没有调用Close方法导致部分数据没有写入，这是因垃圾回收造成的。当我们调用完write方法后，没有调用close，系统发现StreamWriter和FileStream对象不可达，会对他们进行终结操作，但是终结的顺序是不确定的。如果先关闭了FileStream会出现数据无法写入。微软为了避免这种情况，就不让StreamWriter方法实现Finalize方法，这样，在程序结束时，没有执行StreamWriter的Finalize方法，也就无法把缓冲区的数据写入FileStream中。而FileStream内部实现了Finalize方法。这也就是为什么FileStream不关闭仍然可以把数据写入文件。所以在使用StreamWriter对象时不显调用Close方法时，缓冲区的数据一定会丢失。

而且WriterStream的内部缓冲区填满后会自动写入到Stream流中。所以当我们写入的数据很少时，不够填充满数据缓冲区，而且不关闭对象，必然无法写入文件。而当我们写大量数据时，一部分数据在缓冲区满的时候被写入了Stream中，当我们不关闭对象，直接结束程序时，Stream会执行Finalize方法，把数据写入文件，而StreamWriter没有此方法，而且默认的缓冲区大小为4K。如果此时缓冲区中还有数据必定无法被写入，而且大小是1-4K。

3 BinaryWriter
BinaryWriter对象也可以用写文件，以二进制形式将基元类型写入流，并支持用特定的编码写入字符串。与StreamWriter不同的是，他不存在缓冲区丢失的问题。因为他每次调用Write方法以后说首先把数据写入自己的char[]数组，然后转换为指定编码的Byte[]数组，最后调用Stream的Write方法写入到流的缓冲区。

BinaryWriter对象也有Flush方法，但是只是简单的调用了Stream的Flush方法，而他的Close和Dispose方法则是调用了Stream的Close方法。和上面一样 BinaryWriter对象也没有实现Finalize方法，但是因为他没有把数据放到自己的缓冲区，每次都是立即写入到流中。所以即便不调用Flush方法或是显式关闭对象，最后也会全部被写入到文件中，因为数据全部在FileStream的缓冲区中，而程序结束时Finalize方法会调用Flush把数据写入文件。

c#当前应用程序路径

329084470@qq.com() — Wed, 02 Mar 2011 04:20:34 GMT

应该算是出于对各种DOCK的烦躁（部分DOCK程序在启动程序时，会把当前路径指派为DOCK所在路径，当程序中使用相对路径时，路径对“相对”到DOCK的文件夹里），我在程序中大多使用绝对路径来定位文件方便后来者，在这里总结了下，也摘抄了点网上流传的以我的程序为例物理路径：

E:\c#学习\获取当前路径\获取当前路径\bin\Debug\获取当前路径.exeSystem.Environment.CurrentDirectory;
//很熟悉了,获取和设置当前目录（即该进程从中启动的目录）的完全限定路径。

//返回E:\c#学习\获取当前路径\获取当前路径\bin\Debug

System.AppDomain.CurrentDomain.BaseDirectory;

//我用的最多的方法，获取当前 Thread 的当前应用程序域的基目录，它由程序集冲突解决程序用来探测程序集。

//返回 E:\c#学习\获取当前路径\获取当前路径\bin\Debug\

System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;

//获取新的 Process 组件并将其与当前活动的进程关联的主模块的完整路径，包含文件名(进程名)。

//返回 E:\c#学习\获取当前路径\获取当前路径\bin\Debug\获取当前路径.exe

System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase;

//获取和设置包含该应用程序的目录的名称。

//返回 E:\c#学习\获取当前路径\获取当前路径\bin\Debug\

System.Windows.Forms.Application.StartupPath;

//获取启动了应用程序的可执行文件的路径，不包括可执行文件的名称。

//返回 E:\c#学习\获取当前路径\获取当前路径\bin\Debug

System.Windows.Forms.Application.ExecutablePath;

//获取启动了应用程序的可执行文件的路径，包括可执行文件的名称。

//返回 E:\c#学习\获取当前路径\获取当前路径\bin\Debug\获取当前路径.exe

System.IO.Directory.GetCurrentDirectory();

//获取应用程序的当前工作目录(不可靠)。

//返回 E:\c#学习\获取当前路径\获取当前路径\bin\Debug

//这个方法其实是我最早知道的，但是也是我用的最少的，总感觉基于IO的东西都不怎么可靠

//至于上面的“（不可靠）”不是我加的，是网上的大大们写的，我只是Copy过来了

//另外还有一个方法

this.GetType().Assembly.Location;

//获取当前进程的完整路径，包含文件名(进程名)。

//遗憾的静态方法无法使用

//返回 E:\c#学习\获取当前路径\获取当前路径\bin\Debug\获取当前路径.exe

.NET/C#中对对象集合进行查询的方法以及相关的 Predicate 及 Action 的用法

329084470@qq.com() — Sat, 26 Feb 2011 06:05:09 GMT

所谓的对对象集合进行查询的方法，就是指，如何从一个集合中找出符合条件的某些项来。这一次我没有用自定义对象集合，而是直接使用对象集合，是因为普通的对象集合，如int[], List<int>,这样的东西，也没有统一固定的查询方法，因为对于一个查询来讲，它的条件是多种多样的，所以是无法提供统一固定查询方法的。比如有时候想找出所有大于10的int,有时候又想找所有小于10的int。。。。。。。。。

所以要完成这样一个任务，传统的编程方式就是定义方法，其中建立循环，然后逐个遍历每一个元素，查看其是否符合条件，然后把符合条件的结果挑出来，放在一个返回值集合中，最后返回给调用者。这样的方法直接了当，清晰易懂。用了好多年了，但是写起来麻烦，简单点的都得个7，8行。于是.NET又进行了改进。

这是.NET2.0时代一种比较笨的方法：

代码1

 1using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5
 6 namespace SelectTest1
 7{
 8class Product
 9    {
10publicstring Name { get; privateset; }
11publicdecimal Price { get; privateset; }
12
13public Product(string name, decimal price)
14        {
15            Name = name;
16            Price = price;
17        }
18
19public Product() { }
20
21publicstatic List<Product> GetSampleProduct()
22        {
23returnnew List<Product>
24            {
25new Product{Name="Watch",Price=12345.56m},
26new Product{Name="Knife",Price=224.50m},
27new Product{Name="Rope",Price=12.50m},
28new Product{Name="ETorch",Price=5.5m}
29            };
30        }
31
32publicoverridestring ToString()
33        {
34returnstring.Format("{0} : {1}", Name, Price);
35        }
36    }
37
38class Program
39    {
40staticvoid Main(string[] args)
41        {
42            List<Product> ProductSample = Product.GetSampleProduct();
43foreach (Product tmp in ProductSample)
44            {
45                Console.WriteLine(tmp);
46            }
47
48            Console.WriteLine();
49
50            Predicate<Product> test =delegate(Product p) { return p.Price > 10m; };
51            List<Product> matches = ProductSample.FindAll(test);
52
53            Action<Product> print =delegate(Product p) { Console.WriteLine(p); };
54
55            matches.ForEach(print);
56        }
57    }
58}
59

关键代码是：

Predicate<Product> test = delegate(Product p) { return p.Price > 10m; };
List<Product> matches = ProductSample.FindAll(test);

Action<Product> print = delegate(Product p) { Console.WriteLine(p); };

matches.ForEach(print);

什么是Predicate,Action 呢？？？？？这两个东西我很陌生。查MSDN!

Predicate<T> 是一个委托，它代表了一个方法，它的定义是：

namespace System
{
　　// 摘要: 表示定义一组条件并确定指定对象是否符合这些条件的方法。
　　// 参数:
　　// obj: 要按照由此委托表示的方法中定义的条件进行比较的对象。
　　// 类型参数:
　　// T: 要比较的对象的类型。
　　// 返回结果:
　　// 如果 obj 符合由此委托表示的方法中定义的条件，则为 true；否则为 false。
publicdelegatebool Predicate<T>(T obj);
}

这个委托常被好多Array , List<T> 类的方法所使用，用来查找集合中的元素。

关于 Predicate,,跟 Action 的进一步使用，可以参考 Adil Akhter 的博文：Using Predicate & Action of .Net2.0 。我看的时候简单翻译了一下：

“自从我开始做软件开发以来，我就得一次又一次得面对这样的情况：不得不遍历整个集合然后对每个元素做一些处理，或者根据某一个逻辑规则来筛选出一些元素。一次从一次地写那些循环语句真是太讨厌了。

.NET 2.0 解决了这个问题，我们只需要告诉集合如何筛选，如何处理每个元素，然后它自己会处理重复的步骤。让我们来看一下System.Collections.Generic命名空间中的List<T>类，看看它提供了哪些支持：

有大量的针对查询，排序，筛选的支持方法。如果我们看一下我们经常说到的 FindAll 跟 ForEach :

public List<T> FindAll(Predicate<T> match);public void ForEach(Action<T> action);

会看到这儿的 Predicate 跟 Actor 是两个泛型委托，它们提供了一种方法，可以让我们灵活地对List中的每一个元素进行筛选或者执行某些处理。
让我们深入观察一下这两个委托：

Inside Predicate:

Predicate 是一个泛型委托，它利用了.NET 2.0提供的泛型特性。它的定义是：

delegate bool Predicate<T>(T obj)

如MSDN所定义, Predicate -

"represents a method that defines a set of criteria and determines whether the specific object meets this criteria."

简单地说，Predicate就是一个代表了接受一个T类型的参数，然后检查它是否满足某一规则然后返回 true 或者 false 的委托。示例如下：

在这个例子中，我们使用Predicate 来告诉集合如何筛选，然后集合会处理整个重复筛选的过程。

比如说，我们有一个 SprintBacklogItem 集合，想根据State==Closed 这一规则来进行筛选。我们就可以使用如下的一个方法：

　　　private bool HasStateClosed(SprintBacklogItem item) 
        { 
if (item.State == SprintBackLogStatesStrings.CLOSED) 
return true; 
return false; 
        }

这个方法简单地检查了是否SprintBacklogItem's state is closed，然后返回true/false。现在如果我们观察一下这个方法的定义，就能够确认可以使用Predicate 委托来代表这个方法。下面这行代码就用 FindAll( ) 方法筛选出了所以关闭了的SprintBacklogItems

List<SprintBacklogItem> closedItems= _SprintBackLogsItems.FindAll(HasStateClosed);

Inside Action:

类似于 Predicate,

"Action is also one kind of generic delegate which represents a method that take the object as input and perform some operation on that."

定义：

delegate void Action<T>(T obj);

从这个委托的定义来看，它可以代表一种接受一个T类型的参数，然后什么也不返回的方法。

在List<T>中，由Action委托所代表的方法接受一个输入 obj 对象，然后对它进行处理。

Example

在这个例子中，我们将使用Action 对List中的每一个元素进行一个定义好的操作（initializing ActualHour = 10）

1. Define the method that will be represented by Action -

　　　public void InitActualHour(SprintBacklogItem item) 
        { 
            item.ActualHour = 10; 
        }

2. Following line of code initialize all the elements' Actual hour to 10 of the List -

this.ForEach(InitActualHour);

是不是很COOL很便捷呀？为了不直接给Actor 以及 Predicate 定义方法，我们可以使用匿名方法处理委托。日后会讲到。今天先到这儿”

好了，Predicate 跟 Action 搞明白了，回到主题，接着看集合查询：

前面使用了这样的代码进行了筛选并输出结果，

Predicate<Product> test = delegate(Product p) { return p.Price > 10m; };
List<Product> matches = ProductSample.FindAll(test);

Action<Product> print = delegate(Product p) { Console.WriteLine(p); };

matches.ForEach(print);

其实这两句可以合并成一句：

ProductSample.FindAll(delegate (Product p){return p.Price>10m;}).ForEach(delegate (Product p){Console.WriteLine(p);});

是不是很简洁呀，呵呵。当然从来都是没有最XX，只有更XX，看下面的，LAMBDA出场！！！！！：

ProductSample.FindAll(p=> p.Price > 10m).ForEach(p=>Console.WriteLine(p));

爽吧。

爽的方法还不止一种，还可以这样爽：

            foreach(Product tmp in ProductSample.Where(p=>p.Price > 10m))
            {
                Console.WriteLine(tmp);
            }

注意这个针对List<T>的 Where() 方法，呀呀呀，，，还有上一节的 OrderBy() 真是把能一般情况都考虑到了。

但是，有些人觉得那么写还不够爽，在C# 3.0中就弄出了个LINQ。。。。。这个内容就多了。。。日后再说。。。

NET多线程同步方法详解(三)：读写锁（ReadWriteLock)

329084470@qq.com() — Wed, 09 Feb 2011 09:49:44 GMT

读写锁的出现主要是在很多情况下，我们读资源的操作要多于写资源的操作。但是如果每次只对资源赋予一个线程的访问权限显然是低效的，读写锁的优势是同时可以有多个线程对同一资源进行读操作。因此在读操作比写操作多很多，并且写操作的时间很短的情况下使用读写锁是比较有效率的。读写锁是一个非静态类所以你在使用前需要先声明一个读写锁对象：

static private ReaderWriterLock _rwlock = new ReaderWriterLock(); 读写锁是通过调用AcquireReaderLock，ReleaseReaderLock，AcquireWriterLock，ReleaseWriterLock来完成读锁和写锁控制的

        static public void ReaderThread(int thrdId)
        {
            try
            { // 请求读锁，如果100ms超时退出
                _rwlock.AcquireReaderLock(10);
                try
                {
                    int inx = _rand.Next(_list.Count);
                    if (inx < _list.Count)
                        Console.WriteLine("{0}thread {1}", thrdId, _list[inx]);
                }
                finally
                {
                    _rwlock.ReleaseReaderLock();
                }
            }
            catch (ApplicationException) // 如果请求读锁失败
            {
                Console.WriteLine("{0}thread get reader lock out time!", thrdId);
            }
        }
        static public void WriterThread()
        {
            try
            {
                // 请求写锁
                _rwlock.AcquireWriterLock(100);
                try
                {
                    string val = _rand.Next(200).ToString();
                    _list.Add(val); // 写入资源
                    Console.WriteLine("writer thread has written {0}", val);
                }
                finally
                { // 释放写锁
                    _rwlock.ReleaseWriterLock();
                }
            }
            catch (ApplicationException)
            {
                Console.WriteLine("Get writer thread lock out time!");
            }
        }     如果你想在读的时候插入写操作请使用UpgradeToWriterLock和DowngradeFromWriterLock来进行操作，而不是释放读锁。

        static private void UpgradeAndDowngrade(int thrdId)
        {
            try
            {
                _rwlock.AcquireReaderLock(10);
                try
                {
                    try
                    {
                        // 提升读锁到写锁
                        LockCookie lc = _rwlock.UpgradeToWriterLock(100);
                        try
                        {
                            string val = _rand.Next(500).ToString();
                            _list.Add(val); Console.WriteLine("Upgrade Thread{0} add {1}", thrdId, val);
                        }
                        finally
                        { // 下降写锁
                            _rwlock.DowngradeFromWriterLock(ref lc);
                        }
                    }
                    catch (ApplicationException)
                    {
                        Console.WriteLine("{0}thread upgrade reader lock failed!", thrdId);
                    }
                }
                finally
                {
                    // 释放原来的读锁
                    _rwlock.ReleaseReaderLock();
                }
            }
            catch (ApplicationException)
            {
                Console.WriteLine("{0}thread get reader lock out time!", thrdId);
            }
        }     这里有一点要注意的就是读锁和写锁的超时等待时间间隔的设置。通常情况下设置写锁的等待超时要比读锁的长，否则会经常发生写锁等待失败的情况。

NET多线程同步方法详解(二)：互斥锁(lock)

329084470@qq.com() — Wed, 09 Feb 2011 09:48:47 GMT

lock关键字是实现线程同步的比较简单的方式，其实就是设置一个临界区。在lock之后的{...}区块为一个临界区，当进入临界区时加互斥锁，离开临界区时释放互斥锁。MSDN对lock关键字的描述是: lock 关键字可将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。
具体例子如下:

        static public void ThreadFunc(object name)
        {
            string str = name as string;
            Random rand = new Random();
            int count = rand.Next(100, 200);
            for (int i = 0; i < count; i++)
            {
                lock (NumList)
                {
                    NumList.Add(i);
                    Console.WriteLine("{0} {1}", str, i);
                }
            }
        }   对lock的使用有几点建议：对实例锁定lock(this),对静态变量锁定lock(typeof(val))。lock的对象访问权限最好是private，否则会出现失去访问控制现象。

NET多线程同步方法详解(一)：自由锁(InterLocked)

329084470@qq.com() — Wed, 09 Feb 2011 07:27:47 GMT

本文主要描述在C#中线程同步的方法。线程的基本概念网上资料也很多就不再赘述了。直接接入主题，在多线程开发的应用中，线程同步是不可避免的。在.Net框架中，实现线程同步主要通过以下的几种方式来实现，在MSDN的线程指南中已经讲了几种，本文结合作者实际中用到的方式一起说明一下。

1. 维护自由锁(InterLocked)实现同步
2. 监视器（Monitor）和互斥锁（lock）
3. 读写锁（ReadWriteLock)
4. 系统内核对象
1) 互斥(Mutex), 信号量(Semaphore), 事件(AutoResetEvent/ManualResetEvent)
2) 线程池

除了以上的这些对象之外实现线程同步的还可以使用Thread.Join方法。这种方法比较简单，当你在第一个线程运行时想等待第二个线程执行结果，那么你可以让第二个线程Join进来就可以了。

自由锁(InterLocked)

对一个32位的整型数进行递增和递减操作来实现锁，有人会问为什么不用++或--来操作。因为在多线程中对锁进行操作必须是原子的，而++和--不具备这个能力。InterLocked类还提供了两个另外的函数Exchange, CompareExchange用于实现交换和比较交换。Exchange操作会将新值设置到变量中并返回变量的原来值: int oVal = InterLocked.Exchange(ref val, 1)。

监视器(Monitor)

在MSDN中对Monitor的描述是: Monitor 类通过向单个线程授予对象锁来控制对对象的访问。

Monitor类是一个静态类因此你不能通过实例化来得到类的对象。Monitor的成员可以查看MSDN，基本上Monitor的效果和lock是一样的，通过加锁操作Enter设置临界区，完成操作后使用Exit操作来释放对象锁。不过相对来说Monitor的功能更强，Moniter可以进行测试锁的状态，因此你可以控制对临界区的访问选择，等待or离开, 而且Monitor还可以在释放锁之前通知指定的对象，更重要的是使用Monitor可以跨越方法来操作。Monitor提供的方法很少就只有获取锁的方法Enter, TryEnter；释放锁的方法Wait, Exit；还有消息通知方法Pulse, PulseAll。经典的Monitor操作是这样的：

        // 通监视器来创建临界区
        static public void DelUser(string name)
        {
            try
            {
                // 等待线程进入
                Monitor.Enter(Names);
                Names.Remove(name);
                Console.WriteLine("Del: {0}", Names.Count);
                Monitor.Pulse(Names);
            }
            finally
            {
                // 释放对象锁
                Monitor.Exit(Names);
            }
        }
    }   其中Names是一个List<string>, 这里有一个小技巧，如果你想声明整个方法为线程同步可以使用方法属性：

        // 通过属性设置整个方法为临界区
        [MethodImpl(MethodImplOptions.Synchronized)]
        static public void AddUser(string name)
        {
            Names.Add(name);
            Console.WriteLine("Add: {0}",Names.Count);
        }    对于Monitor的使用有一个方法是比较诡异的，那就是Wait方法。在MSDN中对Wait的描述是: 释放对象上的锁以便允许其他线程锁定和访问该对象。

这里提到的是先释放锁，那么显然我们需要先得到锁，否则调用Wait会出现异常，所以我们必须在Wait前面调用Enter方法或其他获取锁的方法，如lock，这点很重要。对应Enter方法，Monitor给出来另一种实现TryEnter。这两种方法的主要区别在于是否阻塞当前线程，Enter方法在获取不到锁时，会阻塞当前线程直到得到锁。不过缺点是如果永远得不到锁那么程序就会进入死锁状态。我们可以采用Wait来解决，在调用Wait时加入超时时限就可以。

            if (Monitor.TryEnter(Names))
            {
                Monitor.Wait(Names, 1000); // !!
                Names.Remove(name);
                Console.WriteLine("Del: {0}", Names.Count);
                Monitor.Pulse(Names);
            }

C#中的浅拷贝和深拷贝以及利用序列化等多种方式实现深拷贝

329084470@qq.com() — Sun, 30 Jan 2011 15:25:00 GMT

引言

C#中有两种类型变量，一种是值类型变量，一种是引用类型变量,对于值类型变量，深拷贝和前拷贝都是通过赋值操作符号(=)实现，其效果一致，将对象中的值类型的字段拷贝到新的对象中.这个很容易理解。本文重点讨论引用类型变量的拷贝机制和实现。

C#中引用类型对象的copy操作有两种：

浅拷贝(影子克隆/shallow copy):只复制对象的值类型字段,对象的引用类型,仍属于原来的引用. 深拷贝(深度克隆):不仅复制对象的值类型字段,同时也复制原对象中的对象.就是说完全是新对象产生的.

浅拷贝和深拷贝之间的区别：浅拷贝是指将对象中的数值类型的字段拷贝到新的对象中，而对象中的引用型字段则指复制它的一个引用到目标对象。

　　注意：string类型有点特殊，对于浅拷贝，类值类型对象进行处理。

浅拷贝的实现

　　使用Object类MemberwiseClone实现

　　MemberwiseClone:创建当前 Object 的浅表副本。

　　MemberwiseClone 方法创建一个浅表副本，方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的，则对该字段执行逐位复制。如果字段是引用类型，则复制引用但不复制引用的对象;因此，原始对象及其复本引用同一对象。

　　代码实现如下：

public class Person
　　{
　　public int Age { get; set; }
　　public string Address { get; set; }
　　public Name Name { get; set; }
　　public object Clone()
　　{
　　return this.MemberwiseClone();
　　}
　　}
　　public class Name
　　{
　　public Name(string frisName,string lastName)
　　{
　　FristName = frisName;
　　LastName = lastName;
　　}
　　public string FristName { get; set; }
　　public string LastName { get; set; }
　　}

赋值操作(=)VS使用Object类MemberwiseClone实现

　　对于引用类型的变量，我们有种误解，认为赋值操作就是浅拷贝一种，其实不然，两者有区别。

浅拷贝(shallow copy)对于引用类型对象中的值类型字段进行了逐位复制。赋值运算符只是把源对象的引用赋值给目的对象，两者引用同一个对象。 浅拷贝后的对象的值类型字段更改不会反映到源对象，而赋值运算后的对象的值类型字段更改会反映到源对象代码实现如下：

public class Person
　　{
　　public int Age { get; set; }
　　public string Address { get; set; }
　　public Name Name { get; set; }
　　}
　　public class Name
　　{
　　public Name(string frisName,string lastName)
　　{
　　FristName = frisName;
　　LastName = lastName;
　　}
　　public string FristName { get; set; }
　　public string LastName { get; set; }
　　}

深拷贝实现

　　相对于浅拷贝,是指依照源对象为原型，创建一个新对象，将当前对象的所有字段进行执行逐位复制并支持递归，不管是是值类型还是引用类型，不管是静态字段还是非静态字段。

　　在C#中，我们们有三种方法实现深拷贝

　　实现ICloneable接口，自定义拷贝功能。

　　ICloneable 接口，支持克隆，即用与现有实例相同的值创建类的新实例。

　　ICloneable 接口包含一个成员 Clone，它用于支持除 MemberwiseClone 所提供的克隆之外的克隆。Clone 既可作为深层副本实现，也可作为浅表副本实现。在深层副本中，所有的对象都是重复的;而在浅表副本中，只有顶级对象是重复的，并且顶级以下的对象包含引用。结果克隆必须与原始实例具有相同的类型或是原始实例的兼容类型。

　　代码实现如下：

　Code
　　public class Person:ICloneable
　　{
　　public int Age { get; set; }
　　public string Address { get; set; }
　　public Name Name { get; set; }
　　public object Clone()
　　{
　　Person tem = new Person();
　　tem.Address = this.Address;
　　tem.Age = this.Age;
　　tem.Name = new Name(this.Name.FristName, this.Name.LastName);
　　return tem;
　　}
　　}
　　public class Name
　　{
　　public Name(string frisName, string lastName)
　　{
　　FristName = frisName;
　　LastName = lastName;
　　}
　　public string FristName { get; set; }
　　public string LastName { get; set; }
　　}

　　大家可以看到,Person类继承了接口ICloneable并手动实现了其Clone方法,这是个简单的类,试想一下,如果你的类有成千上万个引用类型成员(当然太夸张,几十个还是有的)，这是不是份很恐怖的劳力活?

序列化/反序列化类实现

　　不知道你有没有注意到DataSet对象,对于他提供的两个方法:

　　DataSet.Clone 方法，复制 DataSet 的结构，包括所有 DataTable 架构、关系和约束。不要复制任何数据。

　　新 DataSet，其架构与当前 DataSet 的架构相同，但是不包含任何数据。注意如果已创建这些类的子类，则复本也将属于相同的子类。

　　DataSet.Copy 方法复制该 DataSet 的结构和数据.

　　新的 DataSet，具有与该 DataSet 相同的结构(表架构、关系和约束)和数据。注意如果已创建这些类的子类，则副本也将属于相同的子类。

　　好像既不是浅拷贝,又不是深拷贝，是不是很失望?但是两个结合起来不是我们要的深拷贝吗?看看DataSet的实现，注意序列化接口：ISerializable

序列化是将对象或对象图形转换为线性字节序列，以存储或传输到另一个位置的过程。

　　反序列化是接受存储的信息并利用它重新创建对象的过程。

　　通过 ISerializable 接口，类可以执行其自己的序列化行为。

　　转换为线性字节序列后并利用其重新创建对象的过程是不是和我们的深拷贝的语意“逐位复制”很相像?

　　代码实现如下：

[Serializable]
　　public class Person : ICloneable
　　{
　　public int Age { get; set; }
　　public string Address { get; set; }
　　public Name Name { get; set; }
　　public object Clone()
　　{
　　using (MemoryStream ms = new MemoryStream(1000))
　　{
　　object CloneObject;
　　BinaryFormatter bf = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.Clone));
　　bf.Serialize(ms, this);
　　ms.Seek(0, SeekOrigin.Begin);
　　// 反序列化至另一个对象(即创建了一个原对象的深表副本)
　　CloneObject = bf.Deserialize(ms);
　　// 关闭流
　　ms.Close();
　　return CloneObject;
　　}
　　}
　　}
　　[Serializable]
　　public class Name
　　{
　　public Name(string frisName, string lastName)
　　{
　　FristName = frisName;
　　LastName = lastName;
　　}
　　public string FristName { get; set; }
　　public string LastName { get; set; }
　　}
　　}

　　注意：通过序列化和反序列化实现深拷贝，其和其字段类型必须标记为可序列化类型，既添加特性(Attribute)[Serializable]。

　　通过反射实现

　　通过序列化/反序列化方式我们能比较流畅的实现深拷贝，但是涉及到IO操作，托管的的环境中，IO操作比较消耗资源。能不能有更优雅的解决方案。CreateInstance，对，利用反射特性。这个方法大家可以参考这篇博客：http://rubenhak.com/?p=70 文章反射类的Attribute，利用Activator.CreateInstance New一个类出来(有点像DataSet.Clone先获得架构)，然后利用PropertyInfo的SetValue和GetValue方法，遍历的方式进行值填充。

　　代码实现如下：

　public class Person
　　{
　　private List _friends = new List();
　　public string Firstname { get; set; }
　　public string Lastname { get; set; }
　　[Cloneable(CloneableState.Exclude)]
　　[Cloneable(CloneableState.Include, "Friends")]
　　public List Friends { get { return _friends; } }
　　[Cloneable(CloneableState.Exclude)]
　　public PersonManager Manager { get; set; }
　　}

利用序列化和反序列化实现深拷贝

329084470@qq.com() — Sun, 30 Jan 2011 14:42:31 GMT

假如说有一个简单的类，只有2个属性，那么可以用比较简单的方法实现深拷贝。

[Serializable]  
public class Person  
{  
    public int Height { get; set; }  
    public string FirstName { get; set; }  
}  
   
class Program {  
    static void Main(string[] args) {  
        //实例化一个对象  
        Person PersonOne = new Person();  
        PersonOne.FirstName = "John";  
        PersonOne.Height = 1;  
        //深拷贝  
        Person DeepCopyPerson = new Person();  
        DeepCopyPerson.FirstName = PersonOne.FirstName;  
        DeepCopyPerson.Height = PersonOne.Height;  
    }  
}

代码中的DeepCopyPerson对象就是对PersonOne对象的一个深拷贝。其实还可以用序列化和反序列化的方法来实现对对象的深拷贝。Person类的[Serializable]属性是为了下面介绍序列化反序列化方法做深拷贝而做的准备，在这里没什么特别含义。

public static T DeepCopy<t>(T obj)  
{  
    object retval;  
    using (MemoryStream ms = new MemoryStream())  
    {  
        BinaryFormatter bf = new BinaryFormatter();  
        //序列化成流  
        bf.Serialize(ms, obj);  
        ms.Seek(0, SeekOrigin.Begin);  
        //反序列化成对象  
        retval = bf.Deserialize(ms);  
        ms.Close();  
    }  
    return (T)retval;  
}

用的时候就是：

class Program {  
    static void Main(string[] args) {  
        //实例化一个对象  
        Person PersonOne = new Person();  
        PersonOne.FirstName = "John";  
        PersonOne.Height = 1;  
        //深拷贝  
        Person DeepCopyPerson = DeepCopy<person>(PersonOne);  
    }  
}

只要一个类被声明为可序列化的（就是带有[Serializable]标签），就可以用这个方法来进行深拷贝。记下来，免得以后自己忘记了。

C# string.Format Method [C#字符串格式化方法]

329084470@qq.com() — Tue, 25 Jan 2011 03:55:16 GMT

You want to format strings in your C# program using the string.Format method. The string.Format method is a static method that receives a string that specifies where the following arguments should be inserted, and these are called substitutions. Here we look at examples of the string.Format method in the C# language.

Formatting multiple strings

This example shows the use of the string.Format method to combine three strings with formatting options. The format string itself is the first argument to the string.Format method and it is specified as a string literal. The position markers in the format string are specified to the left of the colons, and this means the "0", "1:", and "2:" indicate where the first, second, and third arguments are inserted. The part after the ":" and in between the { } brackets indicates the exact format specification for that variable.

See String Literal.

--- Program that uses string.Format with three variables [C#] ---
using System;
class Program
{
    static void Main()
    {
        //
        // Declare three variables that we will use in the format method.
        // ... The values they have are not important.
        //
        string value1 = "Dot Net Perls";
        int value2 = 10000;
        DateTime value3 = new DateTime(2007, 11, 1);
        //
        // Use string.Format method with four arguments.
        // ... The first argument is the formatting string.
        // ... It specifies how the next three arguments are formatted.
        //
        string result = string.Format("{0}: {1:0.0} - {2:yyyy}",
            value1,
            value2,
            value3);
        //
        // Write the result.
        //
        Console.WriteLine(result);
    }
}
--- Output of the program ---
Dot Net Perls: 10000.0 - 2007

Walkthrough. There are three variables declared and initialized in the start of the Main method. These variables are used in the next call to string.Format. The first argument to the string.Format method is a format string. The resulting string contains extra formatting between the arguments. The "0.0" part of the format string specifies how the integer is displayed, while the "yyyy" part specifies that only the four-digit year of the date should be displayed.

Number formats

You can specify that a value type such as a double can be formatted inside the string.Format method based on the format string. The format string is the first argument to the string.Format method. The format string in this example uses the 0:0.0% syntax, which means that the second argument should be formatted with the pattern 0.0%. The arguments are numbered starting at zero.

--- Program that uses string.Format with number [C#] ---
using System;
class Program
{
    static void Main()
    {
        //
        // Format a ratio as a percentage string.
        // ... You must specify the percentage symbol in the format string.
        // ... It will multiply the value by 100 for you.
        //
        double ratio = 0.73;
        string result = string.Format("string = {0:0.0%}",
            ratio);
        Console.WriteLine(result);
    }
}
--- Output of the program ---
string = 73.0%

Format string details. The format string here demonstrates several aspects to the string.Format method use. The 0.0% part of the format string specifies the exact number of digits that are required. Note that the 0.0% can have as many digits before the decimal place as necessary, but only one after the decimal place. The percentage symbol will result in the number being multiplied by 100 logically.

Visit msdn.microsoft.com.

Padding

Padding can be used with strings in the C# language and this can be expressed declaratively in formatting strings and the string.Format method. The term 'padding' indicates that you are inserting a variable number of characters at the left or right of the string to ensure that the total length of the string is a fixed length. Instead of the PadLeft and PadRight methods, you can use the string.Format method with special substitutions.

See PadLeft String Method.

See PadRight Aligns Strings.

--- Program that uses string.Format for padding [C#] ---
using System;
class Program
{
    static void Main()
    {
        //
        // The constant formatting string.
        // ... It specifies the padding using the comma and number syntax.
        // ... A negative number means to left-align.
        // ... A positive number means to right-align.
        //
        const string format = "{0,-10} {1,10}";
        //
        // Construct the strings.
        //
        string line1 = string.Format(format,
            100,
            5);
        string line2 = string.Format(format,
            "Carrot",
            "Giraffe");
        //
        // Write the formatted strings.
        //
        Console.WriteLine(line1);
        Console.WriteLine(line2);
    }
}
--- Output of the program ---
100                 5
Carrot        Giraffe

Description. For declaring padding inside a format string, use the comma character followed by the padding size. You can use a negative padding size to add padding to the right, which will left-align the text. You can use a positive padding size to add padding to the left, which will right-align the string.

Dates

The DateTime struct is a value type that is an abstract data type for any possible date and time. The string.Format method can be used with DateTime arguments and these will be inserted into the substitution markers. Because DateTime formatting is so important, this site introduces a thorough exploration of the string.Format and DateTime formatting strings.

See DateTime Format Examples.

Filenames

Many programs written in the C# language need to create files dynamically. The files often need to have file names that are based on the current date and time or another characteristic such as a counter. For example, a logging file can have a file name that is based on the exact date and time it was written. The string.Format method provides a way to express this functionality in a clear way. You can use the string.Format method with substitutions to create the filenames based on state variables.

See DateTime for Filenames.

StringBuilder (AppendFormat)

The StringBuilder type presents a method called AppendFormat. The AppendFormat method receives a formatting string and also the arguments to the formatting string, which are placed in the substitution markers. For performance work, the AppendFormat method is not ideal; however, it can lead to clearer code.

See StringBuilder Secrets.

Console.WriteLine formatting

Console programs written in the C# language can use formatting strings directly inside the Console.Write and Console.WriteLine methods. When using Visual Studio, you can type Console.WriteLine and then scroll through the IntelliSense popup to find the overloads that receive the format string. You can then call Console.WriteLine with the same arguments as the string.Format method receives, and it will internally call the string.Format method.

See Console.WriteLine Use.

Implementation

In the base class library, the string.Format method uses a param argument, which is a variable parameter list. This results in an array allocation on each invocation of the method. You can discover more about the params keyword here.

See Params Method.

Substitution processing. Internally, the string.Format method uses the StringBuilder type, which contains a mutable character buffer. It estimates a capacity based on a heuristic in the StringBuilder constructor. Next, the AppendFormat method is called to process the substitutions themselves. The ToString method is finally called; fortunately, the ToString method does not normally require a copy to be made.

See StringBuilder Capacity Test.

Summary

The string.Format method provides a way for you to insert argument strings and separators together, and also to specify display options for each argument individually. We saw how you can combine several strings and format dates, numbers, and percentages. We noted that many methods in the .NET Framework use this syntax. Finally, we delved into the implementation of the method itself.

C# DateTime Format Examples [C#日期格式化]

329084470@qq.com() — Tue, 25 Jan 2011 03:54:01 GMT

You need help with DateTime formatting strings in the C# language or other .NET languages. The framework provides powerful formatting capabilities, but the syntax is confusing and there are some tricks. Here we see examples of using DateTime formats, and also the different values you can get with the individual formats.

Format your DateTimes in the best way for your application.
You will not have to write elaborate custom routines.
The .NET Framework has a powerful DateTime format mechanism.

Using DateTime format string

Here we see an example of how you can use a specific formatting string with DateTime and ToString to obtain a special DateTime string. This is useful when interacting with other systems, or when you require a precise format.

=== Program that uses DateTime format (C#) ===
using System;
class Program
{
    static void Main()
    {
        DateTime time = DateTime.Now;              // Use current time
        string format = "MMM ddd d HH:mm yyyy";    // Use this format
        Console.WriteLine(time.ToString(format));  // Write to console
    }
}
=== Output of the program ===
Feb Fri 27 11:41 2009
=== Format string pattern ===
MMM     display three-letter month
ddd     display three-letter day of the WEEK
d       display day of the MONTH
HH      display two-digit hours on 24-hour scale
mm      display two-digit minutes
yyyy    display four-digit year

Notes on the letters. The letters in the format string above specify the output you want to display. The final comment shows what the MMM, ddd, d, HH, mm, and yyyy will do.

Modifying DateTime format string

Here we see how you can modify the DateTime format string in the above example to get different output with ToString. We change some of the fields so the resulting value is shorter.

=== Program that uses different format (C#) ===
using System;
class Program
{
    static void Main()
    {
        DateTime time = DateTime.Now;             // Use current time
        string format = "M d h:mm yy";            // Use this format
        Console.WriteLine(time.ToString(format)); // Write to console
    }
}
=== Output of the program ===
2 27 11:48 09
=== Format string pattern ===
M       display one-digit month number          [changed]
d       display one-digit day of the MONTH      [changed]
h       display one-digit hour on 12-hour scale [changed]
mm      display two-digit minutes
yy      display two-digit year                  [changed]

Note on format string usages. You will also need to specify a format string when using DateTime.ParseExact and DateTime.ParseExact. This is because those methods require a custom pattern to parse.

Single-letter DateTime format strings

Here we see that you can use a single character with ToString or DateTime.ParseExact to specify a preset format available in the framework. These are standard formats and very useful in many programs. They can eliminate typos in the custom format strings.

=== Program that tests formats (C#) ===
using System;
class Program
{
    static void Main()
    {
        DateTime now = DateTime.Now;
        Console.WriteLine(now.ToString("d"));
        Console.WriteLine(now.ToString("D"));
        Console.WriteLine(now.ToString("f"));
        Console.WriteLine(now.ToString("F"));
        Console.WriteLine(now.ToString("g"));
        Console.WriteLine(now.ToString("G"));
        Console.WriteLine(now.ToString("m"));
        Console.WriteLine(now.ToString("M"));
        Console.WriteLine(now.ToString("o"));
        Console.WriteLine(now.ToString("O"));
        Console.WriteLine(now.ToString("s"));
        Console.WriteLine(now.ToString("t"));
        Console.WriteLine(now.ToString("T"));
        Console.WriteLine(now.ToString("u"));
        Console.WriteLine(now.ToString("U"));
        Console.WriteLine(now.ToString("y"));
        Console.WriteLine(now.ToString("Y"));
    }
}
=== Output of the program ===
d    2/27/2009
D    Friday, February 27, 2009
f    Friday, February 27, 2009 12:11 PM
F    Friday, February 27, 2009 12:12:22 PM
g    2/27/2009 12:12 PM
G    2/27/2009 12:12:22 PM
m    February 27
M    February 27
o    2009-02-27T12:12:22.1020000-08:00
O    2009-02-27T12:12:22.1020000-08:00
s    2009-02-27T12:12:22
t    12:12 PM
T    12:12:22 PM
u    2009-02-27 12:12:22Z
U    Friday, February 27, 2009 8:12:22 PM
y    February, 2009
Y    February, 2009

ToLongDateString and ToShortDateString

Here we see the ToLongDateString, ToLongTimeString, ToShortDateString, and ToShortTimeString methods on DateTime. These methods are equivalent to the lowercase and uppercase D and T methods shown in the example above.

=== Program that uses ToString methods (C#) ===
using System;
class Program
{
    static void Main()
    {
        DateTime now = DateTime.Now;
        Console.WriteLine(now.ToLongDateString());  // Equivalent to D
        Console.WriteLine(now.ToLongTimeString());  // Equivalent to T
        Console.WriteLine(now.ToShortDateString()); // Equivalent to d
        Console.WriteLine(now.ToShortTimeString()); // Equivalent to t
        Console.WriteLine(now.ToString());
    }
}
=== Output of the program ===
ToLongDateString     Friday, February 27, 2009
ToLongTimeString     12:16:59 PM
ToShortDateString    2/27/2009
ToShortTimeString    12:16 PM
ToString             2/27/2009 12:16:59 PM

Note on default ToString method. The default ToString method on DateTime shown above is equivalent to the simple "G" formatting string in the previous example. In other words, ToString("G") and ToString() do the same thing.

Formatting characters

When you use DateTime.ParseExact, or ToString(), you need to specify a formatting string, which is a sequence of characters that designate how the final result will look. What follows are the author's notes on the strings from MSDN.

See 24-Hour and Military Time Formats.

d
Use this to specify the numeric value for the day of the month.
It will be one or two digits long.
dd
This is the same as a single d, except there are always two digits, with a leading
0 prepended if necessary.
ddd
This displays a three-letter string that indicates the current day of the week.
dddd
This displays the full string for the day of the week.
ffffffffffffffffffffffffffffFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Use the lowercase f to indicate the seconds to one digit length.
Use two lowercase fs to indicate the seconds to two digits.
The uppercase F patterns do the same but work differently on trailing zeros.
gg
Use this to display A.D. on your date.
It is unlikely that this will be B.C. in most programs.
h
Display the hours in one digit if possible.
If the hours is greater than 9, it will display two digits.
Range is 1-12.
hh
Display the hours in two digits always, even if the hour is one digit.
The range here will be 01-12.
H
This represents the hours in a range of 0-23, which is called military time
in some parts of the world. [See next row for two digits and link.]
HH
This represents the hours in a range of 00-23.
The only different here between the single H is that there is always a leading zero
if the number is one digit.
K
Use this to display time zone information.
mmm
This formats the minutes in your date format string.
Here, the one m means that there is only one digit displayed if possible.
The two ms means that there are always two digits displayed, with a leading zero
if necessary.
MMM
These display the months in numeric form.
The one uppercase M does not have a leading zero on it.
The two uppercase Ms will format a number with a leading zero if it is required.
MMM
This displays the abbreviated three-letter form of the month represented in
the DateTime.
MMMM
This displays the full month string, properly capitalized.
sss
The lowercase s displays seconds.
A single lowercase s means that you do not require a leading zero.
Two lowercase s characters means you always want two digits, such as 00-59.
t
Use the lowercase t to indicate A, when the time is in the AM, and P, for when
the time is in PM.
tt
Use two lowercase tts to display the full AM or PM string.
You will normally want this for when you are displaying the string to a user.
yyyyyyyyyyyyyyy
These display the year to different digits.
In your programs, you won't need three digits for the year, or five.
Therefore, you should only consider one y, two ys, or four ys.
zzzzzz
These represent the offset from the UTC time on the local operating system.
:
This is the time separator.
/
This is the date separator.
Others
Most other characters will be printed to the output string without any modification.

Difference between d and dd, ddd and dddd

It is important to note that d and dd (one and two ds) mean something entirely different than ddd and dddd (three and four ds). d and dd indicate the day of the month, while ddd and dddd indicate the day of the week, in a word. Please see the table above.

Three-letter days

In some systems it may be useful to display the day of the week in a three-letter form. Here we see a simple program that prints out the days of the week in three-letter format. This will vary based on the language installed on the computer.

=== Program that tests days (C#) ===
using System;
class Program
{
    static void Main()
    {
        DateTime now = DateTime.Today;
        for (int i = 0; i < 7; i++)
        {
            Console.WriteLine(now.ToString("ddd"));
            now = now.AddDays(1);
        }
    }
}
=== Output of the program ===
Thu
Fri
Sat
Sun
Mon
Tue
Wed

Displaying complete day

Often you need to display the complete day of the week in your C# code, and the four ds together will do this for you. This simple program shows all seven different day strings you can get from the dddd.

=== Program that shows day strings (C#) ===
using System;
class Program
{
    static void Main()
    {
        DateTime now = DateTime.Today;
        for (int i = 0; i < 7; i++)
        {
            Console.WriteLine(now.ToString("dddd"));
            now = now.AddDays(1);
        }
    }
}
=== Output of the program ===
Thursday
Friday
Saturday
Sunday
Monday
Tuesday
Wednesday

Displaying the era

The .NET platform allows you to display the date with the era or period, which is usually A.D. or B.C. It is unlikely that you will need to use B.C., except in a rare theoretical application. Nevertheless, here is what the two gs will print. Use the code "DateTime.Now.ToString("gg");".

Month property and strings

You may need to display the month name in a three-letter format. This is equivalent, in English, to taking a substring of the first three letters, but using the three Ms next to each other may be easier and more terse for your code. Additionally, you may want full month strings. This site contains a useful article that covers DateTime month strings and the Month property in more detail.

See DateTime.Month Property.

Displaying AM/PM—first letter only

This isn't something you are likely to need, but interesting to find out. When you specify one t, you can get the first letter of the AM or PM string. This is equivalent to using Substring or getting the first char of the tt string. There is a space at the end of the format string because the value "t" can mean something else in the format string.

Displaying AM/PM—full string

Here we see how you can get the string AM or PM in your DateTime ToString code. The code adds 12 to ensure the second iteration is in the other half.

=== Program that displays AM and PM (C#) ===
using System;
class Program
{
    static void Main()
    {
        DateTime now = DateTime.Now;
        for (int i = 0; i < 2; i++)
        {
            Console.WriteLine(now.ToString("tt "));
            now = now.AddHours(12);
        }
    }
}
=== Output of the program ===
PM
AM

Note on lack of periods. There are no periods in the output of tt in the example above. Therefore, if you require periods in your AM or PM, you would have to manipulate the string.

Displaying year to different digits

You can vary the number of digits displayed in the year string. You will always want to use y, yy, or yyyy for your programs. The framework accepts different numbers, but they are impractical in the real world. Occasionally two ys is useful for a user-oriented program, but for your back end code, you will want to use four ys. You do not need uppercase Ys.

=== Program that displays years (C#) ===
using System;
class Program
{
    static void Main()
    {
        DateTime now = DateTime.Now;
        Console.WriteLine(now.ToString("y "));
        Console.WriteLine(now.ToString("yy"));
        Console.WriteLine(now.ToString("yyy"));   // <-- Don't use this
        Console.WriteLine(now.ToString("yyyy"));
        Console.WriteLine(now.ToString("yyyyy")); // <-- Don't use this
    }
}
=== Output of the program ===
9
09
2009
2009
02009

Summary

In this example set, we saw lots of information and examples regarding DateTime format strings. We covered single-letter preset format strings, and more complicated custom format strings with different character codes. We saw an overview of the custom code letters. Finally, we saw enumerations of all the values for days of the week, months, and also three-letter versions of those. More general examples that use the format string system in the .NET Framework are available.

雪狼领地 - DotNet框架

C#IO文件读写和流

c#当前应用程序路径

.NET/C#中对对象集合进行查询的方法 以及相关的 Predicate 及 Action 的用法

Inside Predicate:

Inside Action:

Example

NET多线程同步方法详解(三)：读写锁（ReadWriteLock)

NET多线程同步方法详解(二)：互斥锁(lock)

NET多线程同步方法详解(一)：自由锁(InterLocked)

C#中的浅拷贝和深拷贝以及利用序列化等多种方式实现深拷贝

利用序列化和反序列化实现深拷贝

C# string.Format Method [C#字符串格式化方法]

Formatting multiple strings

Number formats

Padding

Dates

Filenames

StringBuilder (AppendFormat)

Console.WriteLine formatting

Implementation

Summary

C# DateTime Format Examples [C#日期格式化]

Using DateTime format string

Modifying DateTime format string

Single-letter DateTime format strings

ToLongDateString and ToShortDateString

Formatting characters

Difference between d and dd, ddd and dddd

Three-letter days

Displaying complete day

Displaying the era

Month property and strings

Displaying AM/PM—first letter only

Displaying AM/PM—full string

Displaying year to different digits

Summary

.NET/C#中对对象集合进行查询的方法以及相关的 Predicate 及 Action 的用法