First off, a bit of a disclaimer – I admit that I am using Visual Studio 2010 (Beta 2) and Office 2010 (Beta); as such I shouldn’t expect all documentation for them to be complete or everything to being running bug free.

With that said: Begin the rant!

Today I decided to attempt to build an Outlook 2010 add in that would enable me to "block" particular authors on RSS Feeds. The reason I wanted to do this is that I am subscribed to the TechNet, ASP.NET, MSDN and Windows Team combined feeds – these 4 "combined" feeds are a collation of quite a number of blogs by Microsoft. The unfortunate thing is than a number of the blogs are completely irrelevant to me, or in a foreign language. With my Add In I could then block the non-English and irrelevant authors without having to create a-hundred-and-one "rules". So, what went wrong?

First off, there is no "RSS" class.
RSS items are of type PostItem or, more specifically, have a MessageClass or IPM.Post.RSS. So while it is possible to tell that an individual Post item is an RSS item (by doing a string comparison), its impossible to filter or check folders. This isn’t a *big* thing, but it certainly is very annoying.

Don’t use the classes, use the interfaces.
For every VBA class, there is a .NET Interface AND a class; for instance there is an Outlook.PostItem (Interface) and Outlook.PostItemClass (Class). So which to use? Apparently the interface is the one to use, I think. The classes are apparently "COM coclasses that are required for interoperability with the corresponding COM object" – which to me sounds like an Infrastructure class, which is fine if it is private or internal, NOT public. Also, in case you didn’t notice, to add insult to injury there is a class with the word "Class" in its name that is referring to the fact it is a class (and the interface isn’t prefixed with an "I" – but we’ll forgive that).

The documentation is incomplete.
And its not just the 2010 documentation that is incomplete. To use the example above, lets have a look at the PostItem Interface members (Go, click on the link and have a look. I’ll wait right here. Done?). That’s right – they’re empty. But IntelliSense in Visual Studio (and the actual API) tell a different story. Ok, lets assume that (being programmers) they’re lazy. maybe the documentation is in the PostItemClass Class (Again, click on the link…). Hmm…. apparently all of the Properties, Methods and Events do the same thing… which is the same thing as the Class…
Oh, and in the name of fairness, reopen one of those links and check the version of Office the documentation is for. That’s right, 2007.

And, the Pièce de résistance:
Apparently Outlook is now Access in Office 2010 (click on the "Outlook 2010" link) (also, Bing’s cached version, just in case)

A couple of weeks ago I was in New York to visit customers and attend the co-located Interop and Web 2.0 events.  One of the attendees/participants I got to know there was Joe Weinman, VP of ATT’s Business Solutions.  Joe has been focusing a lot on the cloud lately so I thought I’d put down for posterity his thoughts and explanation of what ATT is up to in this space.

Some of the topics that Joe tackles:

• ATT’s evolving strategy involves mix of managed endpoints and a variety of network services as well as a variety of services in the cloud.
• ATT’s services range from infrastructure services like “Synaptic hosting,” storage as a service and compute as a service thru a variety of SaaS apps like unified comms and collaboration,  SAP,  Oracle ebiz suite, Seybold and JD Edwards.
• They have a large platform as a service offering that is used by tens of thousands developers creating at mobile enterprise apps.
• They target a wide variety of endpoints e.g.  iphones,windows mobile devices,  netbooks, black berries  all the way thru tele-presence rooms.
• How ATT delivers on both front end and back end architectures.

Pau for now…

The Burton Group and Xirrus are offering a FREE educational webinar today (Wednesday, Dec 2nd) on the newly ratified IEEE wireless standard, 802.11n.  I delivered the Xirrus portion of this presentation at INTEROP New York a couple weeks ago, so I can tell you it’s packed with great information. 

“802.11n: Lessons Learned from the First 1,000 Xirrus Installations”

Date: Wednesday, December 2, 2009
Time: 11:00 am PT / 2:00 pm ET / 7:00 pm UK

Speakers:

Paul DeBeasi, Senior Analyst, Burton Group

Kurt Sauter, Director of Product Marketing, Xirrus

The webinar is posted on the Xirrus webinars page: http://www.xirrus.com/library/webinars.php

You can use the below to register:

http://event.on24.com/r.htm?e=180563&s=1&k=6A1C2263406C5508E18B12C79EF90978

This webinar will discuss:

• Features that the first generation 11n products provide
• Site Survey Issues
• Performance Expectations
• Network and Architecture Considerations
• Client Device Considerations
• Security Issues
• Overall Recommendations

The webinar will be archived on the Xirrus website, and anyone will be able to listen/view after the live event.

The New York Times’ columnist entertains IT types with a parody of “Ooops!… I did it again.”

Pogue at Interop. Photo: Philip Elmer-DeWitt

David Pogue may review technology for a living, but give him half a chance and he’ll revert to his first love: show tunes.

He did it again Wednesday, ending his Interop New York 2009 keynote at the Javits Center with one of his patented song parodies: “Apps!… I did it again,” a Britney Spears classic (if there is such a thing) rewritten for the age of the Apple (AAPL) iPhone.

The performance followed an address that entertained mostly by accident. In what he described in advance as an “exercise in idiocy,” he attempted 15 live demos of his favorite gadgets and apps.

We lost track of how many failed, but it seemed like more than half. “Dr. Kevorkian, call me now!” he cried after one of his simplest — a demo of Google Info (800-GOOG-411) — was foiled by Interop’s overloaded Wi-Fi circuits.

Below the fold: Pogue at the electric piano.

UPDATE: Pogue helpfully provided by e-mail this list of the 14 demos he attempted (one got cut for time):

* Mifi
* iPhone Touch as a cellphone (using Mifi+Skype Out)
* 800-Goog 411
* Blurt (for BlackBerry)–video chat with the author in Dallas
* Nikon Coolpix 1000pj (camera with projector)
* Ocarina (musical instrument iPhone app)
* I Am T-Pain
* Jaadu VNC (real-time control of Mac/PC/Linux across the Internet on phone)
* Red Laser (barcode scan/comparative price lookup)
* PushIt2Me (“push” notification of urgent email–wakes the iPhone)
* RunPee Mobile (tells you exactly when, in each movie, you can go pee)
* FakeCalls
* Retina (augmented reality for the color-blind)
* Swine Flu AR (mockup of phony future app)

