All I had to do was select the settings:

Then, select the screen size I wanted:

The screen could scale accordingly now.

Examples

100% (Very Large) – Its so big that it falls off the screen.

50% (Smaller), now it fits nicely, however the UI is hard to read.

This makes life much easier when developing for a high resolution system on a non-high resoution system.

File –> New

As soon as the tools are installed you can select File –> New Windows Phone Application, as seen below:

Selecting a new Phone app, I was able to get some XAML on the screen, edit the XAML and get my first Hello WP7 app up in running in under 5 minutes. This very impressive. The emulator started right up, I waited for about 30 seconds while it booted and then my app started. As shown below:

All in all, it was a super simple process.

Boot to VHD

It is important to note that working from a virtualized environment is not supported with the Dev Tools for WP7. However, you can boot to vhd and it will work great (which is 10x better than a VPC in my opinion for regular dev anyway).

So if you havent already, start utilizing Boot to VHD, set a a new one and get started with the new WP7 tools. Its cool/fun stuff.

The one thing that the Toolkit did not provide out of the box was a way to use a container in the controller factory. Therefore I altered the ResourceControllerFactory to use Windsor Container as its default container. The code works great and I’m able to utilize dependency injection all throughout my app now.

The code for this is below:

//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//----------------------------------------------------------------

using Castle.MicroKernel;

namespace System.Web.Mvc.Resources
{
    using System.Collections.Generic;
    using System.Globalization;
    using System.Net;
    using System.Net.Mime;
    using System.Text;
    using System.Web.Routing;

    /// <summary>
    /// Specialized ControllerFactory that augments the base controller factory to make it RESTful - specifically, adding
    /// support for multiple formats, HTTP method based dispatch to controller methods and HTTP error handling
    /// </summary>
    public class ResourceControllerFactory : IControllerFactory
    {
        // Note: This has been changed from the regular controller factory provided
        // by the ASP.NET Team so that we can use Windsor Container to resolve
        // container dependencies.

        readonly IKernel _kernel;
        const string restActionToken = "$REST$";

        public ResourceControllerFactory(IKernel kernel)
        {
            _kernel = kernel;
        }

        public IController CreateController(RequestContext requestContext, string controllerName)
        {
            IController ic = _kernel.Resolve<IController>(controllerName.ToLowerInvariant() + "controller");
            Controller c = ic as Controller;
            if (c != null && WebApiEnabledAttribute.IsDefined(c))
            {
                IActionInvoker iai = c.ActionInvoker;
                ControllerActionInvoker cai = iai as ControllerActionInvoker;
                if (cai != null)
                {
                    c.ActionInvoker = new ResourceControllerActionInvoker();

                    string actionName = requestContext.RouteData.Values["action"] as string;
                    if (string.IsNullOrEmpty(actionName))
                    {
                        // set it to a well known dummy value to avoid not having an action as that would prevent the fixup
                        // code in ResourceControllerActionInvoker, which is based on ActionDescriptor, from running
                        requestContext.RouteData.Values["action"] = restActionToken;
                    }
                }
            }
            return ic;
        }

        public void ReleaseController(IController controller)
        {
            _kernel.ReleaseComponent(controller);
        }

        // This ActionInvoker allows us to dispatch to a controller when no action was provided by the routing
        // infrastructure, but the information is available in the request's HTTP verb (GET/PUT/POST/DELETE)
        class ResourceControllerActionInvoker : ControllerActionInvoker
        {
            public ResourceControllerActionInvoker()
            {
            }

            protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
            {
                if (actionName == restActionToken)
                {
                    // cleanup the restActionToken we set earlier
                    controllerContext.RequestContext.RouteData.Values["action"] = null;

                    List<ActionDescriptor> matches = new List<ActionDescriptor>();
                    foreach (ActionDescriptor ad in controllerDescriptor.GetCanonicalActions())
                    {
                        object[] acceptVerbs = ad.GetCustomAttributes(typeof(AcceptVerbsAttribute), false);
                        if (acceptVerbs.Length > 0)
                        {
                            foreach (object o in acceptVerbs)
                            {
                                AcceptVerbsAttribute ava = o as AcceptVerbsAttribute;
                                if (ava != null)
                                {
                                    if (ava.Verbs.Contains(controllerContext.RequestContext.GetHttpMethod().ToUpperInvariant()))
                                    {
                                        matches.Add(ad);
                                    }
                                }
                            }
                        }
                    }
                    switch (matches.Count)
                    {
                        case 0:
                            break;
                        case 1:
                            ActionDescriptor ad = matches[0];
                            actionName = ad.ActionName;
                            controllerContext.RequestContext.RouteData.Values["action"] = actionName;
                            return ad;
                        default:
                            StringBuilder matchesString = new StringBuilder(matches[0].ActionName);
                            for (int index = 1; index < matches.Count; index++)
                            {
                                matchesString.Append(", ");
                                matchesString.Append(matches[index].ActionName);
                            }
                            return new ResourceErrorActionDescriptor(controllerDescriptor, HttpStatusCode.Conflict, string.Format(CultureInfo.CurrentCulture, "Error dispatching on controller {0}, conflicting actions matched: (1)", controllerDescriptor.ControllerName, matchesString.ToString()));
                    }
                }
                return base.FindAction(controllerContext, controllerDescriptor, actionName) ??
                    new ResourceErrorActionDescriptor(controllerDescriptor, HttpStatusCode.NotFound, string.Format(CultureInfo.CurrentCulture, "Error dispatching on controller {0}, no actions matched", controllerDescriptor.ControllerName));
            }

            // This class is used when we don't find an ActionDescriptor or find multiple matches
            // in this case we want to return an error response but throwing an HttpException from
            // FindAction bypasses the InvokeExceptionFilters, so instead we throw in this custom ActionDescriptor
            class ResourceErrorActionDescriptor : ActionDescriptor
            {
                ControllerDescriptor controllerDescriptor;
                string message;
                HttpStatusCode statusCode;

                public ResourceErrorActionDescriptor(ControllerDescriptor controllerDescriptor, HttpStatusCode statusCode, string message)
                {
                    this.message = message;
                    this.statusCode = statusCode;
                    this.controllerDescriptor = controllerDescriptor;
                }

                public override string ActionName
                {
                    get { return restActionToken; }
                }

                public override ControllerDescriptor ControllerDescriptor
                {
                    get { return this.controllerDescriptor; }
                }

                public override object Execute(ControllerContext controllerContext, IDictionary<string, object> parameters)
                {
                    HttpException he = new HttpException((int)this.statusCode, this.message);
                    ResourceErrorActionResult rear;
                    if (!WebApiEnabledAttribute.TryGetErrorResult2(controllerContext.RequestContext, he, out rear))
                    {
                        rear = new ResourceErrorActionResult(new HttpException((int)this.statusCode, this.message), new ContentType("text/plain"));
                    }
                    return rear;
                }

                public override ParameterDescriptor[] GetParameters()
                {
                    return new ParameterDescriptor[0];
                }
            }
        }
    }
}

You can easily replace the Windsor stuff with StructureMap, NInject, Autofac, etc.

Enjoy.

Here are the slides from last Thursday’s “What’s New in MVC2” talk at the Twin Cities .NET User Group Meeting.

Download Slides

Due to your contribution to the success of Android Market, we would like to present you with a brand new Android device as part of our developer device seeding program. You are receiving this message because you’re one of the top developers in Android Market with one or more of your applications having a 3.5 star or higher rating and more than 5,000 unique downloads.

Very Cool. I wasn’t sure what device I’d get, but further down the email it was mentioned:

You will receive either a Verizon Droid by Motorola or a Nexus One. Developers with mailing addresses in the US will receive either a Droid or Nexus one, based on random distribution.

I’m hoping for a Nexus One only because I’m a T-Mobile customer and I would love to actually USE The phone as well as develop for it.

Why is Google doing this? Plain and simple: Most of us developers who received this have been developing for close to a year or more. That means almost all of us are running on old hardware – eg: G1’s. The new phones have more memory, better displays, multi-touch and most of all … the updated 2.x operating system. The G1 does not have those features. Google is trying to stimulate the growth of the 2.0 market by providing the top devs with new hardware to develop on. Genius.  This theory is also shared by the guys at TechCrunch.

Whatever the reason, I’m anxiously awaiting my 2.0 device. I cant wait to develop for it.

Now… if I could only get Microsoft to send me a phone … hmmmmm

The App

I’m going to be using Steves sample app. When you first first fire it up you will be presented with a link to go to Donn’s list binding demo. This demo emulates using the built in features of MVC2 to great an editable grid or list. It will look like this:

