Jeremy Hance : Samples / Snippets

A Simple Resource Helper Class

jehance — Fri, 01 Jul 2005 21:09:00 GMT

using System;
using System.Reflection;
using System.IO;
using System.Runtime.CompilerServices;

/// <summary>
/// A simple helper class for extracting Resources from the
/// calling assembly
/// </summary>

public class ResourceHelper
{
   private static Stream GetStream(Assembly assembly, string ResourceName)
   {
      if (ResourceName != null && ResourceName.Trim() != string.Empty)
      {
         ResourceName = ResourceName.Trim();
         foreach (string name in assembly.GetManifestResourceNames())
            if (string.Compare(ResourceName, name, true) == 0)
               return assembly.GetManifestResourceStream(name);

         ResourceName = ResourceName.ToUpper();
         foreach (string name in assembly.GetManifestResourceNames())
            if (name.ToUpper().IndexOf(ResourceName) >= 0;
               return assembly.GetManifestResourceStream(name);
      }

return new MemoryStream(new byte[0], false);
}

   /// <summary>
   /// Returns the requested resource as a Stream
   /// </summary>
   /// <param name="ResourceName">
   /// The name of the resource to retrieve
   /// </param>
   /// <returns>
   /// A stream for the requested resource on success.
   /// An empty stream on failure
   /// </returns>
   /// <remarks>
   /// GetStream first searches for an exact, case insensitive
   /// match to ResourceName. If the initial search fails,|
   /// GetStream will search again and return the first
   /// resource for which ResourceName is a case insensitive
   /// sub-string
   /// </remarks>
   [MethodImpl(MethodImplOptions.NoInlining)]
   public static Stream GetStream(string ResourceName)
   {
      return GetStream(Assembly.GetCallingAssembly(), ResourceName);
   }

   /// <summary>
   /// Returns the requested resource as a byte[]
   /// </summary>
   /// <param name="ResourceName">
   /// The name of the resource to retrieve
   /// </param>
   /// <returns>
   /// A byte[] for the requested resource on success.
   /// An empty byte[] on failure</returns>
   /// <remarks>
   /// GetBytes first searches for an exact, case insensitive
   /// match to ResourceName. If the initial search fails,
   /// GetBytes will search again and return the first
   /// resource for which ResourceName is a case insensitive
   /// sub-string
   /// </remarks>
   [MethodImpl(MethodImplOptions.NoInlining)]
   public static byte[] GetBytes(string ResourceName)
   {
      Stream s = GetStream(Assembly.GetCallingAssembly(), ResourceName);
      byte[] bytes = new byte[s.Length];
      s.Read(bytes, 0, bytes.Length);
      s.Close();
      return bytes;
   }
}

--- jeh
This post is provided “As Is”, with no warranties, and confers no rights.

PocketOutlook and COM Interop

jehance — Thu, 12 Aug 2004 23:23:00 GMT

New to the .NET Compact Framework in Whidbey Beta 1 is a feature known as COM Interop. Among other things, this feature allows simple managed access to a number of Native APIs, including the Pocket Outlook Object Model (POOM). Steven has posted a great article on getting POOM into your Whidbey project (I highly recommend reading it here.)

I thought I'd take some time to focus on Step 4 of Steven's article, "Write your POOM application". After all, once you've gotten the PocketOutlook Interop Assembly references, it's time to do something with it.

Two resources I've found to be invaluable are the Pocket Outlook Object Model Documentation at MSDN, and the Object Browser within Whidbey itself.

If you're not familiar with the Object Browser, take some time to get acquainted with it once you've referenced the Pocket Outlook Interop Assembly. All assemblies and their namespaces are listed in the browser.

By expanding the namespace, you can look at individual classes and interfaces, and see not only their methods, by also the signatures as they have been imported by TLBIMP. And, of course, through the magic that is intellisense, you get full intellisense for the POOM classes and methods.

For my application, I chose to write a simple managed Task Viewer. One drawback of the task viewer that ships with Windows Mobile is that there's no way to both view and edit tasks at the same time.

With approximately 2 hours of coding, I was able to produce the application pictured to the left. The ListView shows all the tasks on the system (the same tasks that will show in the task viewer that ships with Windows Mobile). The fields at the bottom will allow the user to add new tasks, or edit existing tasks after selecting them in the ListView. Using the context menu on the ListView, the user can mark tasks as complete (which highlights them with a dark grey), or delete them.

Changes made to the tasks via this application are reflected in the task viewer integrated into Windows Mobile. The app stores no information internally, but rather makes all updates, and retrieves all displayed items, directly with POOM.

The code for this program (not counting that code automatically generated by the Windows Designer) is well under 300 lines (including white space for readability), and as you can well imagine, the majority of the code I wrote manipulates the UI. Less than 40 lines of C# code were required to manipulate POOM in the ways I've described.

The code required to activate the POOM Application object, logon, and retrieve the the Task Folder is as simple as:

// Get the application class and the tasksFolder
ApplicationClass outlookApp = new ApplicationClass();
outlookApp.Logon(0);
IFolder tasksFolder = outlookApp.GetDefaultFolder(OlDefaultFolders.olFolderTasks);

You can find TaskViewer.cs here. Please feel free to send me any questions regarding this application, or using COM Interop with POOM.

A Simple Device ID Class

jehance — Mon, 12 Jul 2004 21:17:00 GMT

I've received a number of questions regarding how best to retrieve the Device ID. As a result, I've decided to provide the following class for your coding pleasure:

--- jeh
This posting is provided “AS IS“, without warranties, and confers no rights.

using System;
using System.Runtime.InteropServices;

namespace DeviceID
{
public sealed class DeviceIDException : Exception
{
  public DeviceIDException() : base() {}
  public DeviceIDException(string message) : base(message) {}
  public DeviceIDException(string message, Exception innerException) : base(message, innerException) {}
}

/// <summary>
/// Summary description for DeviceID.
/// </summary>
public sealed class DeviceID
{
  private const int GuidLength = 16;
  private const Int32 ERROR_NOT_SUPPORTED = 0x32;
  private const Int32 ERROR_INSUFFICIENT_BUFFER = 0x7A;
  private const Int32 IOCTL_HAL_GET_DEVICEID = 0x01010054;