See also:

• Video: “Don’t Cry for Me Cupertino”
• Pogue rocks Macworld with “Where is Steve?”

[Follow Philip Elmer-DeWitt on Twitter @philiped]

Tim O'Reilly, Ray Ozzie

Tim O’Reilly created a bit of a stir last night in the tech world by writing a thoughtful essay entitled “The War for the Web.” He’ll be expanding on his thoughts in his keynote address today at the Web 2.0 Expo in New York. From the essay, here’s the core argument:

“[W]e’ve grown used to a world with one dominant search engine, one dominant online encyclopedia, one dominant online retailer, one dominant auction site, one dominant online classified site, and we’ve been readying ourselves for one dominant social network. But what happens when a company with one of these natural monopolies uses it to gain dominance in other, adjacent areas? I’ve been watching with a mixture of admiration and alarm as Google has taken their dominance in search and used it to take control of other, adjacent data-driven applications.

It could be that everyone will figure out how to play nicely with each other, and we’ll see a continuation of the interoperable web model we’ve enjoyed for the past two decades. But I’m betting that things are going to get ugly. We’re heading into a war for control of the web. And in the end, it’s more than that, it’s a war against the web as an interoperable platform. [emphasis added] Instead, we’re facing the prospect of Facebook as the platform, Apple as the platform, Google as the platform, Amazon as the platform, where big companies slug it out until one is king of the hill.

… P.S. One prediction: Microsoft will emerge as a champion of the open web platform, supporting interoperable web services from many independent players, much as IBM emerged as the leading enterprise backer of Linux.

The coda there, with the Microsoft prediction, is what fascinated me – so much so that I mentioned it on Twitter. Tim immmediately responded, “Thanks. I should write a followup explaining the logic that got me to the PS.”  While we wait for that, though, here’s my prediction – with a bit of inside knowledge – today Microsoft begins to live up to Tim’s expectations with several announcements at our Professional Developers Conference (PDC) 2009 in Los Angeles.

If you want to see the future of Microsoft, and the future of the web and computing as we see it, watch live as Ray Ozzie lays it out in his keynote address, streamed live today at 11:30 eastern time, 8:30 am Pacific, over at http://microsoftpdc.com/.

Oh – and if your Latin is rusty, my title above comes from the phrase ”Si vis pacem, para bellum” – the classic doctrine of maintaining peace & deterring war by being better armed and prepared. It is generally attributed to Publius Flavius Vegetius Renatus, a fourth-century AD Roman military scholar whom I consider the Sun Tzu of the West. I’ve known many fans of his philosophy in the Pentagon.

Now it may turn out that, whether they know it or not, Microsoft techies are building new ways to avoid a war on the open web. As Sun Tzu wrote,  ”To win one hundred victories in one hundred battles is not the acme of skill. To subdue an enemy without fighting is the acme of skill.” Watch our PDC this week to see examples of what I consider the modern technological acme of skill.

Share this post on Twitter

Email this post to a friend

I watched the video about the new Dynamic feature coming in .Net 4.0.  Its an interview with Sam Ng and Chris Burrows who are the compiler developers who actually helped design and implement the feature.

This feature provides enhanced interoperation with dynamic languages such as Ruby and Python, with dynamic models such as Silverlight JavaScript, and with COM objects, particularly those that you find in the Office APIs. With the addition of Dynamic to C# 4.0, it is now much easier to access Microsoft Office APIs from C#.

They almost lost me when they said it was for interop & COM (features I hope to avoid), but they brought me back when they mentioned it would be helpful with the HTML DOM and Office (features that keep sucking me back in).

They talked about the DLR (dynamic language runtime) which helps with dynamic expressions.  Lots of mentions of interop with IronPython & Ruby so we’ll see if this makes those guys happy or is just a red herring.

There’s going to be a dynamic type: its syntactic sugar for object type (I’m in favor of anything sweet).  Dynamic type will help the compiler optimize, but the syntax will be the same as usual.  This is primarily for COM Interop, Dynamic C#/Reflection, and Office API’s.

Dynamic will allow for working with dynamic objects without all that nasty casting, but you need to know method names in that case, so it sounds like you wont get intellisense , and late bound type errors aren’t pretty either.  While getting the same error at runtime as you would at compile time sounds good, the bad part is that you’ll get an error at runtime.  More debugging…

Another use case is using a dynamic object (essentially an object type) as a parameter and the proper overload being determined at runtime.  Oh joy, imagine all the possibilities.  Now test them all…

On the other hand, if you really need to do this, it sounds like dynamic will help make things easier without much trouble for the developer.  I’m all for that.

I bet one day I’ll use this.  I hope I won’t build something embarrassing or that I regret.  At least I feel smarter listening to these guys talk.

We can’t directly call Assembly language from WPF program. But we can do this indirectly. We can easily call the assembly language from any VC++ unmanaged program and make a DLL of it and export it as a C functions. After that we can call the functions of that DLL just like we call the windows API.

Now lets take a look at the example. First we are going to make a simple DLL, which export C function and uses inline assembly. We have 5 function to perform some low level work for us. Here is a header file of our DLL.

  1:

  2: #ifndef __SYSINFO_H

  3: #define __SYSINFO_H

  4:

  5: extern "C" __declspec(dllexport) int __stdcall getCPUSpeed();

  6: extern "C" __declspec(dllexport) char* __stdcall getCPUType();

  7: extern "C" __declspec(dllexport) int __stdcall getCPUFamily();

  8: extern "C" __declspec(dllexport) int __stdcall getCPUModel();

  9: extern "C" __declspec(dllexport) int __stdcall getCPUStepping();

 10:

 11: #endif

 12: 

