我的高效编程秘诀

DanielBMarkham曾发表博文《To code quickly, you must quit coding》，文中他为我们分享了高效编程的几个秘诀。《外刊IT评论》对本文进行了翻译，现转载于此，全文如下：

昨天我做了一些事情使我的编程效率提高了一倍。简单，容易，但使我的生活发生了巨大的变化。

你们中可能有些人已经知道我是怎么做的。对于其他的人，这听起来有些疯狂。

我不持续工作。

或者，我把定时器设置成50分钟，在此期间我只干一件事——没Email，没聊天工具，没游戏，没分心的事。50分钟后，我去散步。

它使我效率增倍。而且作为一个副作用，它使我的工作更加快乐。

我知道你们中的很多人在想什么。无论何时这个(或其它特别的Pomodoro技巧)被提及时，我都会听到各种的常见的怀疑声。

那就让我们一一看来：

这样做不会使我的注意力不能集中在我正要努力解决的难题上吗？很奇怪，跟你的直觉相反，不会。当你做其它的事情来放松你的神经时，你的大脑却仍然在思考你的问题。很多次，思路豁然开朗，把很多一直都无法解决的难题都解决掉了，这是因为你开始从远处观察这个问题，在大背景下，而不是紧紧的死揪着某处。

你是怎么停下来的？当我编程时我从来不看表。昨天我使用的是微波炉的定时器，但我工作效率上的变化使我大为震惊，我买了一个秒表，就是上面图中的那个。

我的生活中有太多的各种各样的打搅我的事情，邮件，聊天工具，电话短信。你的方法对我不管用。我有个原则：在我的工作时间里不允许有分心的东西。当我休息完后，我会花几分钟把这种分心的事情处理掉：检查邮件，回复聊天软件里的消息，回电话。当把这些事情全做完后我才开始启动定时器。

看起来它会给我的生活带来不必要的压力。的确会，但却是积极性质的。我发现自己急切的想知道在每个工作时间段里 能究竟能做多少工作。我不由的开始把工作细化成更小的模块，催促自己看是否能在这时间段里完成这个模块。但这没有压力。我有个更好的词来描述督促自己把工 作完成的更好更高效的现象：愉快。我很愉快。它把难题变成了游戏。

工作后你会用多长时间来休闲？ 我不知道。这难住我了。我会去散步 — 一个足够长的散步，至少10分钟。有时我会到阳台上，吃个橘子，听听大自然的声音。有时我会把秒表倒计时10分钟，以免我回来的太早。

在休息时间我可以做任何想做的活动吗？ 我想不能。我觉得你必须只做一种活动，让你大脑闲置的活动。散步，乒乓，玩乐器，发呆，打盹。考虑那些温和的、有目标挑战的活动 — 特别是户外的 — 效果会更好，但这只是我的猜测。

这里有什么秘密？ 秘密，以我个人的见解，是当你强迫大脑释放缠绕很久的问题时，潜意识里会使它缠绕的更紧：你的大脑强烈希望回到问题上。于是它会一直研究它，思考它。你越 使你的大脑从工作上拽走，它就越强的返回到工作中。越是特意的停止工作，你越更多的投入到问题中，你把思想带离工作越远，思想会越想回去。这比起你死盯着 电脑屏幕/敲出一堆垃圾代码来，你的大脑会更有效率的多。退一步，海阔天空。我可以保证，当你又重新回到座位上坐下来时，你会有各种更好的该怎么样做的想 法。就像是有一个小程序、设计评审程序，当你在玩乐时，在你的大脑深处后台运行，帮你思考问题。

如果你非常的聪明，怎么会想到要依赖这样的做法？ 这个嘛。这里我的故事要转向说一下坏的事情：我过去做事情也是这样“玩玩干干”！事实上，我的工作时间和娱乐时间的分配已经无法控制。我以前编程就像是在受煎熬。我决定要改变。