  private byte[] idBytes = null;
  private Guid   idGuid   = Guid.Empty;
  private string idString = String.Empty;

  public DeviceID()
  {
   byte[] buffer = new byte[20];
   bool idLoaded = false;
   uint bytesReturned;

   while(!idLoaded)
   {
    Array.Copy(BitConverter.GetBytes(buffer.Length), 0, buffer, 0, 4);

    try
    {
     idLoaded = KernelIoControl(IOCTL_HAL_GET_DEVICEID, 0, 0, buffer, (uint)buffer.Length, out bytesReturned);
    }
    catch (Exception e)
    {
     throw new DeviceIDException("This platform may not support DeviceIDs", e);
    }

    if(!idLoaded)
    {
     int error = Marshal.GetLastWin32Error();

     if(error == ERROR_INSUFFICIENT_BUFFER)
     {
      buffer = new byte[BitConverter.ToUInt32(buffer, 0)];
     }
     else
     {
      // Some older PPC devices only return the ID if the buffer
      // is exactly the size of a GUID, so attempt to retrieve
      // the ID this way before throwing an exception
      buffer = new byte[GuidLength];
      idLoaded = KernelIoControl(IOCTL_HAL_GET_DEVICEID, 0, 0, buffer, GuidLength, out bytesReturned);

      if(idLoaded)
      {
       InitializeFromBytes(buffer);
       return;
      }
      else
      {
       if(error == ERROR_NOT_SUPPORTED)
       {
        throw new DeviceIDException("This platform does not support DeviceIDs");
       }
       else
       {
        throw new DeviceIDException(String.Format(
         "Error Encountered Retrieving ID (0x{0})", error.ToString("X8")));
       }
      }
     }
    }
   }

   int dwPresetIDOffset = BitConverter.ToInt32(buffer, 4);
   int dwPresetIDBytes = BitConverter.ToInt32(buffer, 8);
   int dwPlatformIDOffset = BitConverter.ToInt32(buffer, 12);
   int dwPlatformIDBytes = BitConverter.ToInt32(buffer, 16);

   idBytes = new byte[dwPresetIDBytes + dwPlatformIDBytes];

   Array.Copy(buffer, dwPresetIDOffset, idBytes, 0, dwPresetIDBytes);
   Array.Copy(buffer, dwPlatformIDOffset, idBytes, dwPresetIDBytes, dwPlatformIDBytes);
  }