Here is a implementation of these function. Here we have some low level assembly language work.

  1: #include "SysInfo.h"

  2: #include <windows.h>

  3:

  4: BOOL __stdcall DllMain(HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved)

  5: {

  6: 	return  TRUE;

  7: }

  8:

  9: extern "C" __declspec(dllexport) int __stdcall getCPUSpeed()

 10: {

 11: 	LARGE_INTEGER ulFreq, ulTicks, ulValue, ulStartCounter, ulEAX_EDX, ulResult;

 12:

 13: 	// it is number of ticks per seconds

 14: 	QueryPerformanceFrequency(&ulFreq);

 15:

 16: 	// current valueofthe performance counter

 17: 	QueryPerformanceCounter(&ulTicks);

 18:

 19: 	// calculate one second interval

 20: 	ulValue.QuadPart = ulTicks.QuadPart + ulFreq.QuadPart;

 21:

 22: 	// read time stamp counter

 23: 	// this asm instruction load the highorder 32 bit of the register into EDX

 24: 	// and the lower order 32 bits into EAX

 25: 	_asm

 26: 	{

 27: 		rdtsc

 28: 		mov ulEAX_EDX.LowPart, EAX

 29: 		mov ulEAX_EDX.HighPart, EDX

 30: 	}

 31:

 32: 	// start no of ticks

 33: 	ulStartCounter.QuadPart = ulEAX_EDX.QuadPart;

 34:

 35: 	// loop for 1 second

 36: 	do {

 37: 		QueryPerformanceCounter(&ulTicks);

 38: 	} while (ulTicks.QuadPart <= ulValue.QuadPart);

 39:

 40: 	// get the actual no of ticks

 41: 	_asm {

 42: 		rdtsc

 43: 		mov ulEAX_EDX.LowPart, EAX

 44: 		mov ulEAX_EDX.HighPart, EDX

 45: 	}

 46:

 47: 	// calculate result

 48: 	ulResult.QuadPart = ulEAX_EDX.QuadPart - ulStartCounter.QuadPart;

 49:

 50: 	return (int)ulResult.QuadPart / 1000000;

 51: }

 52:

 53: extern "C" __declspec(dllexport) char* __stdcall getCPUType()

 54: {

 55: 	static char pszCPUType[13];

 56: 	memset(pszCPUType, 0, 13);

 57:

 58: 	_asm

 59: 	{

 60: 		mov eax, 0

 61: 		cpuid

 62:

 63: 		// getting information from EBX

 64: 		mov pszCPUType[0], bl

 65: 		mov pszCPUType[1], bh

 66:

 67: 		ror  ebx, 16

 68: 		mov pszCPUType[2], bl

 69: 		mov pszCPUType[3], bh

 70:

 71: 		// getting information from EDX

 72: 		mov pszCPUType[4], dl

 73: 		mov pszCPUType[5], dh

 74:

 75: 		ror  edx, 16

 76: 		mov pszCPUType[6], dl

 77: 		mov pszCPUType[7], dh

 78:

 79: 		// getting information from ECX

 80: 		mov pszCPUType[8], cl

 81: 		mov pszCPUType[9], ch

 82:

 83: 		ror  ecx, 16

 84: 		mov pszCPUType[10], cl

 85: 		mov pszCPUType[11], ch

 86: 	}

 87:

 88: 	pszCPUType[12] = '';

 89:

 90: 	return pszCPUType;

 91: }

 92:

 93: extern "C" __declspec(dllexport) int __stdcall getCPUFamily()

 94: {

 95: 	int retVal;

 96:

 97: 	_asm {

 98: 		mov eax, 1

 99: 		cpuid

100: 		mov retVal, eax

101: 	}

102:

103: 	return (retVal >> 8);

104: }

105:

106: extern "C" __declspec(dllexport) int __stdcall getCPUModel()

107: {

108: 	int retVal;

109:

110: 	_asm {

111: 		mov eax, 1

112: 		cpuid

113: 		mov retVal, eax

114: 	}

115:

116: 	return ((retVal >> 4 ) & 0x0000000f);

117: }

118:

119: extern "C" __declspec(dllexport) int __stdcall getCPUStepping()

120: {

121: 	int retVal;

122:

123: 	_asm {

124: 		mov eax, 1

125: 		cpuid

126: 		mov retVal, eax

127: 	}

128:

129: 	return (retVal & 0x0000000f);

130: }

131: 

Now we are going to call these function just like Windows API using the PInvoke functionality. Here is a XAML file for the client of this DLL.

  1: <Window x:Class="AsmWpf.Window1"

  2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

  3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

  4:     Title="Assembly Language from WPF" Height="300" Width="400" Background="AliceBlue" Loaded="Window_Loaded">

  5:     <Grid>

  6:         <Grid.RowDefinitions>

  7:             <RowDefinition/>

  8:             <RowDefinition/>

  9:             <RowDefinition/>

 10:             <RowDefinition/>

 11:             <RowDefinition/>

 12:             <RowDefinition/>

 13:         </Grid.RowDefinitions>

 14:

 15:         <Grid.ColumnDefinitions>

 16:             <ColumnDefinition/>

 17:             <ColumnDefinition/>

 18:         </Grid.ColumnDefinitions>

 19:

 20:         <TextBlock Grid.Column="0" Grid.Row="0" Margin="5" VerticalAlignment="Center">

 21:             Computer Speed

 22:         </TextBlock>

 23:         <TextBlock Grid.Column="1" Grid.Row="0" Margin="5" VerticalAlignment="Center" Name="txtSpeed"/>

 24:         <TextBlock Grid.Column="0" Grid.Row="1" Margin="5" VerticalAlignment="Center">

 25:             Vendor Name

 26:         </TextBlock>

 27:         <TextBlock Grid.Column="1" Grid.Row="1" Margin="5" VerticalAlignment="Center" Name="txtVendor"/>

 28:         <TextBlock Grid.Column="0" Grid.Row="2" Margin="5" VerticalAlignment="Center">

 29:             Family

 30:         </TextBlock>

 31:         <TextBlock Grid.Column="1" Grid.Row="2" Margin="5" VerticalAlignment="Center" Name="txtFamily"/>

 32:         <TextBlock Grid.Column="0" Grid.Row="3" Margin="5" VerticalAlignment="Center">

 33:             Model

 34:         </TextBlock>

 35:         <TextBlock Grid.Column="1" Grid.Row="3" Margin="5" VerticalAlignment="Center" Name="txtModel"/>

 36:         <TextBlock Grid.Column="0" Grid.Row="4" Margin="5" VerticalAlignment="Center">

 37:             Stepping

 38:         </TextBlock>

 39:         <TextBlock Grid.Column="1" Grid.Row="4" Margin="5" VerticalAlignment="Center" Name="txtStepping"/>

 40:         <Button Grid.Column="0" Grid.Row="5" Grid.ColumnSpan="2" Width="75" Margin="5" Name="btnExit" Click="btnExit_Click">

 41:             Exit

 42:         </Button>

 43:     </Grid>

 44: </Window>

 45: 

