unsafe
                     {
                         new ImageArgb32(path).ShowDialog("原始圖像")
                             .ToGrayscaleImage().ShowDialog("灰度圖像")
                             .ApplyOtsuThreshold().ShowDialog("二值化圖像")
                             .ToImageArgb32()
                             .ForEach((Argb32* p) => { if (p->Red == 255) *p = Argb32.RED; })
                             .ShowDialog("染色");
                     }

   private unsafe void btnSubmit_Click(object sender, EventArgs e)

public partial unsafe class FrmDemo1 : Form

  public unsafe class Person
    {
        public int Age;
        public void SetAge(int age)
        {
            fixed (int* p = &Age)
            {
                *p = age;
            }
        }
    }

       int age = 0;
             int* p = &age;
             *p = 20;
             MessageBox.Show(p->ToString());

         IntPtr handle = System.Runtime.InteropServices.Marshal.AllocHGlobal(4);
             Int32* p = (Int32*)handle;
             *p = 20;
             MessageBox.Show(p->ToString());
             System.Runtime.InteropServices.Marshal.FreeHGlobal(handle);

public unsafe class UnmanagedMemory : IDisposable
          {
              public int Count { get; private set; }
              private byte* Handle;
             private bool _disposed = false;
              public UnmanagedMemory(int bytes)
              {
                 Handle = (byte*) System.Runtime.InteropServices.Marshal.AllocHGlobal(bytes);
                 Count = bytes;
            }
             public void Dispose()
             {
                 Dispose(true);
                 GC.SuppressFinalize(true);
             }
            protected virtual void Dispose( bool isDisposing )
             {
                 if (_disposed) return;
                 if (isDisposing)
                 {
                     if (Handle != null)
                     {                         System.Runtime.InteropServices.Marshal.FreeHGlobal((IntPtr)Handle);
                     }
                 }
                 _disposed = true;
             }
             ~UnmanagedMemory()
  　         {
  　　           Dispose( false );
  　         }
         }

  using (UnmanagedMemory memory = new UnmanagedMemory(10))
            {
                int* p = (int*)memory.Handle;
                *p = 20;
                MessageBox.Show(p->ToString());
            }

       int* p = stackalloc int[10];
             for (int i = 0; i < 10; i++)
             {
                 p[i] = 2 * i + 2;
             }
             MessageBox.Show(p[9].ToString());

  [StructLayout(LayoutKind.Explicit)]
        public struct Argb32
        {
            [FieldOffset(0)]
            public Byte Blue;
            [FieldOffset(1)]
            public Byte Green;
            [FieldOffset(2)]
            public Byte Red;
            [FieldOffset(3)]
            public Byte Alpha;
            [FieldOffset(0)]
            public Int32 IntVal;
        }

namespace Geb.Image
{
    using TPixel = Argb32;
    using TCache = System.Int32;
    using TKernel = System.Int32;
    using TImage = Geb.Image.ImageArgb32;
    using TChannel = System.Byte;
    public static partial class ImageArgb32ClassHelper
    {
        #region include "ImageClassHelper_Template.cs"
        #endregion
    }
    public partial class ImageArgb32
    {
        #region include "Image_Template.cs"
        #endregion
        #region include "Image_Paramid_Argb_Templete.cs"
        #endregion
    }
    public partial struct Argb32
    {
        #region include "TPixel_Template.cs"
        #endregion
    }
}

 using TPixel = System.Byte;
 using TCache = System.Int32;
 using TKernel = System.Int32;
 using System;
 using System.Collections.Generic;
 using System.Text;
 namespace Geb.Image.Hidden
 {
     public abstract class Image_Template : UnmanagedImage<TPixel>
     {
         private Image_Template()
             : base(1,1)
         {
             throw new NotImplementedException();
         }
         #region mixin
         public unsafe TPixel* Start { get { return (TPixel*)this.StartIntPtr; } }
         public unsafe TPixel this[int index]
         {
             get
             {
                 return Start[index];
             }
             set
             {
                 Start[index] = value;
             }
         }
   
   ……
 
         #endregion
     }
 }

void SetAge(this T item,  int* age)

 namespace Introduce.Hide
 {
     using T = Person;
     public static class Template
     {
         #region mixin
         public static unsafe void SetAge(this T item,  int* age)
         {
             item.Age = *age;
         }
         #endregion
     }
 }

namespace Introduce
 {
     using T = Person;
     public static partial class PersonClassHelper
     {
         #region include "Template.cs"
         #endregion 
     }
 }

 namespace Introduce
 {
     using T = Cat;
     public static partial class CatClassHelper
     {
         #region include "Template.cs"
         #endregion
     }
 }

   public unsafe struct ItArgb32Old
    {
        public unsafe Argb32* Current;
        public unsafe Argb32* End;
        public unsafe Argb32* Next()
        {
            if (Current < End) return Current ++;
            else return null;
        }
    }
    public static class ImageArgb32Helper
    {
        public unsafe static ItArgb32Old CreateItorOld(this ImageArgb32 img)
        {
            ItArgb32Old itor = new ItArgb32Old();
            itor.Current = img.Start;
            itor.End = img.Start + img.Length;
            return itor;
        }
    }

     public unsafe struct ItArgb32
     {
         public unsafe Argb32* Start;
         public unsafe Argb32* End;
         public int Step(Argb32* ptr)
         {
             return 1;
         }
     }

   public unsafe static ItArgb32 CreateItor(this ImageArgb32 img)
     {
         ItArgb32 itor = new ItArgb32();
         itor.Start = img.Start;
         itor.End = img.Start + img.Length;
         return itor;
     }

   ItArgb32 itor = img.CreateItor();
     for (Argb32* p = itor.Start; p < itor.End; p+= itor.Step(p))
     {
         p->Red = 200;
     }

  public unsafe struct ItRoiArgb32
    {
        public unsafe Argb32* Start;
        public unsafe Argb32* End;
        public int Width;
        public int RoiWidth;
        public int Step(Argb32* ptr)
        {
            return Width;
        }
        public ItArgb32 Itor(Argb32* p)
        {
            ItArgb32 it = new ItArgb32();
            it.Start = p;
            it.End = p + RoiWidth;
            return it;
        }
    }

     public unsafe static ItRoiArgb32 CreateRoiItor(this ImageArgb32 img,
            int x, int y, int roiWidth, int roiHeight)
        {
            ItRoiArgb32 itor = new ItRoiArgb32();
            itor.Width = img.Width;
            itor.RoiWidth = roiWidth;
            itor.Start = img.Start + img.Width * y + x;
            itor.End = itor.Start + img.Width * roiHeight;
            return itor;
        }

 void ActionOnPixel(TPixel* p);

     public unsafe static UnmanagedImage<TPixel> ForEach(this UnmanagedImage<TPixel> src, ActionOnPixel handler)
        {
            TPixel* start = (TPixel*)src.StartIntPtr;
            TPixel* end = start + src.Length;
            while (start != end)
            {
                handler(start);
                ++start;
            }
            return src;
        }

img.ForEach((Argb32* p) => { p->Red = 200; });