<ChristophDotNet

Cloud is the Next iPhone (for IT)

ChristophDotNet — Mon, 07 May 2012 14:27:00 GMT

It was the year 2006. The year Google acquired YouTube for a mere $1.65B, Pavarotti opened the Winter Olympics and Germany hosted the World Cup. After successfully branching out into music players, Apple is hinting at releasing a phone. The excitement is building, but the smartphone market is dominated by Blackberry. Microsoft's Windows Mobile has been in the market for a few years and is steadily growing in popularity because it's a more accessible developer platform.

Then on January 9th, 2007 the world changed. Not just the technology world, but the world as we knew it. Yes, Steve Jobs only showed a product, the first iPhone, but what he really showed the world what it's like to be connected and have access to the internet at all times.

The iPhone wasn't the first of its kind. Far from it actually. Microsoft had been toying with the idea of Smartphones for almost 10 years at the time. Mobile powerhouses like Blackberry and Nokia had products in the market as well, but the iPhone had two new things going for it.

1) it was beautiful and desirable and
2) it made things that mattered easy. It was no longer about piling on features. It was about making the important things easy and hiding the complexity of common tasks.

Those two factors made the iPhone an overnight success. The philosophy of beauty and simplicity was the perfect recipe to form a strong emotional connection between users and their devices.

It wasn't the apps. Those came later. A year and a half later, when Apple opened the AppStore. At that point there was no holding back, the success of the iPhone seemed unstoppable. It no longer was about being cool. You simply didn't participate without one.

So what about the cloud?

The cloud is about the same thing. Making things that matter easy. For consumers, the cloud makes keeping things in sync easy. Keeping your appointments, your contacts and files in sync is frustrating problem that was worth solving.

For the IT Crowd it's about making it easy to run apps. No longer do you have to spend time and effort on things you or, more importantly, your users(!), don't care about. The users care about how good you are at racking, stacking and cabling. They don't even want to know how much you know about maintaining and patching an OS image. You may argue that they think you're "wasting too much time" on such "unimportant" things. They care about one thing. They want their apps, fast, consistently and everywhere.

The cloud makes those things easy, because they’re done in different ways that makes users not wait for things to show up. Gratification is instant. Apps show up. New features show while they're still new and exciting. They can show off their new toys before others have them … like people showed off their new iPhones. That's what forms the emotional bond, but there were good business reasons behind it.

Let's look at some other aspects

iPhone	Cloud
iPhone hides complexity to accomplish the important tasks users care about	Cloud hides complexity to accomplish the important tasks users care about
iPhone required upfront investment , but the investment paid off quickly in productivity gains	Transition to the cloud is not seamless, but adopters confirm cost savings and transformational capabilities.
iPhone shortened timelines because access to information became ubiquitous. Information was accessible before, but the iPhone reached critical mass to drive rapid availability of mobile enabled sites.	Cloud shortens timelines because context becomes ubiquitous, capabilities become available instantaneously and innovation cycles become shorter because IT bottlenecks are eliminated.
IT hated the iPhone in the enterprise because it meant change. The iPhone was neither the most secure nor the most enterprise friendly smartphone, but users had it their way. Companies who adopted early gained an edge.	IT hates the (public) cloud in the enterprise because it means change, ...

That's why I say, the cloud is the next iPhone: Trojanic, Tectonic and Transformational. In other words, it'll creep in no matter how much you think you'll keep it out, it's going to change things and it's here to stay.

The ones that harness the transformational capabilities are going to have the edge because they shed baggage and thus move faster. With tectonic, transformational shifts, it’s important to have a strategy. Thoughts on strategies on harnessing the power of the cloud come in the next posts.

Silverlight 3 / Expression Lab Posted

ChristophDotNet — Wed, 09 Dec 2009 17:09:52 GMT

Arturo was kind enough to post a hands-on lab I created for a training event in Dallas.

It’s an introduction to Silverlight, that showcases some Silverlight 3 features, such as:

but it’s also written as an introduction to Silverlight with basics such as:

Working in Blend and Visual Studio
Control Styling
Animations
Transitions with the Visual State Manager

while you build a rotating Zune.

The lab comes with a Lab Manual for you to work through and Visual Studio projects to keep thing simple and help you out if you get stuck.

Enjoy.

Silverlight 3 – How to access peripherals

ChristophDotNet — Tue, 08 Dec 2009 17:27:00 GMT

The previous post on Silverlight 3 for kiosk apps outlined some architecture options how you can build Silverlight applications with access to peripherals. This follow up post goes into more detail on the implementation.

I strongly encourage you to consider WPF, ClickOnce and POS for .NET as the foundation of your application before you go ahead building these types of applications. The major benefits of Silverlight are the small run-time and the cross-platform availability. Chances are that cross-platform is not necessary in a kiosk environment. The small runtime may not be a big advantage if you are deploying a local application, if you’re deploying, you may as well deploy the full .NET runtime. In fact, the lean runtime may be a disadvantage since it’s lacking functionality available in the .NET libraries. ClickOnce may provide similar benefits as a web deployment of Silverlight.