The C# code of this project is very easy. We just define the signature of our exported function and call them one by one.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14: using System.Runtime.InteropServices;

 15:

 16: namespace AsmWpf

 17: {

 18:     /// <summary>

 19:     /// Interaction logic for Window1.xaml

 20:     /// </summary>

 21:     public partial class Window1 : Window

 22:     {

 23:         [DllImport("SysInfo.dll")]

 24:         static extern int getCPUSpeed();

 25:

 26:         [DllImport("SysInfo.dll")]

 27:         static extern string getCPUType();

 28:

 29:         [DllImport("SysInfo.dll")]

 30:         static extern int getCPUFamily();

 31:

 32:         [DllImport("SysInfo.dll")]

 33:         static extern int getCPUModel();

 34:

 35:         [DllImport("SysInfo.dll")]

 36:         static extern int getCPUStepping();

 37:

 38:         public Window1()

 39:         {

 40:             InitializeComponent();

 41:         }

 42:

 43:         private void Window_Loaded(object sender, RoutedEventArgs e)

 44:         {

 45:             try

 46:             {

 47:                 txtSpeed.Text = getCPUSpeed().ToString();

 48:                 txtVendor.Text = getCPUType();

 49:                 txtFamily.Text = getCPUFamily().ToString();

 50:                 txtModel.Text = getCPUModel().ToString();

 51:                 txtStepping.Text = getCPUStepping().ToString();

 52:             }

 53:             catch (DllNotFoundException ex)

 54:             {

 55:                 MessageBox.Show(ex.Message);

 56:             }

 57:             catch (EntryPointNotFoundException ex)

 58:             {

 59:                 MessageBox.Show(ex.Message);

 60:             }

 61:         }

 62:

 63:         private void btnExit_Click(object sender, RoutedEventArgs e)

 64:         {

 65:             Close();

 66:         }

 67:     }

 68: }

 69: 

Here is the output of this program.

Sometimes we want to access the low level functionality of operating system which is not directly available in WPF. In that case we are going to call Windows API directly. Calling a Windows API from WPF program is similar to calling it from any console based .Net program. Let’s take a look at the example and calling two Windows API in our program to make non rectangular window. We are going to create a region with CreateRoundRectRgn and then set the current window region by calling SetWindowRgn. The only difference between calling API from Windows Form or any other .Net based program and WPF is that here we don’t have direct access to handle of window i.e. HWND. We have to use WindowInteropHelper class to get the handle of window. Here is a class diagram of WindowInteropHelper class.

Here is a complete XAML code of this project.

  1: <Window x:Class="PInvokeWPF.Window1"

  2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

  3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

  4:     Title="PInvoke WPF" Height="300" Width="300" Loaded="Window_Loaded">

  5:     <Grid>

  6:

  7:     </Grid>

  8: </Window>

  9: 

Here is the complete C# code of the project.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14: using System.Runtime.InteropServices;

 15: using System.Windows.Interop;

 16:

 17: namespace PInvokeWPF

 18: {

 19:     /// <summary>

 20:     /// Interaction logic for Window1.xaml

 21:     /// </summary>

 22:     public partial class Window1 : Window

 23:     {

 24:         [DllImport("user32.dll")]

 25:         static extern Int32 SetWindowRgn(IntPtr hWnd, IntPtr hRgn, bool bRedraw);

 26:

 27:         [DllImport("gdi32.dll")]

 28:         static extern IntPtr CreateRoundRectRgn(int x1, int y1, int x2, int y2, int cx, int cy);

 29:

 30:         public Window1()

 31:         {

 32:             InitializeComponent();

 33:         }

 34:

 35:         private void Window_Loaded(object sender, RoutedEventArgs e)

 36:         {

 37:             IntPtr hwnd = new WindowInteropHelper(this).Handle;

 38:             SetWindowRgn(hwnd, CreateRoundRectRgn(0, 0, 300, 300, 75, 75), true);

 39:         }

 40:     }

 41: }

 42: 

Here is the output of this program.

Previously we saw that how can we call the Unmanaged dialog from WPF, now we are going to do the reverse and calling the WPF from the win32 application. For calling WPF dialog, we have to compile our project with /CLR switch and include all the proper references of the required DLL. In addition we also include the proper namespaces in our VC++ program. Here is the simple VC++ program to call the WPF dialog.

  1: #include <windows.h>

  2:

  3: using namespace System;

  4: using namespace System::Windows;

  5:

  6: [STAThread]

  7: int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,

  8: 				   LPSTR lpcStr, int nCmd)

  9: {

 10: 	Window^ win = gcnew Window();

 11: 	win->Title = "WPF Window";

 12: 	win->Height = 300;

 13: 	win->Width = 400;

 14: 	win->Content = "This is WPF Window";

 15: 	win->ShowDialog();

 16: 	return 0;

 17: }

 18: 

Here is the output of this program.