为什么？因为我发现当浏览器变得越来越友好，计算机变得约来越使人分心时，我开始在潜意识里把计算机的娱乐功能和工作功能混淆在一起了。我工作一会儿，就去看看骇客新闻，再去读几篇有趣的文章，然后再工作一会儿，然后写几条评论，然后看看邮件，等等。

回头一想我在做什么？很显然：我正在拿各种各样新鲜刺激的事物过程来轰炸我的大脑。我的大脑不能工作在我的“主要”问题上，因为我忙着来回折腾在数 十个不同的产生刺激因素的事物过程中。事后你会发现这最后的结果是把一心只放到一件编程事情上的情况转变成一心放在了很多事情上，而这些事情都跟编程没有 关系。如果你喜欢使用计算机进行娱乐活动，你可以在工作前，午餐时，或工作休息期间。我越观察现代的计算机活动，我越相信计算机功能繁多、使娱乐更方便的 性质已经严重的跟它作为一种能够生产工作的机器的用途相抵触了。几年来，我甚至慢慢的停止了赛场运动，约来越多的时间“沉浸”在了计算机世界里。这对你的 大脑不是件好事，请相信我。

这是一个很简单的事情，你也许会很难想象到它会有什么用处。但请给自己一次机会 — 谁能预料你会有什么发现呢？

作为一个边注，从所有的这些事情，我发现物理的把你的电子设备按功能分离开也许是另外一个能提高你的工作效率的好方法。(这是一个防止你把消极的电子设备和消极的设备之间的界限弄混淆的方法)

如何让编程效率提高了一倍，高效编程的秘诀有什么呢？不持续工作，集中精力干50分钟后就去散步。是作者总结出的提高编程效率的一个秘诀。

以上是DanielBMarkham的观点

对高效编程每个人都有 不同观点.

举个图形操作例子:

需要用到获取或设置像素颜色方法：GetPixel 和 SetPixel，如果直接对这两个方法进行操作的话速度很慢

图形操作有两种方式，1是内存法，2是指针法.