Now … if you’re still reading, you probably determined that Silverlight is the way to go.

The solution is based on several key features in Silverlight

Hosting Silverlight in a custom container via the hosting API – introduced with Silverlight 1
Scripting Silverlight applications – introduced with Silverlight 1
Local messaging between Silverlight applications – even across different containers, first introduced with Silverlight 3

Let’s take a look how we can string these together to build a solution that maintains the integrity and protection of the Silverlight sandbox, but also let us get to local computing resources and maintains the benefits of Silverlight development and deployment.

First, you can host Silverlight applications not only in a web browser, but also in a custom application container via the Hosting COM API. You’re in for a blast from the past since some experience with C++ and COM is definitely required to get this to work. There’s a sample for Silverlight Alternative Hosting on MSDN. You save yourself a lot of time and effort compared to implementing the various COM interfaces if you just download the sample and start from there.

Custom Silverlight Hosting

First, you decide how you’re going to load the Silverlight application in the custom container. You could load a .xap from the local disk, or you could local the .xap application over the web. Loading from a URL over the web preserves some of the deployment flexibilities of a browser app, but if you’re running an application without a network connection, loading the application from a http URL may not be an option.

Loading a XAP from from a URL, either a file:/// URL or an http:// URL will work. To load the Silverlight application, you pass the URL to the application as a named Source property in the PropertyBag during control activation (I didn’t think I would ever have to write about ActiveX control activation again). The TutorialXcpHost application from the MSDN sample makes this very easy. It includes a XcpControlHost helper class with the SetSource method. You call SetSource before activating the control:

int WINAPI _tWinMain(HINSTANCE, HINSTANCE, LPTSTR lpCmdLine, int nShowCmd) 
{  
   CXcpControlHost::SetSource(L"http://localhost/AppsComms/ClientBin/SenderApp.xap");
   return _AtlModule.WinMain(nShowCmd);
}

Even when running in a custom host, Silverlight is still validating zones and enforces some cross-domain security. If you’re loading additional application data or resources, then base URL and zone (file:/// or http://) need to match. You can play some trickery by implementing the container’s IXcpControlHost::GetBaseUrl() method to return a matching zone, but it’s safer to play by the rules and comply with Silverlight’s security policies. after all, they’ve been put in place for good reasons.

So far, we can load a Silverlight application into a custom container, that provides more flexibility than a browser. For example, the custom container can communicate with other local resources or devices. Next we need to enable communication between the container and the Silverlight application.

Defining an interface from Silverlight to the Custom Container

A Silverlight application can expose an interface to scripting engines to allow integration with the host. For example the javascript engine in a browser can get and set properties of a Silverlight application and invoke methods exposed to script. The Silverlight piece of the code is very simple.

You define a class that represents your scripting interface and mark the class with the [ScriptableType] attribute.

[ScriptableType]
public class MyScriptableObject
{
// ... 
}

In that class, you mark methods you want to expose to the scripting engine with the [ScriptableMember] attribute.
```
[ScriptableMember]
public void ShowMessage()
{
// ...
}
```
Note: Properties and Methods must be public, or discovering the Method with GetIDsofNames will return E_FAIL.

You register an instance of the ScriptableType with the Silverlight runtime after the application starts up by calling RegisterScriptableObject. It’s very important to note that you have to call RegisterScriptableObject after runtime and application are intialized, not during the MainPage’s constructor or in InitializeComponent(). Scripting will not work correctly if you register the object too early.

private void Application_Startup(object sender, StartupEventArgs e)
{
    this.RootVisual = new MainPage();
    HtmlPage.RegisterScriptableObject("MyReceiver", new MyScriptableObject(this.RootVisual as UserControl));
}

Now the Silverlight application exposes an interface for the container to call. Since this application is running in a custom container, the container can call into the application in response to an event from a card reader for example.

Calling the Silverlight interface

The HTML bridge is part of Silverlight to integrate with browser’s java script engines. That doesn’t mean you can’t make use of it from other containers though. We’re calling the scriptable objects from the C++ container. It’s a little bit cumbersome in our scenario since you have to deal with late bound objects through COM interfaces, but the sample code may help you out a little bit.

Let’s look at the important pieces. The host for the Silverlight application must allow for access to objects that the Silverlight application registered with the scripting bridge. IXcpControlHost::GetHostOptions() gets called during activation of the control by the hosted Silverlight runtime to find out which features the host allows. The options returned to Silverlight control must include XcpHostOption_EnableScriptableObjectAccess;

STDMETHODIMP CXcpControlHost::GetHostOptions(DWORD* pdwOptions)
{
  *pdwOptions = XcpHostOption_EnableCrossDomainDownloads | XcpHostOption_EnableScriptableObjectAccess;
  return S_OK;
}

Without the option set, attempts by the container to obtain a reference (the DISPID as we’ll see shortly) will fail. RegisterScriptableObject, however, succeeds.

Getting to the registered object requires some understanding of COM. If you never had to deal with IUnknown and IDispatch, you may want to take a quick look at the COM reference.

The scriptable objects are a accessible from the Silverlight control’s Content Interface. Like all other late bound objects, properties and method on the Content object is available via IDispatch, which turns the inconspicuous lines of javascript:

slCtl  = sender.get_element();
slCtl.Content.MyReceiver.ShowMessage();

into the slightly more verbose C++ equivalent:

  _axWindow.QueryControl(IID_IXcpControl, (void**)&pxcpControl);
  HRESULT hr = pxcpControl->get_Content( &pContentDispatch );
  BSTR name = L"MyReceiver";
  hr = pContentDispatch->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_SYSTEM_DEFAULT, &dispatchID);
  hr = pContentDispatch->Invoke(dispatchID, IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET, &params, &varResult, NULL, NULL);
  pScriptableObjectDispatch = varResult.pdispVal;
  name = L"ShowMessage";
  hr = pScriptableObjectDispatch->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_SYSTEM_DEFAULT, &dispatchID);
  hr = pScriptableObjectDispatch->Invoke(dispatchID, IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, &varResult, NULL, NULL);