If we want to make our Win32 window as a parent of this window then we can’t directly set the handle of window as an owner of this window. We first have to create an object of WindowInteropHelper class and pass the WPF window as a parameter to the constructor and then use IntPtr to set the owner of the WPF window. These are defined in System::Windows::Interop namespace. Here is simple code to demonstrate this.

  1: Window^ win = gcnew Window();

  2: Windows::Interop::WindowInteropHelper^ wih = gcnew Windows::Interop::WindowInteropHelper(win);

  3: wih->Owner = IntPtr(hWnd);

  4: 

While the idea of Data Binding is excellent, there are some concepts that I have found hard to grasp. The first one is instantiating classes in XAML. Coming from procedural programming, I first assumed that a UI control’s property would be bound to an instance of a class. Suppose you have a class called MyClass. To support change notification it has to implement INotifyPropertyChange interface, which isn’t shown in the code below.

class MyClass
{
   private string color;

   public string Color
   {
      get { return this.color; }
      set { this.color = value; }
   }
}

In procedural code (in this case C#) you would create an instance of this class.

MyClass myObject = new MyClass;

To create an instance of the class in XAML you have to define a resource.

<DockPanel.Resources>
      <MyClass x:Key="myObject"/>

When loading this XAML code the runtime creates an instance of the class MyClass and myObject is a “reference” to the instance. The catch is that the object scope is not the same as with C#-instantiated object. In XAML you can access the object through myObject. The object is actually stored in a resource collection and if you want to access myObject in C#, or code-behind as it’s called, you have to call Application.FindResource.

MyClass md = (MyClass)this.FindResource("myObject");

To bind a Button’s Background property to the MyClass.Color property, you have to define the source object and the path to the property. Source defines the instance of the class, and Path defines the property. Because elements inherit their parent element’s properties through attached property mechanism, you could also define a DataContext in the DockPanel.

<DockPanel>
   <DockPanel.DataContext>
      <Binding Source="{StaticResource myObject}"/>
   </DockPanel.DataContext>

   <Button Background="{Binding Path=Color}">
      A button
   </Button>
</DockPanel>

This ties all bindings inside the DockPanel to myObject.

I was given a task to develop a new WPF UI on top of a native business layer. This obviously required me to create managed classes that wrap the native business logic. One of the best things in .NET is data binding, but using it with native data types requires a bit of work. This and following articles show an example of how you can implement WPF data binding to native legacy code. Interop is a complex subject on its own, but I will focus on data binding issues. You need to be familiar with WPF data binding and DependencyProperties.

Simple wrapper class

Suppose you have a native class that has a public field. The class constructor initializes the value.

class NativeDataClass
{
   public:
   int SomeValue;

   NativeDataClass();
};

...

NativeDataClass::NativeDataClass()
{
   SomeValue = 42;
}

Now, suppose you want to display the public field value in a WPF TextBox. First you need to create a managed wrapper for the native class. You could use COM interop or P/Invoke, but I’ll use C++/CLI.

public ref class ManagedWrapper
{
   private:
   NativeDataClass* _dataObject;

   public:
   ManagedWrapper()
   {
      _dataObject = new NativeDataClass();
   }

   ~ManagedWrapper()
   {
      delete _dataObject;
   }
};

Since ref types (ie. managed types) may not contain native types, I’ll use a pointer instead. Data binding requires that the class exposes properties, so I’ll create one.

public ref class ManagedWrapper
{
...

   property int SomeValue
   {
      int get()
      {
         return _dataObject->SomeValue;
      }

      void set(int value)
      {
         if (_dataObject->SomeValue != value)
         {
            _dataObject->SomeValue = value;
         }
      }
   }
}

This is basically all you need, but I want change notification, so that when the native field value changes, the UI changes as well. Also, I want to have a two-way binding, that is, if the TextBox value is changed, I want the new value to propagate to the native class. For this I need change notification. For this WPF has an interface called INotifyPropertyChanged, which requires a single event to be implemented. So the final wrapper looks like this.

public ref class ManagedWrapper : public INotifyPropertyChanged
{
   private:
   NativeDataClass* _dataObject;

   public:
   ManagedWrapper()
   {
      _dataObject = new NativeDataClass();
   }

   ~ManagedWrapper()
   {
      delete _dataObject;
   }

   virtual event PropertyChangedEventHandler^ PropertyChanged;

   property int SomeValue
   {
      int get()
      {
         return _dataObject->SomeValue;
      }

      void set(int value)
      {
         if (_dataObject->SomeValue != value)
         {
            _dataObject->SomeValue = value;
            OnPropertyChanged("SomeValue");
         }
      }
   }

   protected:
   void OnPropertyChanged(String^ info)
   {
      PropertyChanged(this, gcnew PropertyChangedEventArgs(info));
   }
};

I have been invited to speak and chair a panel at Interop, New York (November 16-20, 2009) to give a talk exploring the hype and reality surrounding Data Center based containers and Green IT in general.  

The goal of the panel discussion will help data center managers evaluate and approach containers by understanding their economics, key considerations and real-life customer examples.  It’s going to be a great conversation.  If you are attending Interop this year I would love to see you there!

\Mm

The Excel team blogged about async xll udfs today.

There is one other unique investment in the area of calculation that I want to briefly mention:Asynchronous XLL User-Defined Functions (Asynch XLL UDFs). The idea behind Asynch XLL UDFs is this: we know that some of our customers use XLL UDFs as a way to fetch data from external data servers. The CPU usage on the machine running Excel isn’t very heavy, but the server handling the request may take a while to return the requested data. If you have 100 of these functions in A1:A100 for example, you can be waiting quite a while for your workbook to calculate, because Excel processes those cells one at a time. Since the local machine isn’t doing any heavy CPU processing, with Excel 2010 we’ve enabled the functionality to send all 100 XLL UDFs calls at one time, allowing the backend servers to process the requests in parallel.

IMO, this is a much-needed feature. In the past, you’d have to write an Excel RTD server to fetch the values asynchronously, even if the backend was returning static data (or an addin wrapping the RTD server).  This lead to PnL & Risk workbooks containing formulae written by both the users and the development team; not an ideal support scenario. The async udfs should help reduce user dependence on the IT team as far as maintenance of the formulae is concerned.

Visual Studio Team Edition for Database Professionals je odličan alat koji inženjerima baza podatka omogućava niz fensi stvari kao što su verzioniranje sheme, generiranje testnih podataka, refaktoriranje i drugo. Međutim pitanje koje nam je često bilo postavljano, a na koje nisam imao odgovor, je da li je Oracle baza podržana. Odgovor je bio da VSTS podržava proširivanje i da je pitanje vremena kada će se netko sjetiti i napraviti provider za Oracle. I eto, konačno je došlo to vrijeme. Quest Software, proizvođač najpoznatijeg alata za upravljanje Oracle bazama (Toad) trenutno radi na implementaciji Oracle providera za VSTS. Projekt kodnog naziva “Team Fuze” trenutno je u beti, a trebao bi izaći skupa s Visual Studiom 2010.

Sve detalje možete pročitati na njihovoj stranici http://www.teamfuze.net gdje možete i preuzeti provider.

Ili pogledajte odmah:

We can call the unmanaged code from the WPF. There is a namespace System.Windows.Interop define all the necessary classes and structure for this purpose.

If we are working in VC++ then we can easily mix managed and unmanaged code. First we have to create an object of WindowInteropHelper class and then get the handle of window i.e. HWND. Once we get the HWND then we can use it with unmanaged code. Here is a code to get the HWND within WPF.

  1: WindowInteropHelper^ helper = gcnew WindowInteropHelper(this);

  2: HWND hwnd = (HWND)helper->Handle.ToPointer();

  3: 

Here is a sample code to demonstrate this. Here we create a simple WPF window and create one button inside it. When user press that button then it will popup one unmanaged dialog from it.

  1: #include <windows.h>

  2: #include "resource.h"

  3: using namespace System;

  4: using namespace System::Windows;

  5: using namespace System::Windows::Media;

  6: using namespace System::Windows::Controls;

  7: using namespace System::Windows::Interop;

  8:

  9: HINSTANCE gInst;

 10: LRESULT CALLBACK MyDialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

 11:

 12: public ref class MyWindow : public Window

 13: {

 14: public:

 15: 	MyWindow()

 16: 	{

 17: 		Title = "Unmanaged DialogBox Demo";

 18: 		Width = 400;

 19: 		Height = 300;

 20:

 21: 		Grid^ grid = gcnew Grid();

 22:

 23: 		Windows::Controls::RowDefinition^ row = gcnew Windows::Controls::RowDefinition();

 24: 		Windows::Controls::ColumnDefinition^ col = gcnew Windows::Controls::ColumnDefinition();

 25:

 26: 		Button^ btn = gcnew Button();

 27: 		btn->Content = "Call Dialog";

 28: 		btn->Margin = Thickness(10);

 29: 		btn->Click += gcnew RoutedEventHandler(this, &MyWindow::OnButton);

 30:

 31: 		grid->SetRow(btn, 0);

 32: 		grid->SetColumn(btn, 0);

 33:

 34: 		grid->RowDefinitions->Add(row);

 35: 		grid->ColumnDefinitions->Add(col);

 36:

 37: 		Content = grid;

 38:

 39: 		grid->Children->Add(btn);

 40: 	}

 41:

 42: 	void OnButton(Object^ sender, RoutedEventArgs^ e)

 43: 	{

 44: 		WindowInteropHelper^ helper = gcnew WindowInteropHelper(this);

 45: 		HWND hwnd = (HWND)helper->Handle.ToPointer();

 46: 		DialogBox(gInst, MAKEINTRESOURCE(IDC_DIALOG), hwnd, (DLGPROC)MyDialogProc);

 47: 	}

 48: };

 49:

 50: LRESULT CALLBACK MyDialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

 51: {

 52: 	switch(uMsg)

 53: 	{

 54: 	case WM_COMMAND:

 55: 		switch(LOWORD(wParam))

 56: 		{

 57: 			case IDC_CLOSE:

 58: 				EndDialog(hWnd, LOWORD(lParam));

 59: 				break;

 60: 		}

 61: 	}

 62:

 63: 	return FALSE;

 64: }

 65:

 66: [STAThread]

 67: int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,

 68: 				   LPSTR lpCmd, int nCmd)

 69: {

 70: 	gInst = hInstance;

 71:

 72: 	MyWindow^ win = gcnew MyWindow();

 73:

 74: 	Application^ app = gcnew Application();

 75: 	app->Run(win);

 76: }

 77: 

