1、异步的：

p.StartInfo.RedirectStandardError = true;
p.ErrorDataReceived += new DataReceivedEventHandler(OutputInfo);
p.Start();
p.BeginErrorReadLine();

private void OutputInfo(object sendProcess, DataReceivedEventArgs output){
  if (!String.IsNullOrEmpty(output.Data))
  {
    //处理方法...
  }
}

2、同步的

p.StartInfo.RedirectStandardError = true;
p.Start();
StreamReader sr = ffmpeg.StandardError;
p.WaitForExit();//之后就可以从sr里读了

1、关于enum的定义

enum Fabric
{
  Cotton = 1,
  Silk = 2,
  Wool = 4,
  Rayon = 8,
  Other = 128
}

2、符号名和常数值的互相转换

Fabric fab = Fabric.Cotton;
int fabNum = (int)fab;//转换为常数值。必须使用强制转换。
Fabric fabString = (Fabric)1;//常数值转换成符号名。如果使用ToString()，则是（（Fabric）1）.ToString()，注意必须有括号。
string fabType = fab.ToString();//显示符号名
string fabVal = fab.ToString ("D");//显示常数值

3、获得所有符号名的方法（具体参见Enum类）

public enum MyFamily
{
  YANGZHIPING = 1,
  GUANGUIQIN = 2,
  YANGHAORAN = 4,
  LIWEI = 8,
  GUANGUIZHI = 16,
  LISIWEN = 32,
  LISIHUA = 64,
}
foreach (string s in Enum.GetNames(typeof(MyFamily)))
{
  Console.WriteLine(s);
}

4、将枚举作为位标志来处理

根据下面的两个例子，粗略地说，一方面，设置标志[Flags]或者[FlagsAttribute]，则表明要将符号名列举出来；另一方面，可以通过强制转换，将数字转换为符号名。说不准确。看下面的例子体会吧。注意：

• 例一：

Fabric fab = Fabric.Cotton | Fabric.Rayon | Fabric.Silk;
Console.WriteLine("MyFabric = {0}", fab);//输出：Fabric.Cotton | Fabric.Rayon | Fabric.Silk;

• 例二：

class FlagsAttributeDemo
{
  // Define an Enum without FlagsAttribute.
  enum SingleHue : short
  {
    Black = 0,
    Red = 1,
    Green = 2,
    Blue = 4
  };
  // Define an Enum with FlagsAttribute.
  [FlagsAttribute]
  enum MultiHue : short
  {
    Black = 0,
    Red = 1,
    Green = 2,
    Blue = 4
  };
  static void Main( )
  {
    Console.WriteLine(
    "This example of the FlagsAttribute attribute n" +
    "generates the following output." );
    Console.WriteLine(
    "nAll possible combinations of values of an n" +
    "Enum without FlagsAttribute:n" );
    // Display all possible combinations of values.
    for( int val = 0; val <= 8; val++ )
    Console.WriteLine( "{0,3} – {1}",  val, ( (SingleHue)val ).ToString( ) );
    Console.WriteLine(  "nAll possible combinations of values of an n" + "Enum with FlagsAttribute:n" );
    // Display all possible combinations of values.
    // Also display an invalid value.
    for( int val = 0; val <= 8; val++ )
    Console.WriteLine ( "{0,3} – {1}",  val, ( (MultiHue)val ).ToString( ) );
  }
}
/*
This example of the FlagsAttribute attribute
generates the following output.
All possible combinations of values of an
Enum without FlagsAttribute:
0 – Black
1 – Red
2 – Green
3 – 3
4 – Blue
5 – 5
6 – 6
7 – 7
8 – 8
All possible combinations of values of an
Enum with FlagsAttribute:
0 – Black
1 – Red
2 – Green
3 – Red, Green
4 – Blue
5 – Red, Blue
6 – Green, Blue
7 – Red, Green, Blue
8 – 8
*/

5、枚举作为函数参数。经常和switch结合起来使用。下面举例

public static double GetPrice(Fabric fab)
{
  switch (fab)
  {
    case Fabric.Cotton:
      return (3.55);
    case Fabric.Silk:
      return (5.65);
    case Fabric.Wool:
      return (4.05);
    case Fabric.Rayon:
      return (3.20);
    case Fabric.Other:
      return (2.50);
    default:
      return (0.0);
  }
}

6、上面三点一个完整的例子

//enum的定义
public enum Fabric : short
{
  Cotton = 1,
  Silk = 2,
  Wool = 3,
  Rayon = 8,
  Other = 128
}
//将枚举作为参数传递
public static double GetPrice(Fabric fab)
{
  switch (fab)
  {
    case Fabric.Cotton: return (3.55);
    case Fabric.Silk : return (5.65);
    case Fabric.Wool: return (4.05);
    case Fabric.Rayon: return (3.20);
    case Fabric.Other: return (2.50);
    default: return (0.0);
  }
}
public static void Main()
{
  Fabric fab = Fabric.Cotton;
  int fabNum = (int)fab;
  string fabType = fab.ToString();
  string fabVal = fab.ToString ("D");
  double cost = GetPrice(fab);
  Console.WriteLine("fabNum = {0}nfabType = {1}nfabVal = {2}n", fabNum, fabType, fabVal);
  Console.WriteLine("cost = {0}", cost);
}

7、Enum类的使用

Enum.IsDefinde、Enum.Parse两种方法经常一起使用，来确定一个值或符号是否是一个枚举的成员，然后创建一个实例。Enum.GetName打印出一个成员的值；Enum.GetNames打印出所有成员的值。其中注意**“`typeof“`**的使用。这一点很重要。