Let’s examine those lines a little bit more closely. First you get a reference to the Silverlight control. From the control you go to the control’s content. There’s an implicit assumption here that you don’t access the Content until after the VisualTree is constructed.

From the content, you get the ScriptableObject by the name passed to RegisterScriptableObject in the Silverlight application. Then finally, very important(!), you ask the ScriptableObject for its default dispatch interface, from where you get method or property references, which you can invoke via IDispatch::Invoke.

Now you have everything in place to listen to events from peripherals and pass them on to a Silverlight application running inside the custom host.

Communication between Applications

If you need run the Silverlight application running in a browser, then you can build a bridge from the custom host that communicates with the browser application with the silverlight application communication feature introduced with Silverlight 3.

Two applications can communicate with the LocalMessageSender and LocalMessageReceiver objects. If you need to forward local events to a browser application, then the browser application would start listening to messages.

Setting up Sender and Receiver is straight forward. The receiving applications starts the listener:

LocalMessageReceiver receiver = new LocalMessageReceiver(     
    "Receiver Name",    
    ReceiverNameScope.Global, LocalMessageReceiver.AnyDomain  );
receiver.MessageReceived += ( object sender, MessageReceivedEventArgs e ) =>
{
        items.Add( new ListItem() { Text= e.Message + " " + DateTime.Now.ToLongTimeString() } );
};
receiver.Listen();

and the sending application sends to a receiver with the registered name:

LocalMessageSender msgsender = new LocalMessageSender(    
    "Receiver Name",     
    System.Windows.Messaging.LocalMessageSender.Global );
msgsender.SendCompleted += ( object sender2, SendCompletedEventArgs e2 ) =>
{
    MessageBox.Show("Result: " );
};
msgsender.SendAsync(textBox1.Text);

MSDN has a good overview of local messaging in Silverlight, including some advanced features like sending complex XML messages and troubleshooting.

What’s important to note, is that the BaseUrl of the sending application has to match the BaseUrl of the receiving application. Even setting the receiver options and disabling zone checks are not sufficient for the receiver to process incoming messages. You may have to play some more tricks in the host if you’re not planning on loading the sending application from the same site.

For example, you could intercept the download request in IXcpControlHost::DownloadUrl() to load the .xap from other locations.

Closing Words

The upcoming Silverlight 4 release is going to simplify the architecture for out-of-browser scenarios. Silverlight 4 trusted applications can communicate with COM servers directly, which eliminates the need for hosting a Silverlight application in a custom container to get access to local resources. You still need the custom container bridge if your browser application needs access to devices and other local resources.

I’m planning a follow up post discussing the Silverlight 4 option. It’s going to be a little bit before SL4 ships – Scott Guthrie mentioned H1 2010 as the target timeframe during his PDC Day 2 keynote. It’s good to have a working option with Silverlight 3 before that.

And finally, the big thank you to Ashish, who patiently answered my questions about the COM APIs while I was looking for the magic combination ;)

What’s so old-school about text based programming?

ChristophDotNet — Mon, 07 Dec 2009 15:20:53 GMT

Computerworld posted this piece that Microsoft developers are using text editors for development. What’s so old-school about that? What I mean really? Coding in text editors is not a trend among the grey-hairds like Lewis suggested on an internal thread. Text based tools are all the rave with the next generation of developers. I mean people that look like the Mac guy in the Apple commercials.

Lots of today’s developers are all fired up about Ruby, RoR, PHP and even javascript – they’re all about text programming. Those are going to be the thought-leaders for the next generation of developers and they are programming with very similar tools and dev models that many of us started with. You may say that those developer icons at Microsoft are downright on the cutting edge.

Aside from that … are the development tools really the right thing to look at to judge state of development at Microsoft (or any other shop)? What about code quality? Innovation? Shouldn’t Microsoft developers be judged by that?