  public DeviceID(Guid g)
  {
   idBytes = g.ToByteArray();
   idGuid = g;
  }

  public DeviceID(byte[] bytes)
  {
   InitializeFromBytes(bytes);
  }

  private void InitializeFromBytes(byte[] bytes)
  {
   idBytes = new byte[bytes.Length];
   Array.Copy(bytes, 0, idBytes, 0, bytes.Length);
  }

  /// <summary>
  /// DeviceIDs are only guaranteed to be Guids on PPC. On generic Windows CE, they can be
  /// any unspecified length
  /// </summary>
  public bool IsGuid
  {
   get
   {
    return (idBytes.Length == GuidLength);
   }
  }

  public Guid Guid
  {
   get
   {
    if(IsGuid)
    {
     if(idGuid == Guid.Empty)
     {
      idGuid = new Guid(idBytes);
     }

     return idGuid;
    }
    else
    {
     throw new DeviceIDException(String.Format("The DeviceID {0} is not a Guid", ToString()));
    }
   }
  }

  public override bool Equals(object obj)
  {
   if(obj is DeviceID)
   {
    DeviceID rhs = (DeviceID)obj;

    if(idBytes.Length == rhs.idBytes.Length)
    {
     for(int i = 0; i < idBytes.Length; i++)
     {
      if(idBytes[i] != rhs.idBytes[i])
      {
       return false;
      }
     }

     return true;
    }
   }

   return false;
  }

  public override int GetHashCode()
  {
   if(IsGuid)
   {
    return this.Guid.GetHashCode();
   }
   else
   {
    // The default GetHashCode for object is guaranteed to
    // always be the same for a given object, but not for
    // multiple objects with the same value. We want a HashCode
    // that will always be the same for a given ID
    byte[] tempbytes = new byte[16];
    if(idBytes.Length > 16)
    {
     Array.Copy(idBytes, 0, tempbytes, 0, 16);
    }
    else
    {
     Array.Clear(tempbytes, 0, 16); // Should be unneccessary
     Array.Copy(idBytes, 0, tempbytes, 0, idBytes.Length);
    }

    return (new Guid(tempbytes)).GetHashCode();
   }
  }

  public override string ToString()
  {
   if(idString == String.Empty)
   {
    if(IsGuid)
    {
     idString = this.Guid.ToString();
    }

    else
    {
     idString = "";

     for(int i = 0; i < idBytes.Length; i++)
     {
      if(i == 4 || i == 6 || i == 8 || i == 10)
      {
       idString = String.Format("{0}-{1}", idString, idBytes[i].ToString("x2"));
      }
      else
      {
       idString = String.Format("{0}{1}", idString, idBytes[i].ToString("x2"));
      }
     }
    }
   }

   return idString;
  }

  public byte[] ToByteArray()
  {
   byte[] cpyBytes = new byte[idBytes.Length];
   Array.Copy(idBytes, 0, cpyBytes, 0, idBytes.Length);
   return cpyBytes;
  }

  [DllImport("coredll.dll", SetLastError=true)]
  private static extern bool KernelIoControl(
             uint dwIoControlCode,
             uint lpInBuf /* set to 0 */,
             uint nInBufSize /* set to 0 */,
   [In, Out] byte[] lpOutBuf,
             uint nOutBufSize,
   out     uint lpBytesReturned);
}
}