Here is the output of the program.

When user press this button then one dialog box will popup. Here is the output of it.

When the first edition of the television show Indian Idol was nearing its conclusion in early 2005, I remember one of the judges admitting to initial apprehension and expressing relief that the participating singers hadn’t let India down and had ensured that the show was as good as, or even better than, the forerunning British and American versions that it was modeled on.

When I set out a few months ago as Conference Chair to devise the conference program for Interop Mumbai 2009, I had similar apprehensions. Where would we find so many speakers? Would the speakers be good enough? What about the workshops and demos? Would we be able to put together and deliver a conference and exposition of this scale in Mumbai? (a city notorious for its woeful lack of world-class convention infrastructure).

After all, the Interop brand has huge equity and a legacy that goes back to the time when TCP/IP was still being perfected and the fledgling Internet was just about spreading into the realm of business. That’s way beyond what any TV reality show can ever hope to claim. To get a sense of the Interop heritage, let me quote from A Brief History of the Internet (Barry Leiner, Vinton Cerf, et al): “…Dan Lynch [one of the TCP/IP and Arpanet pioneers] in cooperation with the IAB arranged to hold a three day workshop for ALL vendors to come learn about how TCP/IP worked and what it still could not do well… After two years of conferences, tutorials, design meetings and workshops, a special event was organized that invited those vendors whose products ran TCP/IP well enough to come together in one room for three days to show off how well they all worked together and also ran over the Internet. In September of 1988 the first Interop trade show was born. 50 companies made the cut. 5,000 engineers from potential customer organizations came to see if it all did work as was promised. It did. Why? Because the vendors worked extremely hard to ensure that everyone’s products interoperated with all of the other products—even with those of their competitors. The Interop trade show has grown immensely since then and today it is held in [several] locations around the world each year to an audience of over 250,000 people who come to learn which products work with each other in a seamless manner, learn about the latest products, and discuss the latest technology.”