Some of my personal conclusions are that the developer(!) community doesn’t crave graphical tools – maybe it’s because they favor power and flexibility over dealing with level of complexity because that’s a higher priority for the job they are doing. Architects likely that deal with multiple more dimensions, i.e. cross-system dependencies, deployment, etc. and thus like other levels of abstractions that lend themselves better to a visual representation.

Furthermore, frameworks like RoR following the trends started with Java and .NET. They are raising the level of abstraction for developers – without going to graphical development models. I just spent time experimenting with some COM work. The productivity problem isn’t working with text-based languages like C++. The much bigger productivity problem is that COM interfaces were designed for late bound environments and are extremely low level. That problem was solved either with graphical environments or text based environments like VB.

Again, use the right tool for the job. Libraries that raise the level of abstraction have been very successful to boost productivity for developers. Enhancements to text editors to speed up development have been around since way longer than Visual Studio. Pretty much everybody had their Emacs or VI rigged with all sorts of fancy macros to keep code clean. Graphicals tools, at least today are much more helpful for visualizing architecture and the high-level flow of a program. Those are different from executable code and are intended for a different audience.

What am I missing?

Silverlight 3 for Kiosk Apps? Of Course!

ChristophDotNet — Tue, 17 Nov 2009 15:48:36 GMT

Several of the customers I work with are looking to build kiosk or point-of-sale applications with Silverlight. The ease of deployment with browser-based Silverlight applications is definitely appealing. Sharing applications or components between customers’ kiosks and web sites is another appealing reasons to go with Silverlight. This post outlines the architecture decisions between Silverlight and WPF and presents architecture options for Silverlight based solutions. A follow up post will discuss the Silverlight implementation details.

However, POS systems or kiosks often need integration with local peripherals, such as credit card readers, barcode scanners, printers, etc. Since Silverlight browser applications run in a sandbox access to these devices isn’t immediately available. Therefore we need to find a way to insert a bridge between the peripherals and the Silverlight application to read data from the devices and forward the data to the Silverlight app.

To get started, let’s look at applications that can communicate with local peripherals. Desktop applications can communicate with local devices. Devices usually ship with C++ or .NET libraries to read data or sink events from devices. Therefore Desktop applications are usually preferred for POS systems. Microsoft has a POS for .NET framework to simplify development of applications that need access to a wide array of peripherals. WPF offers a very compelling option to build the application UI and building the UI in WPF is a great step to share assets between the kiosk and the Web. The following table summarizes the decision points to decide between a full desktop application or a Silverlight app.

Pro	Con
Full POS Framework for peripheral integration	Requires high-touch deployment
Full access to local resources (files, registry, printers, peripherals)	Some re-development to share assets between desktop and web applications
Hardware accelerated graphics	Windows specific
Richest Graphics with WPF and XNA
Full .NET Framework (WCF, WPF, WF, SxS versioning, …)

If the cons weigh too high and you really need a browser-based app, for example when you’re running in shared kiosk environments or if ease of deployment is much more important than peripheral integration, then you have a couple of options with Silverlight.

First, you can simply load the Silverlight application with a control hosted in a desktop application via the COM hosting interfaces. The host application can load the Silverlight application from a web URL, i.e. once you install the host application, you can still download the Silverlight application from the web. The Silverlight hosting interfaces even allow managing the download process, customize caching of .xap files and other resources through the IXcpControlHost interface.

For communication between the Silverlight app and the device manager running in the host application, the Silverlight application can expose an interface via the scriptable object bridge. That bridge is intended for communicating with the javascript engine of a web browser but it works in other containers as well. The scriptable object is accessible to the Win32 host via COM IDispatch interfaces, which the host application can invoke to send data to the embedded Silverlight application as shown in the diagram below.

You may at this point decide that the custom host is all you need, but may also want to run the application in a browser, for example because the Silverlight application integrates with an existing web site or you need to comply with an industry standard like CUSS.

Pro	Con
Single Process solution	Non-standard, Windows-only container
	Need to re-develop browser functionality, such as caching
	Tight coupling of peripheral management and application UI

In the past, applications installed a local web server like Cassini which hosted a .NET component that would communicate with local resources as needed. The Silverlight application would make REST calls to the “web server” which would handle the communication with a peripheral device or other local resources.

However, this approach had a couple of drawbacks. First, running a local web server requires administrator privileges and is often frowned upon because of potential security risks. Second, communication always had to be initiated by the Silverlight application. The peripheral could not send notifications to the application running in the browser.

Pro	Con
Potentially fully managed code implementation	Complexity running a local web server
	Communication overhead with HTTP
	One-way communication. Silverlight application has to poll/
	Policy restrictions for local services and sockets
	Perceived security risks of local web servers
	Complex deployment of local services

