知乎周源微信_每周源代码8

知乎周源微信

In my new ongoing quest to read source code to be a better developer, I now present the eighth an infinite number of a weekly series called "The Weekly Source Code." Here's some source I'm reading this week that I enjoyed.

在我的新不断追求阅读源代码，是一个更好的开发者，我现在提出的第八每周一系列名为无限数量的“每周源代码”。 这是我本周喜欢的一些资料。

• The Vista Battery Saver is a fun and simple little application that shuts off Aero and the Sidebar when you're running on batteries. The source is up at CodePlex. He registered his application with Windows for Power Notifications. Windows will send his application a Window Message when the system's power state changes.

  Vista Battery Saver是一个有趣且简单的小应用程序，当您使用电池运行时，它会关闭Aero和侧边栏。 源代码来自CodePlex。 他在Windows上为Power Notifications注册了他的应用程序。 当系统电源状态更改时，Windows将向其应用程序发送“窗口消息”。

    //In the main WinForm, he overrides the WndProc
    protected override void WndProc(ref Message m)
    {
         base.WndProc(ref m);
         if (m.Msg == PowerMngr.WM_POWERBROADCAST)
         {
             PowerMngr.GetManager().PowerSettingChange(m);
         }
    }

        //Earlier he selects the messages he's interested in.
        internal void RegisterForPowerNotifications(IntPtr hwnd)
        {
            hPowerSrc = RegisterPowerSettingNotification(hwnd,
            ref GUID_ACDC_POWER_SOURCE,
            DEVICE_NOTIFY_WINDOW_HANDLE);

            hBattCapacity = RegisterPowerSettingNotification(hwnd,
            ref GUID_BATTERY_PERCENTAGE_REMAINING,
            DEVICE_NOTIFY_WINDOW_HANDLE);

            hMonitorOn = RegisterPowerSettingNotification(hwnd,
            ref GUID_MONITOR_POWER_ON,
            DEVICE_NOTIFY_WINDOW_HANDLE);

            hPowerScheme = RegisterPowerSettingNotification(hwnd,
            ref GUID_POWERSCHEME_PERSONALITY,
            DEVICE_NOTIFY_WINDOW_HANDLE);
        }

        [DllImport(@"User32", SetLastError = true, EntryPoint = "RegisterPowerSettingNotification", CallingConvention = CallingConvention.StdCall)]
        private static extern IntPtr RegisterPowerSettingNotification(
            IntPtr hRecipient,
            ref Guid PowerSettingGuid,
            Int32 Flags);
  

• Patrick Smacchia released a Strongly Typed Path Library today. You know Patrick, he's NDepend-guy and he rocks. He includes a Class Diagram as well:

  Patrick Smacchia今天发布了“强类型路径库”。 你知道帕特里克，他是NDepend-guy，而且他很摇滚。 他还包括一个类图：

  

  Patrick Smacchia released a Strongly Typed Path Library today. You know Patrick, he's NDepend-guy and he rocks. He includes a Class Diagram as well:

  Patrick Smacchia今天发布了“强类型路径库”。 你知道帕特里克，他是NDepend-guy，而且他很摇滚。 他还包括一个类图：

  I'll let you go check it out, because you should. I think a class this smart would be a nice addition to the BCL. Here's some of his tests showing the usage of the library. Make careful note of the !'s inside the Asserts. They weren't totally obvious to me. I usually use == false. I find it easier to read.

  我会让你去检查，因为你应该。 我认为这门课很聪明，将是对BCL的不错补充。 这是他的一些测试，显示了库的用法。 仔细记下断言中的！。 他们对我来说不是很明显。 我通常使用== false。 我发现它更容易阅读。

•       //
        // Path string validation
        //
        string reason;
        Debug.Assert(PathHelper.IsValidAbsolutePath(@"C:\Dir2\Dir1", out reason));
        Debug.Assert(!PathHelper.IsValidAbsolutePath(@"C:\..\Dir1", out reason));
        Debug.Assert(!PathHelper.IsValidAbsolutePath(@".\Dir1", out reason));
        Debug.Assert(!PathHelper.IsValidAbsolutePath(@"1:\Dir1", out reason));
        Debug.Assert(PathHelper.IsValidRelativePath(@".\Dir1\Dir2", out reason));
        Debug.Assert(PathHelper.IsValidRelativePath(@"..\Dir1\Dir2", out reason));
        Debug.Assert(PathHelper.IsValidRelativePath(@".\Dir1\..\Dir2", out reason));
        Debug.Assert(!PathHelper.IsValidRelativePath(@".\Dir1\..\..\Dir2", out reason));
        Debug.Assert(!PathHelper.IsValidRelativePath(@"C:\Dir1\Dir2", out reason));
    