Over the years, as interoperability became less and less of an intractable problem, Interop evolved into a more broad-based business technology event. Now, 21 years on, after Las Vegas, New York, Tokyo, Sao Paulo and Moscow, Interop has finally arrived here in India and I am pretty confident that Interop Mumbai (7-9 Oct 2009) will be everything that everyone has come to expect from the leading business technology event worldwide.

We have over 60 speakers from all over the world spread across 20-plus sessions, six keynotes, three plenary panel discussions, and several workshops and special sessions, in four parallel tracks. My approach has been to provide a mix of subject experts, experienced practitioners, distinguished analysts, tech gurus and promising young enterprise-IT professionals from India. To give a realistic practical dimension to the conference, most of the sessions will be chaired by leading CIOs from various industry verticals. The icing on the cake is the large exhibit floor adjoining the conference halls, where delegates and visitors can see the latest technologies being showcased and demonstrated by close to 50 leading vendors, all in one place.

India is at a critical juncture in its quest to achieve “developed country” status, and I firmly believe that prudent deployment of Information Technology is one of the important factors that will help us get there quicker. I am further convinced that events such as Interop serve as enablers and triggers for enterprise IT managers, aiding them in making sound decisions for rapid and effective deployment of IT solutions in their organizations.

As the date for the event approaches, the excitement is palpable, and inexorably rising to a crescendo. Interop Mumbai 2009 will definitely be a landmark event in the annals of the evolution of enterprise-IT in India. Do join me on October 7th at the Bombay Exhibition Centre—and be a witness to history in the making!

- Val Souza

Conference Chair, Interop Mumbai 2009

 (valsouza at ubmindia dot com)

If you work with .NET long enough, sooner or later you’ll probably need to leverage older Win32 COM components. To allow the CLR managed code of .NET to communicate with the unmanaged code of COM, a “middleman” in the form of an interop assembly must be created. This can be done via Visual Studio or the Type Library Importer.

Creating an interop assembly with Visual Studio
Enter the “Add reference” dialog of your project, browse for your registered COM server and select it. Now take a look at the properties of the newly created reference. It is actually pointing to a new assembly called Interop.COMServerName.dll: If your COM server is foo.dll, the resulting assembly is called Interop.foo.dll. You will find this assembly in your bin directory after you build.

If your project uses an .snk or .pfx for strong naming, the interop assembly will also be strong named using that file.

A major limitation of this method I found was the fact that you can’t change the version number of the interop assembly. It is always 1.0.0.0. Bummer.

Creating an interop assembly with Type Library Importer
If you need more control, then you should use the Type Library Importer (tlbimp). This application is included with the .NET SDK.

Running the following command will create an interop assembly with a version number of your choosing:
Using our foo.dll example:

tlbimp foo.dll /out:Interop.foo.dll /asmversion:2.0.0.0

If you need the interop assembly strongly named, you can do that also. If you are using an .snk, use the following:

tlbimp foo.dll /out:Interop.foo.dll /asmversion:2.0.0.0 /keyfile:MyKey.snk

If you are using a .pfx for strong naming, it’s a bit trickier. You will also need to leverage the Strong Name Tool (sn) to create a keycontainer:

echo Prompts you for .pfx password
sn -i MyKey.pfx KeyContainerName

tlbimp foo.dll /out:Interop.foo.dll /asmversion:2.0.0.0 /keycontainer:KeyContainerName

echo Housecleaning.  Removes the key container from memory.
sn -d KeyContainerName

Now add it as a reference and you’re good to go!

My new best friend, the Windows 7 Code Pack, has been released.  From Charlie Calvert’s Community Blog:

The Windows® API Code Pack for Microsoft® .NET Framework provides support for various features of Windows 7 and previous releases of that operating system. The Code Pack has  reached version 1.0 and has been published on Code Gallery:

• Download it
• Read about it
• Discuss it
• Report bugs

Here are some of the features you can from managed code using the Code Pack:

• Windows 7 Taskbar Jump Lists, Icon Overlay, Progress Bar, Tabbed Thumbnails, and Thumbnail Toolbars.
• Windows 7 Libraries, Known Folders, non-file system containers.
• Windows Shell Search API support, a hierarchy of Shell Namespace entities, and Drag and Drop functionality for Shell Objects.
• Explorer Browser Control.
• Shell property system.
• Windows Vista and Windows 7 Common File Dialogs, including custom controls.
• Windows Vista and Windows 7 Task Dialogs.
• Direct3D 11.0, Direct3D 10.1/10.0, DXGI 1.0/1.1, Direct2D 1.0, DirectWrite, Windows Imaging Component (WIC) APIs. (DirectWrite and WIC have partial support)
• Sensor Platform APIs
• Extended Linguistic Services APIs
• Power Management APIs
• Application Restart and Recovery APIs
• Network List Manager APIs
• Command Link control and System defined Shell icons.

Part of ooo-build since early June, and now on the way to 3.2 for vanilla. Just a few pictures that should tell the story, starting with the state of affairs up to and including OOo 3.1:

The competition:

After the fix:

The differences are a bit subtle when looked at on this scale, but quite annoying when encountered by someone who designs her presentations with an eye for details. Especially the way sub-shapes were gradient-filled before, like the top end of the can or the eyes of the smiley. Kudos to haui btw. for the very nice hack to make OOo believe a sub-shape actually has the same bounding box as the main shape. Here’s the patch for those interested in the gory details.

I was thinking about a gotcha in Java, and started wondering about the idea of making it convenient to intern reference objects.

“Interning” refers to the idea of ensuring that there is only one instance of an object with a given internal configuration – the classic example being strings in Java and .NET. When you construct a new string from a string literal, code is inserted to ensure that you get back a reference to the same string object for any given string literal value. So if you have the quoted string "Hello, world" in two places in your source code, they will point to the same object. This is a form of referential identity.