With Silverlight 3 we have an alternative that doesn’t require a local “web server”. Silverlight 3 introduced the ability for Silverlight applications to communicate regardless what application container they are running in. One Silverlight application would send messages over a “named channel” with a LocalMessageSender object. Another Silverlight application can listen on that named channel with a LocalMessageReceiver object.

In our case the Win32 application could be an application without a visible UI that only acts as a bridge between the peripherals and the browser application.

In a scenario where the need for a local peripherals is limited to a single, well-known device, the effort to write a C++ host and communicate with the device in unmanaged code isn’t a daunting task. More sophisticated POS solutions may require more than one peripheral type. They may even require supporting different device configurations, i.e. bar code readers from different vendors. These types of POS applications typically require POS abstraction frameworks like POS for .NET. However, in that case the host application could be either a managed C++ application with C++ code to implement the COM host for the Silverlight “bridge” application and .NET code to manage peripheral interaction.

Pro	Con
Loose coupling between peripheral management and UI	Local deployment of peripheral management application required
Shareable bridge	More complex architecture with two applications

To close with some food for thought, there may be a completely browser based alternative that I haven’t tested out yet. Instead of running a Silverlight bridge in a separate Win32 application you could try to build a C++ ActiveX control to host the Silverlight “bridge” and the native device interaction code. This approach presents some security challenges that can be mitigated, but you still have to deal with the perceptions of pushing down an ActiveX control.

You do have the benefits of clean separation between a cross-platform application that run on any platform that supports Silverlight and the platform specific extensions that need to manage interaction with local peripherals. You also have the benefit of a fully browser-based deployment model.

Pro	Con
Fully browser-based deployment model	Native code development of ActiveX control
	Policies for secure ActiveX execution required to avoid security risks

WcfTestClient with Windows Azure

ChristophDotNet — Fri, 30 Oct 2009 16:25:13 GMT

One of my customers is working on an Azure WCF service. When wanted to test the service with WcfTestClient, but we ran into some issues. We started the dev fabric and had the WebRole running on port 81. When we went to the WCF service metadata page at http://mybox:5101/ProdKService.svc, we got the expected web page, which states:

To test this service, you will need to create a client and use it to call the service. You can do this using the svcutil.exe tool from the command line with the following syntax:

svcutil.exe http://mybox:5101/ProdKService.svc?wsdl

This will generate a configuration file and a code file that contains the client class. Add the two files to your client application and use the generated client class to call the Service.

Note that the instructions point you to port 5101 in the service URL. That’s the port where the Azure instance is running in my local development fabric. It is not as we would expect the address of the Azure dev fabric which is running on port 81. We tried to follow the instructions and point WcfTestClient to the address on the page, but instead of testing the service, we got this not so friendly error message:

Error: Cannot obtain Metadata from http://mybox:5101/ProdKService.svc If this is a Windows (R) Communication Foundation service to which you have access, please check that you have enabled metadata publishing at the specified address. For help enabling metadata publishing, please refer to the MSDN documentation at http://go.microsoft.com/fwlink/?LinkId=65455.WS-Metadata Exchange Error URI: http://mybox:5101/ProdKService.svc Metadata contains a reference that cannot be resolved: 'http://mybox:5101/ProdKService.svc'. There was no endpoint listening at http://mybox:5101/ProdKService.svc that could accept the message. This is often caused by an incorrect address or SOAP action. See InnerException, if present, for more details. The remote server returned an error: (400) Bad Request.HTTP GET Error URI: http://mybox:5101/ProdKService.svc There was an error downloading 'http://mybox:5101/ProdKService.svc'. The request failed with HTTP status 400: Bad Request.

Now this is weird. We know that metadata publishing is enabled, because we got the instructions for the WSDL address from the metadata page in the first place.

If you look at the address line in the browser when the Azure dev fabric launches, you note that the local fabric is listening on localhost port 81, not mybox port 5101. localhost is IP address 127.0.0.1, whereas mybox is bound to the IP address on my corporate network. . Is instructed, we tried to get the WSDL with http://127.0.0.1:81/ProdKService.svc?wsdl and we’re getting a different error in in WcfTestClient:

Error: Cannot obtain Metadata from http://mybox:5101/ProdKService.svc If this is a Windows (R) Communication Foundation service to which you have access, please check that you have enabled metadata publishing at the specified address. For help enabling metadata publishing, please refer to the MSDN documentation at http://go.microsoft.com/fwlink/?LinkId=65455.WS-Metadata Exchange Error URI: http://mybox:5101/ProdKService.svc Metadata contains a reference that cannot be resolved: 'http://mybox:5101/ProdKService.svc'. Could not connect to http://mybox:5101/ProdKService.svc. TCP error code 10061: No connection could be made because the target machine actively refused it 127.0.0.1:5101. Unable to connect to the remote server No connection could be made because the target machine actively refused it 127.0.0.1:5101HTTP GET Error URI: http://mybox:5101/ProdKService.svc There was an error downloading 'http://mybox:5101/ProdKService.svc'. Unable to connect to the remote server No connection could be made because the target machine actively refused it 127.0.0.1:5101

