OpenNETCF has a budget of about zero.  We've paid for absolutely no marketing whatsoever, so any “market awareness” is purely by word of mouth and search engine results. 

So tonight I got to wondering, many compaies pay thousands for search engine ranking and hire teams to better themselves.  I wonder how we're faring. Here are the results from some quick Google tests.  I list the search term and the placement we got:

Compact Framework : #2
Compact Framework Code : #1 (beating Microsoft even)
Compact Framework Samples : #15 (surprisingly low based on the last 2)
.NET Mobile : Not in first 50 (though DePaul University has a CF course, neat!)
Managed Code Mobile : #49
Pocket PC VB : #12
Pocket PC C# : #28
Pocket PC Managed : not in top 50
CE Managed Code : #7
Compact Framework Consulting : #4

So it seems that we've got pretty good placement for what I'd think are common search terms. I'd love to see higher ranking on some, but it seems we're getting more than we pay for.

As is typical, I started what I thought would be a simple project - providing managed access to a Sierra Wireless AirCard 555 CDMA modem from managed code. I did a basic eVB wrapper in COM for it about a year ago and figured it was going to be cake. Little did I know...

The first problem is that it needed a native callback.  Second, that callback takes a union parameter, which has some 50+ members.  Third, the few pieces of info retrieved without the callback would be used to update a UI and had long retrieval times, so retrieval must be on a Thread, yet most users won't want to deal with using Invoke for everything.

So the short story is that it took a lot longer to develop than originally planned.  I guess that's how development typically works.

It's only been through light testing, and I still need to add a lot of XML comments and run it through NDOC, but it's pretty much complete.  This is going to be a for-sale product through OpenNETCF Consulting, the “commercial arm“ of the OpenNETCF project (we've got to pay the bills somehow).  If you're interested, email us.

Here's a snapshot of my test harness, which gives you an idea of the properties exposed.

Anyone taken the time to test out this sample code in the CF and see how it compares to the full framework?  I was surprised at the desktop results, and if it's true for the CF then I'd like to be aware of it.  Does the JITter use registers for locals when available?  If so, how many registers (the FFW has 64 of them)?  Is it processor dependent?

You're probably aware that using dumpbin.exe is very useful if you need to P/Invoke.  dumpbinGUI.exe is a tool that I've been using for years that you might be interested in.  It adds a simply context menu to the Windows shell, so you can right click any DLL or LIB and view it's exports (among other things).

The install leaves a bit to be desired.  You have to have a dev tool installed, and you must modify your path to allow dumpbinGUI to find a couple files.  If you have Studio 2003 installed in the default location, add these to your system path:

C:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\bin
C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\IDE

For those of you who may ever need to interface to a DS1307 I2C real time clock (it would wourk for the 1306 SPI RTC as well) here's a useful class.

private class RTCTime
{
 private byte[] m_bytes = new byte[7];
 
 public RTCTime()
 {
 }
 public RTCTime(byte[] data)
 {
  m_bytes = data;
 }
 public RTCTime(DateTime dateTime)
 {
  this.Second = dateTime.Second;
  this.Minute = dateTime.Minute;
  this.Hour = dateTime.Hour;
  this.Day = dateTime.Day;
  this.Month = dateTime.Month;
  this.Year = dateTime.Year;
 }
 public static implicit operator byte[](RTCTime rtc)
 {
  return rtc.m_bytes;
 }
 public static implicit operator RTCTime(byte[] bytes)
 {
  return new RTCTime(bytes);
 }
 public static explicit operator DateTime(RTCTime rtc)
 {
  return new DateTime(rtc.Year, rtc.Month, rtc.Day, rtc.Hour, rtc.Minute, rtc.Second, 0);
 }
 public int Second
 {
  get { return BCD_TO_WORD(m_bytes[0]); }
  set { m_bytes[0] = WORD_TO_BCD(value); }
 }
 public int Minute
 {
  get { return BCD_TO_WORD(m_bytes[1]); }
  set { m_bytes[1] = WORD_TO_BCD(value); }
 }
 public int Hour
 {
  get { return BCD_TO_WORD(m_bytes[2]); }
  set { m_bytes[2] = WORD_TO_BCD(value); }
 }
 public int DayOfWeek
 {
  get { return BCD_TO_WORD(m_bytes[3]); }
  set { m_bytes[3] = WORD_TO_BCD(value); }
 }
 public int Day
 {
  get { return BCD_TO_WORD(m_bytes[4]); }
  set { m_bytes[4] = WORD_TO_BCD(value); }
 }
 public int Month
 {
  get { return BCD_TO_WORD(m_bytes[5]); }
  set { m_bytes[5] = WORD_TO_BCD(value); }
 }
 public int Year
 {
  get { return BCD_TO_WORD(m_bytes[6]); }
  set { m_bytes[6] = WORD_TO_BCD(value); }
 }
 public int Length
 {
  get { return m_bytes.Length; }
 }
 private int BCD_TO_WORD(byte x)
 {
  return (x & 0x0f) + ((x >> 4) * 10);
 }
 private byte WORD_TO_BCD(int x)
 {
  return (byte)((x % 10) + ((x / 10) * 0x10));
 }
}

Pocket PC magazine has published an article by Mick Badran of Breeze Training that uses the SDF (though they called it the Smart Device Extensions - remember back when the CF was called that?).  An online version is available here.