This predictably causes confusion in Java because learners are duped into thinking that they will be able to compare string values with ==, but this is not generally true, because other operations that create strings (such as concatenation, or reading from a file) do not take part in interning. It’s not such a problem in C# because you can implement a special version of == that compares the actual values instead of references, and this is exactly what the built-in System.String type does.

But then there are types that frequently occur in C# programs where you don’t have the ability to override the == operator. An example is an interface type – no overloading of operators is allowed with them. In the code I’m working on, a lot of things are described by COM interfaces, which look just like interfaces. I’d frequently like to be able to intern references to such things, allowing me to casually compare two references in a meaningful way. Especially where I’m dealing with an external COM library that just allocates objects on the fly to represent data, and so the identity of the object is not currently being put to good use – it’s completely meaningless.

But the right way to do this depends on some detail of the interface. There is also the question of the scope in which internship should apply – a whole process, or just the current thread?

Trivial example:

public interface IMyWeirdInterface
{
    string Name { get;}
}

What I’d like is to be able to assume that any two objects of that type will be the same instance if they have the same Name. So what I need is an object that manages the “internship” in that way:

var i = new Internship<IMyWeirdInterface, string>(m => m.Name);

IMyWeirdInterface x = new MockMyWeirdInterface { Name = "Fred" };
IMyWeirdInterface y = new MockMyWeirdInterface { Name = "Fred" };
IMyWeirdInterface z = new MockMyWeirdInterface { Name = "Jim" };

i.Intern(ref x);
i.Intern(ref y);
i.Intern(ref z);

Debug.Assert(x == y);
Debug.Assert(x != y);

So no matter from where a method obtains some references to IMyWeirdInterface, it can intern them and they will have referential identity. It just needs access to the right Internship object to manage this. With most COM objects, they are “apartment threadsafe”, which is a coy way of saying that they aren’t particularly threadsafe at all and should not be shared between threads. So for such objects, the right thing to do is make the Internship object thread local:

public static class Internships
{
    [ThreadStatic] private static Internship<IMyWeirdInterface, string> WeirdThreadLocal;

    public static Internship<IMyWeirdInterface, string> Weird
    {
        get
        {
            if (WeirdThreadLocal == null)
                WeirdThreadLocal = new Internship<IMyWeirdInterface, string>(m => m.Name);

            return WeirdThreadLocal;
        }
    }
}

As well as being absolutely necessary to ensure objects don’t get mysteriously shared between threads, this also has the nice quality of avoiding the need for locks to coordinate between threads – it’s a per-thread singleton. Now, any method can say:

Internships.Weird.Intern(ref x);
Internships.Weird.Intern(ref y);

And know that if x and y have the same Name, they will now be the same object.

Here’s the declaration of Internship (not exactly rocket science, is it?):

public class Internship<TRef, TKey>
{
    private readonly Dictionary<TKey, TRef> _map = new Dictionary<TKey, TRef>();
    private readonly Func<TRef, TKey> _keySelector;

    public Internship(Func<TRef, TKey> keySelector)
    {
        _keySelector = keySelector;
    }

    public void Intern(ref TRef obj)
    {
        TKey key = _keySelector(obj);
        TRef result;
        if (_map.TryGetValue(key, out result))
            obj = result;
        else
            _map.Add(key, obj);
    }
}

The keySelector parameter to the constructor is the thing that controls how intances can be treated as identical, by picking a key value from a property (the Name property in my examples above).

Navision C/AL can be quite monotonous to develop in – which is also one of its strengths – strength through simplicity, but sometimes one simply desires some power tools to get past the endless repetitive boiler-plate code.

Microsoft .Net Framework, CLR, COM interop, C# and Lazy Evaluation (aka IEnumerable of T) to the rescue!

The example I’ll show here is probably not the best one. I’ll be showing how to lazily enumerate files on the file system. Navision already has a special virtual table called the file table that serves to enumerate over the file system. Nevertheless, this example will show what you can do, and maybe you’ll prefer my approach, although minimizing dependencies on automations is of course desirable.

So, let’s get started here.

First we define an Navision version of the IEnumerable interface. This is straight-forward and is immensely useful for iteroperability between Navision and automations. It provides a very smooth iteration idiom.

This simple interface provides a great deal of expressiveness due to its simplicity, generality and broad applicability.

In order to make use of this, an equal implementation class should be defined, it merely wraps around an IEnumerable<object>. This is left as an exercise for the reader.

Why IEnumerable of object you may ask? Because COM interop is not so happy about parametric polymorphism and generic types. That wohn’t be a problem in Navision though. The only problem is the limits around passing data to and from Navision where f.x. text is limited to 1024 characters. – But here you can again utilize the above type to indirectly pass around a large string wrapped in an ILinear.

Lazy Evaluation in C# 2.0 (yes, it’s so yesterday, but laziness never expires!) is our means to efficiently enumerate and traverse arbitrarily large file system trees. Here’s how it’s done.

        public ILinear GetFiles(string path, string pattern, bool recursive)
        {
            var result = (Linear)null;
            try
            {
                result = new Linear(LazyGetFiles(path, pattern, recursive));
            }
            catch (Exception) { }
            return result;
        }

I’ll not show the definition of LazyGetFiles here, but you can find the basic technique many places on the Web, e.g.

• http://weblogs.asp.net/whaggard/archive/2004/08/15/214864.aspx
• http://weblogs.asp.net/podwysocki/archive/2009/03/18/functional-net-laziness-becomes-you.aspx

I always wrap COM entry-points with exception handling to avoid crashing Navision should anything fail (using the most general exception class here). I found it a good practice to do this, in combination with access to the current exception state of the class, for logging unexpected run-time exceptions inside Navision.

It’s a bit painful to declare variables in Navision (you have to go through UI menus to do this, it’s not possible in pure text – although that may change in future versions of Navision) – the point of which is to say that if it were a bit less painful, maybe even with type-inference, one might instead return a Maybe value but we can use ISCLEAR from within Navision to detect null-values and therefore see if a failure occurred.