public enum MyFamily
{
  YANGZHIPING = 1,
  GUANGUIQIN = 2,
  YANGHAORAN = 4,
  LIWEI = 8,
  GUANGUIZHI = 16,
  LISIWEN = 32,
  LISIHUA = 64,
}
string s = "YANGHAORAN";
if (Enum.IsDefined(typeof(MyFamily), s))
{
  MyFamily f = (MyFamily)Enum.Parse(typeof(MyFamily), s);
  GetMyFamily(f);
  Console.WriteLine("The name is:" + Enum. GetName(typeof(MyFamily), 2));
  string[] sa = Enum.GetNames(typeof(MyFamily));
  foreach (string ss in sa)
  {
    Console.WriteLine(ss);
  }
}

Subscription sub = new Subscription();
sub.Appname = subName;
if (this.Subscriptions.Contains(sub,new SubcriptionComparer<Subscription>()))
  return true;
else
  return false;
class SubcriptionComparer<T> : IEqualityComparer<T>
where T : Subscription
{
  public int GetHashCode(T obj)
  {
    return obj.GetHashCode();
  }
  public bool Equals(T t1, T t2)
  {
    return t1.Appname == t2.Appname;
  }
}

failed: Rhino.Mocks.Exceptions.ExpectationViolationException : IBandwidthDataService.GetDataForCustom(100, 2010/1/11 14:35:31, 2010/2/11 14:35:31, 1.00:00:00); Expected #0, Actual #1.

模拟的方法加上.IgnoreArguments()

1,class 是引用类型，structs是值类型

既然class是引用类型，class可以设为null。但是我们不能将struct设为null,因为它是值类型。

struct AStruct
{
  int aField;
}
class  AClass
{
  int aField;
}
class MainClass
{
  public static void Main()
  {
    AClass b = null; // No error.
    AStruct s = null; // Error [ Cannot convert null to 'AStruct'
    because it is a value type ].
  }
}

2,当你实例一个class，它将创建在堆上。而你实例一个struct，它将创建在栈上

3，你使用的是一个对class实例的引用。而你使用的不是对一个struct的引用。（而是直接使用它们）

4，当我们将class作为参数传给一个方法，我们传递的是一个引用。struct传递的是值而非引用。

5，structs, 不可以有初始化器，class可以有初始化器。

class MyClass
{
  int myVar =10;  //  no syntax error.
  public void MyFun( )
  {
    // statements
  }
}
struct MyStruct
{
  int myVar = 10;  //  syntax error.
  public void MyFun( )
  {
    // statements
  }
}

6,Classes 可以有明显的无参数构造器，但是Struct不可以

class MyClass
{
  int myVar = 10;
  public MyClass( ) // no syntax error.
  {
    // statements
  }
}
struct MyStruct
{
  int myVar;
  public MyStruct( ) // syntax error.
  {
    // statements
  }
}

7, 类使用前必须new关键字实例化，Struct不需要

MyClass aClassObj;     //  MyClass aClassObj=new MyClass(); is the correct format.aClassObj.
myVar=100;//NullReferenceException(because aClassObj does not contain a reference to an object of type myClass).
MyStruct  aStructObj;
aStructObj.myVar=100; //  no exception.

8, class支持继承和多态，Struct不支持. 注意：但是Struct 可以鹤类一样实现接口

9, 既然Struct不支持继承，其成员不能以protected 或Protected Internal 修饰

10, Class的构造器不需要初始化全部字段，Struct的构造器必须初始化所有字段

class MyClass    //No error( No matter whether the Field ’ MyClass.myString ’ is initialized or not ).
{
  int myInt;
  string myString;
  public MyClass( int aInt )
  {
    myInt = aInt;
  }
}
struct MyStruct    // Error ( Field ’ MyStruct.myString ’ must be fully assigned before it leaves the constructor ).
{
  int myInt;
  string myString;
  public MyStruct( int aInt )
  {
    myInt = aInt;
  }
}

11, Class可以定义析构器但是Struct不可以

12, Class比较适合大的和复杂的数据，Struct适用于作为经常使用的一些数据组合成的新类型。

适用场合：Struct有性能优势，Class有面向对象的扩展优势。
用于底层数据存储的类型设计为Struct类型，将用于定义应用程序行为的类型设计为Class。如果对类型将来的应用情况不能确定，应该使用Class。

System.Text.Encoding.Default.GetBytes(string);

反之亦然

System.Text.Encoding.Default.GetString(byte);

using System;
using System.Collections.Generic;
class Program
{
  static void Main()
  {
    List a = new List();
    a.Add(1);
    a.Add(2);
    a.Add(5);
    a.Add(6);
    // Contains:
    // 1
    // 2
    // 5
    // 6
    int[] b = new int[3];
    b[0] = 7;
    b[1] = 6;
    b[2] = 7;
    a.AddRange(b);
    // Contains:
    // 1
    // 2
    // 5
    // 6
    // 7 [added]
    // 6 [added]
    // 7 [added]
    foreach (int i in a)
    {
      Console.WriteLine(i);
    }
  }
}
=== Output of the program ===
1
2
5
6
7
6
7

写一个sorter

public class CourseSorter:IComparer
{
  #region IComparer Members
  public int Compare(CourseDto x, CourseDto y)
  {
    return x.Title.CompareTo(y.Title);
  }
  #endregion
}

用的时候list.sort(new Sorter());即可