After you’ve downloaded the developer tools installer, you will go through a download process…

After downloading the remaining components, you will install all component resources.

Once the developer tools have been installed, you can startup Visual Studio 2010 Express for Windows Phone which is the IDE used for the mobile development.

We will use the Silverlight for Windows Phone – Windows Phone Application project template and add some custom XAML and image resource to the base project.

In this simple application we’ve titled Mobile Portal just going to add some textblocks, buttons, and use a standard Silverlight grid layout. We first modify MainPage.xaml to create our custom view for the mobile application. Here is a view of our coding changes.

Next, we go to our Solution Explorer add our image resource using the context menu on the project and selecting Add -> Existing Item.

Finally, we add our custom styles to App.xaml. After building the solution and running the emulator, we see the following results.

If we rotate the device orientation, we can see how the view shifts to fit the space available.

We are glad to see that Microsoft is embracing the WPF and Silverlight-based development engine for the mobile platform. This decision allows developers and designers skilled in XAML to leverage their existing knowledge and prowess to create useful mobile applications for both business and pleasure. The small footprint of Silverlight makes it ideal for usage with embedded or mobile systems with limited power and memory.

You can download our complete solution here.

Following the Microsoft KB you can see that you need to edit the docicon.xml file located at the path C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\TEMPLATE\XML

The Docicon.xml configuration file is a listing of all document types that are supported by SharePoint. To support the PDF icon, you need to add the following Mapping XML element to the XPath //DocIcons/ByExtension. The Mappings are listed in alphabetical order, so you should insert the PDF mapping accordingly.

<Mapping Key="pdf" Value="pdficon.gif"/>

Here is the Docicon.xml file after the edit.

The next step is retrieving the small PDF icon from Adobe. When you have download the icon image, you need to save the image as “pdficon.gif” to match the mappings entry we created earlier. The last step is to copy the PDF icon image to the SharePoint template images path: C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\TEMPLATE\IMAGES\pdficon.gif. This is the location where SharePoint will search for document type icons for rendering in document library views – according to the configured file extension mappings in docicon.xml.

After these steps have been completed, you can now visually distinguish the document type for PDF extensions with a quick icon type indicator.

To use App Engine, you need a Google Account. Once you have your Google Account, you can enable App Engine services by entering in your cell phone number and carrier on the App Engine setup page. Google will send you an SMS with an access code you need to enter into the website. This activation scheme is Google’s way of restricting you from creating multiple App Engine accounts.

When you have received your code via SMS and entered your activation code, you can begin creating applications. The following appears after you have activated your App Engine account.

When you click “Create an Application” you can enter an application alias where your new application will be hosted on the appspot.com domain.

If your alias is available, you can then create an application and deploy to your new cloud application. In this example, we created the alias “pearlcompanies”.

Since we’re running in a windows environment, our next step is to setup Eclipse and the Google Plugin for Eclipse to deploy to our cloud application. We used Eclipse 3.5 (Galileo) in our example. After unpacking the Eclipse folder contents, we tell Eclipse where to get the Google Plugin. We add the available software site “http://dl.google.com/eclipse/plugin/3.5″ to our Eclipse Preferences.

Download and Install both the Google Eclipse plugin and GWT and App Engine SDKs.

After installing the Google SDKs, we can create Google App Engine projects (Web Application Projects). The nice thing here is that we can run the cloud application locally and verify it before deploying remotely to the cloud. The Google SDK comes with the components necessary to simulate the cloud environment.

Once we have our web project, we can begin creating our WAR package for deployment into the App Engine cloud service. The current App Engine supports Java and Python environments, but in this example we are going to use the Java runtime. Since we’re demonstrating deployment here, we are not going to use any servlets, but simply an HTML front-end. After changing the index.html page in our web project, we click the App Engine icon in the Eclipse toolbar.

After clicking the icon, we are prompted with the deployment wizard which has our Google account credentials and a link to the App Engine project settings. Click the project settings and enter the Application ID and version for the application (use the alias we setup previously).

Click ‘Ok’ on the properties dialog, and then enter your login credentials. Once you click ‘Deploy’, your application will be pushed into the Google App Engine cloud. You can view and manage your applications that are live in the Google App Engine site.

You can view the clone of our Pearl Companies website which we deployed to pearlcompanies.appspot.com. Please let us know about your App Engine experiences. We look forward to using this new powerful platform.

When you receive your access token, you can begin creating projects on the Azure platform with the Azure Developer Portal. You can only create one project with the CTP, but you can have multiple services inside each project (web/worker roles).

After you’ve created your project in the developer portal, you can add services which will be the endpoints you deploy to for Windows Azure. We will add a Windows Azure Service in this example.

