固定/C#中指针的力量-这个主题太大了，但我只概述一些简单的事情。

在C中，我们有装载结构的设施，如。。。

struct cType{
   char type[4];
   int  size;
   char name[50];
   char email[100];
}

cType myType;
fread(file, &mType, sizeof(mType));

我们可以在“unsafe”方法中使用fixed关键字来读取字节数组对齐的结构。

[Layout(LayoutKind.Sequential, Pack=1)]
public unsafe class CType{
    public fixed byte type[4];
    public int size;
    public fixed byte name[50];
    public fixed byte email[100];
}

方法1（从字节缓冲区中的常规流读取，并将字节数组映射到结构的各个字节）

CType mType = new CType();
byte[] buffer = new byte[Marshal.SizeOf(CType)];
stream.Read(buffer,0,buffer.Length);
// you can map your buffer back to your struct...
fixed(CType* sp = &mType)
{
    byte* bsp = (byte*) sp;
    fixed(byte* bp = &buffer)
    {
         for(int i=0;i<buffer.Length;i++)
         {
             (*bsp) = (*bp);
             bsp++;bp++;
         }
    }
}

方法2，您可以将Win32 User32.dll的ReadFile映射为直接读取字节。。。

CType mType = new CType();
fixed(CType* p = &mType)
{
    User32.ReadFile(fileHandle, (byte*) p, Marshal.SizeOf(mType),0);
}

混合物。基本上，如果您想向多个类添加一个特性，但不能对所有类使用一个基类，请让每个类实现一个接口（没有成员）。然后，为接口编写一个扩展方法，即。

public static DeepCopy(this IPrototype p) { ... }

当然，牺牲了一些清晰度。但它奏效了！

通过C#从CLR：标准化字符串时建议您使用ToUpperInvariant而不是ToLowerInvariant，因为Microsoft具有优化代码以执行大写比较。

我记得有一次我的同事总是在比较之前把字符串改成大写。我一直想知道他为什么这么做，因为我觉得先转换成小写字母更“自然”。看完这本书后，我知道为什么了。

属性，但大多数是DebuggerDisplay。为您节省多年。

@艾德，我有点不愿意发表这篇文章，因为这只是吹毛求疵。但是，我要指出，在您的代码示例中：

MyClass c;
  if (obj is MyClass)
    c = obj as MyClass

如果你要使用“is”，为什么要使用“as”进行安全的转换？如果你确定obj确实是MyClass，一个泥沼标准演员：

c = (MyClass)obj

…永远不会失败。

同样，你可以说：

MyClass c = obj as MyClass;
if(c != null)
{
   ...
}

我对.NET的内部结构了解不多，但我的直觉告诉我，这会将最多两个类型转换操作减少到最多一个。无论哪种方式都不太可能打破处理银行；我个人认为，后一种形式看起来也更干净。

我很确定每个人都熟悉运算符重载，但可能有些人不熟悉。

class myClass
{
    private string myClassValue = "";

    public myClass(string myString)
    {
        myClassValue = myString;
    }

    public override string ToString()
    {
        return myClassValue;
    }

    public static myClass operator <<(myClass mc, int shiftLen)
    {
        string newString = "";
        for (int i = shiftLen; i < mc.myClassValue.Length; i++)
            newString += mc.myClassValue[i].ToString();
        mc.myClassValue = newString.ToString();
        return mc;
    }

    public static myClass operator >>(myClass mc, int shiftLen)
    {
        char[] newString = new char[shiftLen + mc.myClassValue.Length];

        for (int i = shiftLen; i < mc.myClassValue.Length; i++)
            newString[i] += mc.myClassValue[i - shiftLen];

        mc.myClassValue = new string(newString);
        return mc;
    }

    public static myClass operator +(myClass mc, string args)
    {
        if (args.Trim().Length > 1)
            mc.myClassValue += args;
        return mc;
    }

    public static myClass operator -(myClass mc, string args)
    {
        if (args.Trim().Length > 1)
        {
            Regex rgx = new Regex(args);
            mc.myClassValue = rgx.Replace(mc.myClassValue, "");
        }
        return mc;
    }
}

我认为能够使用<<and>>左右移动字符串或使用-=

myClass tmpClass = new myClass("  HelloWorld123");
tmpClass -= @"World";
tmpClass <<= 2;
Console.WriteLine(tmpClass);