It took a little bit to figure this one out since the error message is so similar to the first one. The difference is only in the InnerException and you have to look at the WSDL at http://mybox:5101/ProdKService.svc?wsdlto understand the error.

The culprit for this error is the schemaLocation reference in the WSDL:

<xsd:import schemaLocation="http://mybox:5101/ProdKService.svc?xsd=xsd0" namespace="http://tempuri.org/" />

Even though we retrieved the WSDL from the localhost address, the WSDL generator in WCF generates a reference to the other network address.

Since there’s no easy way to configure the Metadata generator in WCF to switch the hostname for the schemaLocation, I added the hostname to my C:\Windows\System32\drivers\etc\hosts

127.0.0.1 mybox

After restarting the Azure dev fabric, WcfTestClient was able to read the MEX metadata for the service.

I also tried another work-around since not everybody modifying the hosts file may not be possible (although you also need admin rights for running the dev fabric). There is still Christian’s old FlatWsdl trick.

Adding the FlatWsdl extension and configuring the ServiceHost Factory in the Services’ s .svc file got WcfTestClient to work, too.

Need Help Migrating to SQL Azure?

ChristophDotNet — Tue, 20 Oct 2009 21:47:21 GMT

Migrating an existing SQL Server database to SQL Azure is a compelling story, but it’s not a trivial task … unless you start with the SQL Azure migration wizard put together by my team mates George and Wade.

They just updated the wizard to support SQL Azure CTP 2. Details at: http://blog.wadewegner.com/index.php/2009/10/15/the-sql-azure-migration-wizard-will-now-migrate-your-data/

WinMo App Store Questions? I got answers

ChristophDotNet — Mon, 05 Oct 2009 18:09:37 GMT

The Windows Mobile app store is about to launch. The team launched a number of videos on the Windows Mobile Dev Channel on YouTube to walk you through the submission process for your application, but as I’m working with the team over at TripCase, we had a few more questions that we got answered over the past weeks. I thought they worth sharing:

Q: My app runs on Windows Phone Standard (i.e. SmartPhone, SP, no-touch) and Windows Phone Professional (Pocket PC, PPC, with touch screen). The application is packaged in a single cab file. The AppStore submission UI doesn’t let me select both platforms. How do I make sure I reach both groups of users

A: Submit the app twice. Once for Standard, once for Professional. You can submit with the same name.

Q: I want to make an update to my application to fix a bug or a spelling error, change the description, etc. What do I do?

A: Fix your cab, don’t change the version number of the application. Re-submit – it’s free.

Q: I’m getting an error: Unable to enable shim engine on device when running the AppVerifier. Help! How do I fix this?

A: Most commonly, the Windows CE 5.0 Test Kit is missing on your machine or you haven’t replaced the libraries as outlined in the release docs. Replace the Application verifier binaries in the processor folder for the device type. For example, replace C:\Program Files\Windows CE platform builder\5.00\CEPB\wcetk\DDTK\ARMV4I with C:\Program Files\Application Verifier for Mobile 5.0\Armv4i.

If you’re testing with retail devices, then you also need to sign Privileged Certificate. Make sure your app meets the requirements for the cert.

Steve has more details.

Q: Do my customers need to install .NET CF Versions that my application needs?

A: No. The Marketplace client takes care of installing the required version of the Compact Framework.

Q: I want to distribute my application through other channels than the Windows Mobile Marketplace. Can I distribute the certified and signed cab from Marketplace?

A: No: You need to sign the cab with your own certificate. Applications signed with the Marketplace certificate can only be distributed from Marketplace.

Looking forward lots of cool WinMo apps on Marketplace.

Win7 Multi-touch. Why wait until WPF4?

ChristophDotNet — Wed, 23 Sep 2009 13:30:23 GMT

WPF 4 is going to fully integrate Win 7’s multi-touch capabilities. with Windows 7 being RTM, you don’t have to wait for WPF 4 to be released for developing multi-touch demos. You can get started today with the native Win7 APIs, or with the WindowsTouch library for .NET 3.5SP1. The .NET library is much easier to work with since the native APIs are rather low level and based on the existing tablet APIs.

Check out the link to the Win 7 .NET Interop Sample or the Channel9 video: http://channel9.msdn.com/shows/Continuum/MultitouchLibraryWin7/.

Lynn’s blog post discusses the question on multi-touch with .NET 3.5 or 4.0: http://blogs.msdn.com/socaldevgal/archive/2009/06/15/socaldevgal-wishes-to-decide-net-3-5-or-net-4-0-for-windows-7-multi-touch-application-development.aspx. It’s got more useful links to multi-touch development on Win7 resources as well.

At least until WPF4 ships, there is a viable option to build production apps with multi-touch. There are some differences how WindowsTouch and WPF4 implement things, and you’re probably encountering a little bit of re-work, but both options are based on WPF and most of your UI and you code-behind should stay the same and you learn the UI Design Guidelines for Touch right away.

Enjoy.