To create our Windows Azure application, we need to create a package (cspkg) that contains our application contents and a configuration definition (cscfg) that defines our roles. Microsoft has created Azure tools to assist in generating the package and configuration file. You can download the Azure SDK to create Azure applications using Visual Studio. The Azure SDK allows you to run your own local development fabric before pushing your application into the cloud. Eclipse also has its own Azure Tools if you prefer to develop in the Eclipse environment.

After installation of the Azure Tools, you now have a new project template “Cloud Service” which we’ll use to create our web role.

After clicking “Ok”, you will now have a Cloud Service project and a Web Role project in your solution. We will now remove the Web Role for this exercise, and replace it with an existing ASP.NET application called ASP.NET Chart Controls which Scott Guthrie announced last year. This application did not work on the PDC release of Azure, but Azure now allows web applications to run in Full Trust with some minor tweaking.

We now have our solution complete and have one web role we would like to deploy to the cloud. We must now publish the solution to Azure. We right-click on the Cloud Service project and click “Publish” which opens up the Azure Developer Portal.

After logging in with Windows Live, you want to deploy your application to the Staging Environment before pushing it live. To deploy, you simply select the application package (cspkg) and configuration definition (cscfg) from your “/publish” folder in the cloud service “/bin/Debug” directory.

Clicking on “Deploy” will load the Azure package and service definition to the cloud and create a VM necessary to run the application. The environment takes some time to setup and will show its state as “Initialization” until the VM is entirely ready. You are given a URI based upon a randomly generated GUID to view your application and test it before moving it into production. Having two environments is nice if you also have database changes that need to coincide with your deployment.

Once the application has been verified, you can click the center arrows icon to swap the Staging site into Production. You can see the two environments have now been switched.

Azure does make the deployment process a bit more involved, but there is an managed Azure Deployment API in the works to automate the build and deploy steps you may need in your organization. You can view our sample ASP.NET Chart Controls application running on Azure Services (cloudapp.net). Kudos to Microsoft for allowing full trust applications! We will be watching for more exciting features from the Azure Team.

Although I wasn’t using Sharepoint for this website, I was using jQuery, so I leveraged this idea to print specific portions of a website instead of only Sharepoint specific content. This site was also using jQuery UI for creating rich internet content, specifically the tabs, accordion, and dialog widgets. The incredible thing about widgets is that they allow for highly interactive sites, yet the trouble with widgets is that they are not conducive to easily printing their content.

If you tried printing the default tabs example using jQuery UI, you end up with something that looks like this…

At first glance, you may not realize the problem with this. The content of the inactive tabs is hidden from the print view. In our requirements, we needed to print all the content for each tab, whether it was active or not. Now you begin to see the clash between interactive content and printer friendly widgets.

There is a solution to this problem, but it varies depending on how you setup your widgets. Here are some tips to setup the print view. For printed tabs to work, you need to create some hidden panel headers and utilize some CSS to display the hidden tabs contents. The solution I came up with contains a “Printer Friendly” link which triggers the dynamic CSS changes for printing all the tabs contents.

Add the following HTML to your page where you want the locate the “Printer Friendly” link for the tab widgets.

Printer Friendly Here

Here is the printer friendly window that is created after clicking on the “Printer Friendly” link.

Here is the jQuery script that enables the printer-friendly jQuery UI tabs to happen.