After clicking on that link you will be presented with a grid / list that is editable. I’m going to use the EditorFor() expression based input builder and some custom editor for templates to layout the grid. In the end, the grid will look like this (yes, not pretty, but it demonstrates what can be done with some of the editor templates.

This is a order list that is set up in the controller manually. The Controller invokes the index action with a customer view model. The customer object has a list of orders, and each order has a list of line items. The objects look like this:

Customer

Order

LineItem

Solution Layout

The solution is lain out in a way that we can render the Index.aspx, which will render an  editor for the order. The OrderRow.ascx file is the file we use to display the editor. We do that in the Index.aspx page like so:

These editor templates are stored in your controllers view folder, under a folder called “EditorTemplates” as shown below:

The OrderRow.ascx Editor will handle how each editor is formatted for editing:

We will be using another editor template, “LineItemRow” to format how each line item should be edited. We are using one editor to create another editor, cool!

Here’s the LineItemRow.ascx (which is called from above via the “LineItemRow” parameter in the EditorFor expression based call:

Incremental Sequencing

The reason the list binding works is because we’re using incremental sequencing while building our editor. We’re using for loops. This allows MVC to know where it’s at during the creation of the form. What does this mean in plain English? MVC will generate incremental name and id’s in the HTML, which, when posting back, the DefaultModelBinder will be able to bind back into the complex object type.

Lets delve into this a bit further. This screen is generated with incremental id’s, and the id’s are shown below in the screen shot for ease of understanding:

The raw HTML looks like this (click to enlarge):

Using the incremental sequencing and editor templates allows us to change the values and post them back to the form.

Example

Lets change the name of “Sneakers” to “Shoes”. Then we’ll post the form. Here’s what we see in the post (via the debugger):

Conclusion

Now you can edit the list, post the new updated results and persist them. Fairly simple.

Download the Sample Project (VS2010)

If you’re using VS2008, you can copy the files into a VS2008 MVC2 RC2 Project (minus the project) and it should work.

The value of TempData persists only from one request to the next. (source)

This has changed in MVC2. The TempData dictionary will not persist data until the key is read from the dictionary.

…We’ve changed the implementation in MVC 2 slightly as a result: the value will be removed from TempData after the request in which it is read, so it will continue to exist in your TempData dictionary until you display it in some page. This allows a multi-redirect scenario (such as Windows Live ID login) to use TempData and have it still be hanging around until you’re ready for it. (source)

This is very important to note because if you use MVCContrib’s ModelStateToTempData attribute the values in the modelstate will be persisted across requests as it will be present in the TempData across requests. If you’re using button names as decision criteria in your Http Post  then you might notice that your ModelState is traversing into other actions and showing invalid validation on pages where the model is not of the given type of the model state info that is being presented.

public static class TempDataExtensions
{
	public static void Put<T>(this TempDataDictionary tempData, T value) where T : class
	{
		tempData[typeof(T).FullName] = value;
	}

	public static void Put<T>(this TempDataDictionary tempData, string key, T value) where T : class
	{
		tempData[typeof(T).FullName + key] = value;
	}

	public static T Get<T>(this TempDataDictionary tempData) where T : class
	{
		object o;
		tempData.TryGetValue(typeof(T).FullName, out o);
		return o == null ? null : (T)o;
	}

	public static T Get<T>(this TempDataDictionary tempData, string key) where T : class
	{
		object o;
		tempData.TryGetValue(typeof(T).FullName + key, out o);
		return o == null ? null : (T)o;
	}
}

The code above allows you to put values into TempData in a strongly typed fashion. You can then get the values back out (safely) without worrying about an exception being thrown (temp data will throw if the key is not found).

Usage:

var customer = new Customer();

TempData.Put(customer); // Strongly typed without key

TempData.Put("key1", customer); // Strongly typed with extra key

var tempDataCustomer = TempData.Get<Customer>(); // Get customer without key

var tempDataCustomerWithKey = TempData.Get<Customer>("key1"); // Get customer with key

• Inline Code
• Element Constructs
• Partials
• Layouts
• and more …

I hope you enjoy it! I enjoyed writing it.

A big thanks goes out to Chris G. Williams (twitter)for doing a stellar job on the tech editing.

Read it Here

Note: Part of the conversation seems to insinuate that Flash is the be-all-end-all platform for development. This is not my stance, however, I do feel that some sort of cross platform rich client development standard is going to have a major impact and possible market share once it is introduced across mobile platforms. If that becomes flash/air, so be it. Just wanted to clear that up.

Download it here