Seadragon Mobile for the iPhone

ChristophDotNet — Sun, 14 Dec 2008 18:46:25 GMT

The iPhone always reminds me of Finding Nemo (iPhones, they think they’re so cute. Oh, look at me, I’m a flicky little iPhone, let me flick for you. ). Yesterday, Bill Crow from Live Labs just posted about an app that makes the iPhone even cooler – and yes, it’s from Microsoft! That’s the coolest part of it

If you have an iPhone, then check it out. DeepZoom is one of the best features in Silverlight 2 that’s behind the Hard Rock Cafe Memorabilia app or my Innovation Tips & Tricks “Deck” and now SeaDragon Mobile is available for free on the iPhone, too

And for those of you that' don’t have an iPhone and don’t run Silverlight. You can now run SeaDragon Ajax, purely browser based, without an add-on.

Resolving Errors - Moving to Silverlight2 RTW

ChristophDotNet — Sun, 12 Oct 2008 21:16:00 GMT

Following Jesse’s and Pete’s excellent posts on porting Silverlight2 apps from Beta 2 to the final release bits I thought I add just a little more information.

As I worked with one of my customers that’s featured in the launch press release through their code, I thought it would be nice to understand the error you’re getting as you port.

1. The new app type. This is a well documented first step you need to take to see more than the “download silverlight” badge.

The fix is easy. Change the <object> tag from

<object data="data:application/x-silverlight," type="application/x-silverlight-2-b2" …>

<object data="data:application/x-silverlight-2," type="application/x-silverlight-2" … >

2. Fix your references to the vsm namespace (xmlns:vsm="clr-namespace:System.Windows;assembly=System.Windows")

Those result in XamlParseException with error code AG_E_RUNTIME_MANAGED_UNKNOWN_ERROR. Curiously enough those exceptions occur on the LoadComponent call that’s loading and parsing Xaml from the .xap (as explained by Shawn), but the exception details don’t give you much details what you need to get rid of them. For example, your code may reference the vsm namespace in the Application.Resources element in the App.xaml:

<vsm:Application.Resources>

If that’s the case, the exception will occur when parsing the first child of <vsm:Application.Resources>. In my case, that was the line with the closing tag of a ContentPresenter (which has other issues (see below)). Unfortunately, that inconsistency is not caught by the Xaml validator in Visual Studio. Simply changing the Application.Resources element to:

<Application.Resources>

will get rid of this exception.

3. The next class of errors is another XamlParseException with the error code: AG_E_PARSER_PROPERTY_NOT_FOUND.

The culprit is again the namespace reference to the System.Windows namespace, often referenced with the vsm prefix. Again, you will see this exception not on the element that’s actually causing the problem. In my case it was again </ContentPresenter>.

Search and Replace of vsm:Setter and vsm:Setter.Value with the “Entire Solution” option gets rid of these errors pretty quickly. While you’re at it, replace vsm:Style with Style.

4. ScrollViewer and other ContentControl derived classes no longer have Text* properties.

You’ll get validation errors when the parameters are set explicitly in code, but you get a XamlParseException: Invalid attribute value TextAlignment for property Property.

when you define a Style that would set TextAlignment and TextWrapping properties.

<Style x:Key="RightScrollbarScrollerTemplate" TargetType="ScrollViewer">

    <Setter Property="TextAlignment" Value="Left"/>

    <Setter Property="TextWrapping" Value="NoWrap"/>

Those properties were removed for compatibility with WPF. You now have to make sure that the ContentControl’s container sets Text* properties correctly – either explicitly or via <Style>

5. ContentPresenter no longer derives from Control, thus it’s missing a number of properties that could be set in code or in XAML.

Jesse posted about solving these issues at length. The good news is that you can catch this issue at design time through Visual Studio warnings:

The property 'Foreground' does not exist on the type 'ContentPresenter' in the XML namespace 'http://schemas.microsoft.com/winfx/2006/xaml/presentation'

and at run time with XamlParseExceptions when launching the app: XamlParseException: Unknown attribute Foreground on element ContentPresenter.

6. The name of the Duration property on Visual Transition changed to GeneratedDuration.effects you’ll see are:

Compiler errors:

The property 'Duration' was not found in type 'VisualTransition'.

and Validation warnings:

The property 'Duration' does not exist on the type 'VisualTransition' in the XML namespace 'clr-namespace:System.Windows;assembly=System.Windows'.

Follow Jesse’s instructions to fix it.

For other issues check the breaking changes documentation or start with Mike’s post

Mobile Client Software Factory on VS 2008? Sure!

ChristophDotNet — Thu, 25 Sep 2008 13:21:23 GMT

One of my customers was interested in some of the cool features of the Mobile Client Software Factory, but they wanted to develop on Visual Studio 2008. The original version from p&p wasn’t updated to VS 2008, but Glenn Block has a post that describes how to get MSCF to run in VS 2008.

We had some initial problems getting it to work.If you do, too, here are some things to check:

Make sure you have v.1.4 of GAT/GAX installed:

1) GAX February 2008 Release

http://www.microsoft.com/Downloads/details.aspx?familyid=DF79C099-4753-4A59-91E3-5020D9714E4E&displaylang=en

2) GAT for VS2008 - February 2008 Release

http://www.microsoft.com/Downloads/details.aspx?familyid=B91066B3-D1D6-4990-A45F-34CF8DBDC60C&displaylang=en

You may need also to change the GATRegistry value to “Installer\Products\A741EEBC995A0984782CC041A01336F3”.

Additionally, the MSCF MSI performs checks for ActiveSync 4.5 and Windows Mobile Pocket PC 5.0 SDK.

For ActiveSync on WinXP you need:

http://www.microsoft.com/windowsmobile/en-us/downloads/eulas/eula_activesync45_1033.mspx?ProductID=76

On Vista you don’t have ActiveSync but you need WMDC:

http://www.microsoft.com/downloads/details.aspx?FamilyId=46F72DF1-E46A-4A5F-A791-09F07AAA1914&displaylang=en

Once you have ActiveSync or WMDC you can install WM5.0 Pocket PC SDK.

http://www.microsoft.com/downloads/details.aspx?familyid=83A52AF2-F524-4EC5-9155-717CBE5D25ED&displaylang=en

Also note, that if you’re after the Orientation Aware Control from the mobile composite UI block, Clarius has a newer version for VS 2008

Apple ... Puhleeeeeeeeeze ...

ChristophDotNet — Sun, 07 Sep 2008 02:36:28 GMT

Apple is the new Microsoft? Right ... they sneak Safari and MobileMe onto my system - without me asking. That's the kind of stuff Microsoft got in trouble for back in the mid 90s. Isn't it?

Now they are fast approaching being the new Netscape:

C'mon, can't you guys write software that doesn't crash when I don't want to install your products? (but hey, at least you asked me this time).

Presentation Canvas - Not Your Average PowerPoint

ChristophDotNet — Fri, 15 Aug 2008 23:55:20 GMT

The linear style forced by PowerPoint and the metaphor of a slide may have reached their limits. At least support for other styles is on its way ... of course also from the Office team. The innovation team in Office Labs to be exact.

If you've seen my "interactive deck" from TechEd or the some recent Bill Gates demos then or the cool TouchWall demo for example, both showed the concept of a single canvas that you explore during a presentation instead of flipping from one slide to the next.

The concept is very cool and promising, especially when you want to keep around all the information you collect as you build up a presentation. I tend to collect quotes, images, web pages, screenshots, all sorts of stuff that may or may not make it into the presentation. I have tons of OneNote books just filled information I collected for presentations.

Of course, there's always this one guy in the audience that asks questions about things I didn't include in the deck.

With the new tool from Office Labs, pptPlex you get a PowerPoint add-in to build these single canvas presentations in PowerPoint.

It's way easier to use than my rather manual process for my DeepZoom app, which is build the image with DeepZoom composer, then add various types of hotspots with a little Silverlight app.

Have fun with the app.

Innovation - Explore the Interactive Deck from TechEd 2008

ChristophDotNet — Thu, 07 Aug 2008 14:45:45 GMT

As promised at my TechEd 2008 chalk talk Innovation 101: Tips & Tricks for Architects & Developers to Drive Innovation, here's a slightly evolved version of my interactive deck. I had thought that a talk on innovation should innovate on the presentation tools and technique and here's what came out.

Click on the image to launch the application and start exploring the presentation canvas by panning downward DeepZoom style.

You can jump between chapters with the '+' and '-' keys on the number pad. The chapters in this deck are:

Title Slide
Why Innovation Matters and how to get started
Processes, Styles and Ingredients of Successful Innovation
Fail-Fast Pilot & Pitch
Tools (Software and Motivational)
Case Study: Microsoft's IdeAgency
Case Study: Dell's IdeaStorm
Myths and Gotchas
Go and Innovate

Additional Navigation Aids are:

<Home> - Zoom Out to show the entire canvas
<Backspace> - Previous zoom level
<Arrow Keys> - pan around the canvas
<Mouse Wheel> - DeepZoom in and out

The idea for this presentation was borrowed from the Office Live team. They are they guys behind the TouchWall demo Bill Gates gave earlier this year and the LaserTouch shown at the Microsoft Research Roadshow. They just didn't have anything ready for me to show this summer. Fortunately, I still had some Silverlight DeepZoom code for a navigation hotspot framework laying around that I had written for a proof-of-concept earlier this year, which allowed me to pretty quickly build my own presentation app and a tool that helps with authoring the hotspots. Next time, I'll take more advantage of the framework's features with video, nested DeepZoom and others.

I hope you enjoy exploring the presentation adn please drop me a note if you're interested in the further conversations.

Much Thanks to Randy and the IdeAgency, Office Labs, Arvindra for being brave enough to present with the tool already, Ben Williams for his help with Silverlight Streaming to host the app.