$(function() {
	        $("#tabs").tabs();

	        // remove any print headers that we may have added
	        $("div.printHeader").remove();

	        // assign our id for print navigation removal
	        $("#tabs>ul").each(function() {
	            $(this).addClass("tab-nav");
	        });

	        // create printer friendly tab view
	        $("#tabs>ul>li>a").each(function() {
	            // what tab is this?
	            var tabNum = $(this).attr("href").replace("#", "");

	            // get our content for this tab
	            var tabContent = $("div[id=" + tabNum + "]");

	            // prepend our print header along with tab theme style
	            $(tabContent).before("
\n" +
    	                            "
\n" +
	                                    "
" + $(this).text() + "

\n" +
	                                "


\n" +
	                            "

\n");
	        });

	        drawPrinterFriendly(); // creates printer friendly links
	    });

	    // Prints contents of a dialog
	    // source: http://www.endusersharepoint.com/2008/12/09/jquery-for-everyone-print-any-web-part/
	    // remarks: added removal of printer friendly link
	    function printDialog(tagid, title) {
	        if (tagid) {
	            var CSSContent = ".printInfo,.tab-nav { display:none;}\n.ui-tabs .ui-tabs-hide,.printHeader { display: block !important; }\n";
	            var printCss = "


";
	            // build html for print page
	            // remarks: we use parent here since the dialog is in a wrapped container
	            var html = "\n\n" + $("head").html() + "\n" + printCss + "\n\n\n" + $("#" + tagid).parent().html() +
                    "\n\n";
	            var printWP = window.open("", "printWebPart"); //open new window
	            printWP.document.open();
	            //insert content
	            printWP.document.write(html);
	            printWP.document.close();
	            //open print dialog
	            printWP.print();
	        }
	    }

	    // creates printer friendly link for matching dialog H3 tags
	    function drawPrinterFriendly() {
	        // find all dialogs by their TD
	        var tags = $("*[id^='dialog-']");
	        // loop through dialogs
	        tags.each(function() {
	            //get id for print function
	            var tagid = $(this).attr("id");
	            //append an image with onClick event
	            $(this).find("h3").html("").append(
                        "
" +
                        "  Printer Friendly" +
                        "  " +
                        "

"
                    );
	        });
	    }

You can find the entire solution here. This solution can easily be adapted to work with other widgets (dialogs, accordions, etc.) with the inclusion of the H3 tag inside a div with id prefix “dialog-”. Possibly in the future I will create a jQuery plugin that encapsulates this functionality for simple integration into your site. Have you found a better approach for printing select portions of a page containing jQuery widgets?

You can download EWS from Microsoft (currently an RC) and begin interacting immediately with any server running Exchange 2010 or Exchange 2007 running SP1 or higher. The web service interaction requires SSL and a valid Network Credential for access. The base service is hosted on exchange via the EWS URL below, where <exchange_server_name> is the host name of your Exchange server.

https://<exchange_server_name>/ews/exchange.asmx

To try out EWS in a test environment, you can download the Exchange 2007 virtual machine. Once the Exchange VM (VHD) is running and you are logged in, you need to configure the network settings to utilize automatic IP and DNS settings instead of the default static ones provided. This will assist in routing network traffic to the new machine. To verify the setup, you can browse the following URL below and see the WSDL for the EWS. You will need to ignore the certificate warning and enter a login with access to the service (login as litwareinc\Administrator)

https://ex07sp1/ews/exchange.asmx

The next step is installing EWS. After installation, you can begin creating Visual Studio projects using the new API. MSDN provides a nice introduction and valuable references for working with the managed API. After creating a new Visual Studio project, you need to add a reference to the new assembly Microsoft.Exchange.Webservices.dll (located at the path Program Files\Microsoft\Exchange\Web Services\1.0\ ). Next, we add using statements for the new library reference and also for X509 certificates.

using Microsoft.Exchange.WebServices.Data;
using System.Security.Cryptography.X509Certificates;

Now here’s some simple code to create a connection to the EWS endpoint. The certificate callback is necessary since we’re using a user-generated X509 certificate.

// Hook up the cert callback.
            ServicePointManager.ServerCertificateValidationCallback =
                delegate(Object obj, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
                {
                    // Validate the certificate and return true or false as appropriate.
                    // Note that it not a good practice to always return true because not
                    // all certificates should be trusted.
                    return true;
                };

            // assign exchange version
            ExchangeVersion version = ExchangeVersion.Exchange2007_SP1;

            // create service endpoint connection
            ExchangeService service = new ExchangeService(version);

            // Assign NetworkCredential directly
            service.Credentials = new NetworkCredential("username", "password", "domain");

            // EWS network location
            service.Url = new Uri("https://ex07sp1/ews/exchange.asmx");

Now we’ll create an appointment using this service endpoint. Note: When you add attendees, you actual create a meeting instead of an appointment.

            Appointment appt = new Appointment(service);
            appt.Subject = "Read EWS Documentation";
            appt.Body = "You can download the Exchange 2007 SP2 here: <a href='http://www.microsoft.com/downloads/thankyou.aspx?familyId=ee7829a3-0ae8-44de-822c-908cd1034523&displayLang=en'>SP2 Download</a>";
            appt.StartTimeZone = TimeZoneInfo.Local;
            appt.Start = DateTime.Now.AddDays(1);
            appt.ReminderMinutesBeforeStart = 15;
            appt.End = appt.Start.AddHours(2);
            appt.RequiredAttendees.Add("Administrator@litwareinc.com");
            appt.Save(); // persisted to exchange

To probe deeper, you can follow the exchange developer blog on MSDN. We look forward to the RTM of this powerful managed Exchange API.

The resolution to the BizTalk memory problem relied in the source structure (MemoryStream) we were using for storing our stream for the IBaseMessage.

MemoryStream revisedStream = new MemoryStream();

The discussion helpfully points out that we should be using the VirtualStream with a few caveats. The trick to get the VirtualStream object is to include the source from the BizTalk server samples (<BizTalk Install Path>\SDK\Samples\Pipelines\SchemaResolverComponent\SchemaResolverFlatFileDasm) or use the Microsoft.BizTalk.Streaming.dll as it exists in the GAC (<Windows Path>\assembly\GAC_MSIL\Microsoft.BizTalk.Streaming\3.0.1.0__31bf3856ad364e35\). I chose the later approach, which required adding a reference to Microsoft.BizTalk.Streaming.dll to my custom pipeline solution. I first copied the assembly from the GAC to the <biztalk install path> for future solutions where I may need to reuse the same assembly source. After adding the reference via Visual Studio, it was simply a matter of changing the MemoryStream reference to VirtualStream.

VirtualStream revisedStream = new VirtualStream();

Be sure you rewind the stream before assigning the bodyparts data.

// Rewind the stream so it is ready for use by the messaging engine
revisedStream.Seek(0, SeekOrigin.Begin);

So why does this solution work? Behind the scenes, VirtualStream is wrapping excessive data (user defined, but defaults to >4MB) to temporary disk using a BufferedStream. This is why we can avoid the “System.OutOfMemoryException” – since the VirtualStream will offload the large data stream to disk I/O instead of purely storing our IBaseMessage in RAM (via MemoryStream). Yes, there’s certainly overhead depending on where your temporary directory resides, but in most cases this will be the solution you’re looking for. MSDN docs has other BizTalk specific streams if you want to dive deeper.

The new foundations Board of Directors has some influential players in the OSS realm. One of the directors is Miguel de Icaza, creator of GNOME and currently the project leader in both Mono and Moonlight. Miguel has his own enlightening comments on the new foundation. Another member of the board is Shaun Walker, the original creator of the DotNetNuke project, an incredibly popular OSS web platform.

The goal of the foundation is to bring commercial and OSS communities closer together (e.g. get commercial developers working in OSS projects). The Advisory Panel has some interesting members including Phil Haack, Scott Hanselman, and Larry Augustin. Larry is now CEO of SugarCRM, a popular non-microsoft based OSS web platform. Hanselman also shares some insights into the new foundation.

It’s great to see Microsoft attempting to bridge the gap that exists between developers of OSS and commercial software, but only time will tell if this investment pays off. Software will continue to get better, especially with the OSS community involvement that Microsoft is slowly embracing.

• jQuerify is a simple way to inject the jQuery framework into any website and enable immediate DOM manipulation. To try it out, just drag this link to your bookmark list. Depending on the browser you’re using, you can then enter any javascript commands via the console window in Firebug, IE 8 Developer Tools, or Chrome Developer Tools.

  

  If the website you are visiting already has jQuery installed, the bookmarklet will not inject the framework again.

  

  Here is some sample jQuery code which would highlight a post in red, the blog entry in blue, and perform some simple animation to the sidebar on this website. Click here to see it in action.

  $("div[class=post]:first").css("border", "2px solid red");
  $("div[class=entry]:first").css("border", "2px solid blue");
  $("div[class=sidebg]").slideToggle(4000).fadeIn("fast");

• Firebug Lite is another useful bookmarklet if you’re currently using a browser that doesn’t support plugins or have its own set of developer tools. It has support for both online and offline integration. Click here to see an example or simply drag and drop this link into your bookmarks.

  

  You can now enter commands into the console and manipulate the DOM just like you were using an assisted native browser extension. Enjoy!

Do you have any great developer bookmarklets that you’d like to share? Please comment!

There are two ways I’ve found to connect to SQL Azure. The first is using sqlcmd, a command-line utility and the second is using SSMS query window. Unfortunately, there is no current support for using SSMS “Connect to Database Engine”, but Microsoft is getting much closer to creating rich support for their new cloud-based storage with the latest CTP.

Here is a sample of using the sqlcmd utility. You can substitute your login for <loginname> and your server for <servername>

sqlcmd -U <loginname>@<servername> -S <servername>.ctp.database.windows.net -d master

There are limits to the current SQL Azure CTP for long-running queries and idle connections (e.g. five minute timeout), but overall you can get a good taste for the cloud model. There will be latency associated with using a remote database instead of a local network database, but Microsoft is recommending that you also host your web applications on Windows Azure to get the best performance.

One improvement that I hope to see that will help secure these public endpoints is some sort of whitelist (think about how some web services are secured today) to restrict which users can access the SQL Azure databases open on TCP 1433. Some users have already mentioned this potential security flaw.