纯安全C中的联合（C++共享内存类型）#

在不使用不安全模式和指针的情况下，可以让类成员共享类/结构中的内存空间。给定以下类别：

[StructLayout(LayoutKind.Explicit)]
public class A
{
    [FieldOffset(0)]
    public byte One;

    [FieldOffset(1)]
    public byte Two;

    [FieldOffset(2)]
    public byte Three;

    [FieldOffset(3)]
    public byte Four;

    [FieldOffset(0)]
    public int Int32;
}

您可以通过操作Int32字段来修改字节字段的值，反之亦然。例如，该程序：

    static void Main(string[] args)
    {
        A a = new A { Int32 = int.MaxValue };

        Console.WriteLine(a.Int32);
        Console.WriteLine("{0:X} {1:X} {2:X} {3:X}", a.One, a.Two, a.Three, a.Four);

        a.Four = 0;
        a.Three = 0;
        Console.WriteLine(a.Int32);
    }

输出以下内容：

2147483647
FF FF FF 7F
65535

只需添加使用System.Runtime.InteropServices；

定义自定义属性时，可以将其与[MyAttrAttribute]或[MyAttr]一起使用。当两种书写都存在类时，就会发生编译错误。

@特殊字符可用于区分它们：

[AttributeUsage(AttributeTargets.All)]
public class X: Attribute
{}

[AttributeUsage(AttributeTargets.All)]
public class XAttribute: Attribute
{}

[X]      // Error: ambiguity
class Class1 {}

[XAttribute]   // Refers to XAttribute
class Class2 {}

[@X]      // Refers to X
class Class3 {}

[@XAttribute]   // Refers to XAttribute
class Class4 {}

脑海中浮现出反射发射和表达树。。。

不要错过Jeffrey Richter通过C#和Jon Skeet的CLR

请参阅此处获取一些资源：

http://www.codeproject.com/KB/trace/releasemodebreakpoint.aspx

http://www.codeproject.com/KB/dotnet/Creating_Dynamic_Types.aspx

http://www.codeproject.com/KB/cs/lambdaexpressions.aspx

泛型类型中的“默认”关键字：

T t = default(T);

如果T是引用类型，结果为“null”；如果T是int，结果为0；如果T为布尔值，结果为false，等等。

刚刚学会了[UnmanagedFunctionPointerAttribute（CallingConvention.CDecl）]的乐趣，因为它尝试与非托管C++函数库接口，该函数库定义了不带__stdcall的回调。

我想很多人都知道C中的指针，但不确定它在C#中是否有效。您可以在不安全的上下文中使用C#中的指针：

static void Main()
{
    int i;
    unsafe
    {               
        // pointer pi has the address of variable i
        int* pi = &i; 
        // pointer ppi has the address of variable pi
        int** ppi = π
        // ppi(addess of pi) -> pi(addess of i) -> i(0)
        i = 0;
        // dereference the pi, i.e. *pi is i
        Console.WriteLine("i = {0}", *pi); // output: i = 0
        // since *pi is i, equivalent to i++
        (*pi)++;
        Console.WriteLine("i = {0}", *pi); // output: i = 1
        // since *ppi is pi, one more dereference  *pi is i 
        // equivalent to i += 2
        **ppi += 2;
        Console.WriteLine("i = {0}", *pi);// output: i = 3
    }
    Console.ReadLine();
}