[code]1、内存法
 public class LockBp
        {
            Bitmap source = null;
            IntPtr Iptr = IntPtr.Zero;
            BitmapData bitmapData = null;

            public byte[] Pixels { get; set; }
            public int Depth { get; private set; }
            public int Width { get; private set; }
            public int Height { get; private set; }

            public LockBp(Bitmap source)
            {
                this.source = source;
            }

            /// <summary>
            /// Lock bitmap data
            /// </summary>
            public void LockBits()
            {
                try
                {
                    // Get width and height of bitmap
                    Width = source.Width;
                    Height = source.Height;

                    // get total locked pixels count
                    int PixelCount = Width * Height;

                    // Create rectangle to lock
                    Rectangle rect = new Rectangle(0, 0, Width, Height);

                    // get source bitmap pixel format size
                    Depth = System.Drawing.Bitmap.GetPixelFormatSize(source.PixelFormat);

                    // Check if bpp (Bits Per Pixel) is 8, 24, or 32
                    if (Depth != 8 && Depth != 24 && Depth != 32)
                    {
                        throw new ArgumentException("Only 8, 24 and 32 bpp images are supported.");
                    }

                    // Lock bitmap and return bitmap data
                    bitmapData = source.LockBits(rect, ImageLockMode.ReadWrite,
                                                 source.PixelFormat);

                    // create byte array to copy pixel values
                    int step = Depth / 8;
                    Pixels = new byte[PixelCount * step];
                    Iptr = bitmapData.Scan0;

                    // Copy data from pointer to array
                    Marshal.Copy(Iptr, Pixels, 0, Pixels.Length);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }

            /// <summary>
            /// Unlock bitmap data
            /// </summary>
            public void UnlockBits()
            {
                try
                {
                    // Copy data from byte array to pointer
                    Marshal.Copy(Pixels, 0, Iptr, Pixels.Length);

                    // Unlock bitmap data
                    source.UnlockBits(bitmapData);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }

            /// <summary>
            /// Get the color of the specified pixel
            /// </summary>
            /// <param name="x"></param>
            /// <param name="y"></param>
            /// <returns></returns>
            public Color GetPixel(int x, int y)
            {
                Color clr = Color.Empty;

                // Get color components count
                int cCount = Depth / 8;

                // Get start index of the specified pixel
                int i = ((y * Width) + x) * cCount;

                if (i > Pixels.Length - cCount)
                    throw new IndexOutOfRangeException();

                if (Depth == 32) // For 32 bpp get Red, Green, Blue and Alpha
                {
                    byte b = Pixels[i];
                    byte g = Pixels[i + 1];
                    byte r = Pixels[i + 2];
                    byte a = Pixels[i + 3]; // a
                    clr = Color.FromArgb(a, r, g, b);
                }
                if (Depth == 24) // For 24 bpp get Red, Green and Blue
                {
                    byte b = Pixels[i];
                    byte g = Pixels[i + 1];
                    byte r = Pixels[i + 2];
                    clr = Color.FromArgb(r, g, b);
                }
                if (Depth == 8)
                // For 8 bpp get color value (Red, Green and Blue values are the same)
                {
                    byte c = Pixels[i];
                    clr = Color.FromArgb(c, c, c);
                }
                return clr;
            }

            /// <summary>
            /// Set the color of the specified pixel
            /// </summary>
            /// <param name="x"></param>
            /// <param name="y"></param>
            /// <param name="color"></param>
            public void SetPixel(int x, int y, Color color)
            {
                // Get color components count
                int cCount = Depth / 8;

                // Get start index of the specified pixel
                int i = ((y * Width) + x) * cCount;

                if (Depth == 32) // For 32 bpp set Red, Green, Blue and Alpha
                {
                    Pixels[i] = color.B;
                    Pixels[i + 1] = color.G;
                    Pixels[i + 2] = color.R;
                    Pixels[i + 3] = color.A;
                }
                if (Depth == 24) // For 24 bpp set Red, Green and Blue
                {
                    Pixels[i] = color.B;
                    Pixels[i + 1] = color.G;
                    Pixels[i + 2] = color.R;
                }
                if (Depth == 8)
                // For 8 bpp set color value (Red, Green and Blue values are the same)
                {
                    Pixels[i] = color.B;
                }
            }
        }

　　使用：先锁定Bitmap，然后通过Pixels操作颜色对象，最后释放锁，把数据更新到Bitmap中

            string file = @"H:\lo.jpg";
            Bitmap bmp = new Bitmap(Image.FromFile(file));

            LockBp lockbmp = new LockBp(bmp);
            //锁定Bitmap，通过Pixel访问颜色
            lockbmp.LockBits();

            //获取颜色
            Color color = lockbmp.GetPixel(10, 10);

            //从内存解锁Bitmap
            lockbmp.UnlockBits();

2、指针法

这种方法访问速度比内存法更快，直接通过指针对内存进行操作，不需要进行拷贝，但是在C# 中直接通过指针操作内存是不安全的，所以需要在代码中加入unsafe关键字，在生成选项中把允许不安全代码勾上，才能编译通过

[code]  public class PointBitmap
            {
                Bitmap source = null;
                IntPtr Iptr = IntPtr.Zero;
                BitmapData bitmapData = null;

                public int Depth { get; private set; }
                public int Width { get; private set; }
                public int Height { get; private set; }

                public PointBitmap(Bitmap source)
                {
                    this.source = source;
                }

                public void LockBits()
                {
                    try
                    {
                        // Get width and height of bitmap
                        Width = source.Width;
                        Height = source.Height;

                        // get total locked pixels count
                        int PixelCount = Width * Height;

                        // Create rectangle to lock
                        Rectangle rect = new Rectangle(0, 0, Width, Height);

                        // get source bitmap pixel format size
                        Depth = System.Drawing.Bitmap.GetPixelFormatSize(source.PixelFormat);

                        // Check if bpp (Bits Per Pixel) is 8, 24, or 32
                        if (Depth != 8 && Depth != 24 && Depth != 32)
                        {
                            throw new ArgumentException("Only 8, 24 and 32 bpp images are supported.");
                        }

                        // Lock bitmap and return bitmap data
                        bitmapData = source.LockBits(rect, ImageLockMode.ReadWrite,
                                                     source.PixelFormat);

                        //得到首地址
                        unsafe
                        {
                            Iptr = bitmapData.Scan0;
                            //二维图像循环

                        }
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                }

                public void UnlockBits()
                {
                    try
                    {
                        source.UnlockBits(bitmapData);
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                }

                public Color GetPixel(int x, int y)
                {
                    unsafe
                    {
                        byte* ptr = (byte*)Iptr;
                        ptr = ptr + bitmapData.Stride * y;
                        ptr += Depth * x / 8;
                        Color c = Color.Empty;
                        if (Depth == 32)
                        {
                            int a = ptr[3];
                            int r = ptr[2];
                            int g = ptr[1];
                            int b = ptr[0];
                            c = Color.FromArgb(a, r, g, b);
                        }
                        else if (Depth == 24)
                        {
                            int r = ptr[2];
                            int g = ptr[1];
                            int b = ptr[0];
                            c = Color.FromArgb(r, g, b);
                        }
                        else if (Depth == 8)
                        {
                            int r = ptr[0];
                            c = Color.FromArgb(r, r, r);
                        }
                        return c;
                    }
                }

                public void SetPixel(int x, int y, Color c)
                {
                    unsafe
                    {
                        byte* ptr = (byte*)Iptr;
                        ptr = ptr + bitmapData.Stride * y;
                        ptr += Depth * x / 8;
                        if (Depth == 32)
                        {
                            ptr[3] = c.A;
                            ptr[2] = c.R;
                            ptr[1] = c.G;
                            ptr[0] = c.B;
                        }
                        else if (Depth == 24)
                        {
                            ptr[2] = c.R;
                            ptr[1] = c.G;
                            ptr[0] = c.B;
                        }
                        else if (Depth == 8)
                        {
                            ptr[2] = c.R;
                            ptr[1] = c.G;
                            ptr[0] = c.B;
                        }
                    }
                }
            }

还有一些c#秘诀

以前的代码是这样写的

[code]public class Pers
    {

        private string _trueName;
        private string _nickName;
        private int _age;

        public string TrueName 
        {
            get {
                return _trueName;
            }
            set {
                _trueName= value;
            }
        }

        public string NickName 
        {
            get {
                return _nickName;
            }
            set {
                _nickName= value;
            }
        }

        public int Age 
        {

            get {
                return _age;
            }
            set {
                _age = value;
            }
        }
    }

后来08可以这样写

[code]public class Pers
    {
        public string TrueName {    get; set;        }
        public string NickName {    get; set;        }
        public int Age {     get; set;        }
    }

以前是

[code] Pers person = new Pers();
   person.TrueName = "Csdn";
   person.NickName = "全球最大中文IT社区";
   person.Age = 16;

现在可以:

[code] Persperson = new Pers { TrueName="Csdn", NickName = "全球最大中文IT社区", Age=16 }; //一行搞定,真是方便!

[code]List<Pers> people = new List<Pers> {
      new Person { TrueName = "Csdn", NickName = "全球最大中文IT社区", Age = 16 },
      new Person { TrueName = "BillG", NickName = "比尔大哥", Age = 40 },
      new Person { TrueName = "Jim", NickName = "帅哥", Age = 20 }
   };

秘诀千变万化，高效是编码速度，程序运行速度是一个软件是否得到更多人使用。