• I was talking to John Lam this week and he said: "BTW I’m having a ton of fun with C# 3.0 – it really is a beautiful language. Here’s an app that I wrote today that dumps all of our implemented Ruby methods to a YAML file." It'll be up on RubyForge later this week, but here's a snippet. It's about 100 lines and it takes a while to sink in. It's simple and it's a nice way to use LINQ against Reflection and the extension methods that use generics is nice and clean. Start at the Main() at the bottom and work your way around. Sure it could be shorter and hackier, but he appears to be balancing functionality with his own sense of aesthetic.

  我这周与约翰·林( John Lam )交谈时，他说：“顺便说一句，我对C＃3.0充满了乐趣–这确实是一种优美的语言。这是我今天编写的一个应用程序，它将我们所有已实现的Ruby方法转储到YAML文件。 “它将在本周晚些时候在RubyForge上发布，但这是一个代码段。 它大约有100行，需要花一些时间。它很简单，并且是对Reflect使用LINQ的好方法，而使用泛型的扩展方法又好又干净。 从底部的Main()开始，然后逐步解决。 当然，它可能会更短，更骇人，但他似乎在功能性和自己的审美意识之间取得了平衡。

• 
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Reflection;
  using System.Text;
  using Ruby;
  using Ruby.Extensions;
  using Microsoft.Scripting.Utils;
  using Ruby.Runtime;
  
  namespace IronRuby.Library.Scanner {
      static class ExtensionMethods {
          public static IEnumerable<T> SelectCustomAttributes<T>(this Type type) where T : Attribute {
              return type.GetCustomAttributes(typeof(T), false).Cast<T>();
          }
  
          public static IEnumerable<T> SelectCustomAttributes<T>(this MethodInfo method) where T : Attribute {
              return method.GetCustomAttributes(typeof(T), false).Cast<T>();
          }
      }
  
      class RubyClassInfo {
          public Type ClrType { get; set; }
  
          public delegate void Block(IEnumerable<RubyMethodAttribute> methods);
  
          public string Name {
              get { return ClrType.SelectCustomAttributes<RubyClassAttribute>().First().Name ?? ClrType.Name; }
          }
  
          private Type LookupExtensionModuleType(IncludesAttribute attr) {
              Type includedType;
              Program.ExtensionModules.TryGetValue(attr.Type, out includedType);
              return includedType ?? attr.Type;
          }
  
          private void GetMethodNames(Type t, Block accumulate) {
              var methods = (from m in t.GetMethods()
                             where m.IsDefined(typeof(RubyMethodAttribute), false)
                             select m.SelectCustomAttributes<RubyMethodAttribute>().First());
  
              accumulate(methods);
  
              foreach (IncludesAttribute attr in t.SelectCustomAttributes<IncludesAttribute>()) 
                  GetMethodNames(LookupExtensionModuleType(attr), accumulate);
          }
  
          private IEnumerable<string> GetMethodNames(RubyMethodAttributes methodType) {
              var result = new List<string>();
              GetMethodNames(ClrType, methods => 
                  result.AddRange((from m in methods
                                   where m.MethodAttributes == methodType 
                                   select m.Name).Distinct()));
              result.Sort();
              return result;
          }
  
          public IEnumerable<string> InstanceMethods {
              get { return GetMethodNames(RubyMethodAttributes.PublicInstance); }
          }
  
          public IEnumerable<string> SingletonMethods {
              get { return GetMethodNames(RubyMethodAttributes.PublicSingleton); }
          }
      }
  
      class Program {
          static IEnumerable<RubyClassInfo> GetRubyTypes(Assembly a) {
              return from rci in
                          (from t in a.GetTypes()
                           where t.IsDefined(typeof(RubyClassAttribute), false) 
                                 && !t.IsDefined(typeof(RubyExtensionModuleAttribute), false) 
                           select new RubyClassInfo { ClrType = t })
                     orderby rci.Name
                     select rci;
          }
  
          static Dictionary<Type, Type> GetExtensionModules(Assembly a) {
              var modules = from t in a.GetTypes()
                            where t.IsDefined(typeof(RubyExtensionModuleAttribute), false)
                            select new { Type = t, Attribute = t.SelectCustomAttributes<RubyExtensionModuleAttribute>().First() };
              
  
              var result = new Dictionary<Type, Type>();
              foreach(var m in modules)
                  result[m.Attribute.Extends] = m.Type;
              return result;
          }
  
          const string RubyAssembly = @"Ruby, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";
          internal static Dictionary<Type, Type> ExtensionModules;
  
          static void DumpMethods(IEnumerable<RubyClassInfo> types, Func<RubyClassInfo, IEnumerable<string>> getMethods) {
              foreach (RubyClassInfo rci in types) {
                  Console.WriteLine("{0}:", rci.Name);
                  foreach (string methodName in getMethods(rci))
                      Console.WriteLine("  - {0}", methodName);
              }
          }
  
          static void Main(string[] args) {
              var name = new AssemblyName(RubyAssembly);
              var a = Assembly.Load(name);
  
              ExtensionModules = GetExtensionModules(a);
              var types = GetRubyTypes(a);
  
              DumpMethods(types, t => t.InstanceMethods);
              DumpMethods(types, t => t.SingletonMethods);
          }
      }
  }
    

  Feel free to send me any links to cool source you find.

  随时给我发送任何链接到您找到的超酷资源的链接。

  翻译自: https://www.hanselman.com/blog/the-weekly-source-code-8

  知乎周源微信