Jamie Dixon's Home

Curse you copy/paste gremlin!

I was on to deserializing my Windows Phone 7 game data when I ran across this oh-so helpful exception:

System.InvalidOperationException was unhandled Message=There is an error in XML document (0, 0).

And the cause?  I copy and pasted the code for both the turn class and the tiles list .  However, I didn’t update the stream name (turnStream).

IsolatedStorageFileisolatedStorageFile=IsolatedStorageFile.GetUserStoreForApplication();
//Turn
IsolatedStorageFileStreamturnStream=isolatedStorageFile.OpenFile("turn",FileMode.Open);
XmlSerializerturnSerializer=newXmlSerializer(typeof(List<Turn>));
Game.Turns=(List<Turn>)turnSerializer.Deserialize(turnStream);
 
//Tile
IsolatedStorageFileStreamtileStream=isolatedStorageFile.OpenFile("tiles",FileMode.Open);
XmlSerializertileSerializer=newXmlSerializer(typeof(List<Tile>));
Game.BoardFactory.Tiles=(List<Tile>)turnSerializer.Deserialize(turnStream);

This is another good example of why you should break out 1 task into its own function – I would have gotten a compile exception right away and wouldn’t have spent a hour chasing down ghosts in my object model and other such red herrings…

WP7 Phone Capabilities

Note to self.  When adding a Web Browser to a Windows Phone 7 page like this:

<phone:WebBrowser x:Name="HelpBrowser"
                    Grid.Row="1"
                    HorizontalAlignment="Stretch"
                    VerticalAlignment="Stretch"
                    />

and code up a navigation like this:

public GameInformation()
        {
            InitializeComponent();
            this.HelpBrowser.Loaded += new RoutedEventHandler(HelpBrowser_Loaded);
        }

        void HelpBrowser_Loaded(object sender, RoutedEventArgs e)
        {
            this.HelpBrowser.Navigate(new Uri(Constants.HelpDocumentsLocation, UriKind.Absolute));
        }

and you get an exception like this:

You are forgetting the capabilities section of the phone app for web browsers.  The inner exception about privileges gives it away (short of actually telling you what happened).  Just add this to the WMAPPManifest.xml file:

<Capabilities>
      <Capability Name="ID_CAP_NETWORKING" />
      <Capability Name="ID_CAP_WEBBROWSERCOMPONENT" />

Faking Synch WCF calls in WP7

So you can’t do synchronous WCF calls in Windows Phone 7. I have a use case where I do a WCF call to get all of the data to set up a game board of the phone game I am writing. I don’t want the application to progress until the board is set up, so I need it as a blocking call. In addition, the WCF call is 5-6 layers deep in my class hierarchy.  My first idea was just to use a non-thread-safe variable from the Main UI thread and set the flag when the asynch call/thread returned:

        private List<ScenarioTile> GetScenarioTilesFromWebService(int scenarioId)
        {
            CallbackComplete = false;
            PanzerProxy.PanzerClient panzerClient = new PanzerProxy.PanzerClient();
            panzerClient.GetScenarioTilesCompleted += new EventHandler<PanzerProxy.GetScenarioTilesCompletedEventArgs>(panzerClient_GetScenarioTilesCompleted);
            panzerClient.GetScenarioTilesAsync(scenarioId);
            while (CallbackComplete == false)
            {
                Thread.Sleep(1000);
            }
            return ScenarioTiles;
        }

        void panzerClient_GetScenarioTilesCompleted(object sender, PanzerProxy.GetScenarioTilesCompletedEventArgs e)
        {
            ScenarioTiles = new List<ScenarioTile>();
            List<PanzerProxy.ScenarioTile> proxyTiles = e.Result as List<PanzerProxy.ScenarioTile>;
            foreach (PanzerProxy.ScenarioTile proxyScenarioTile in proxyTiles)
            {
                ScenarioTiles.Add(ConvertProxyScenarioTileToScenarioTile(proxyScenarioTile));
            }
            CallbackComplete = true;
        }

The problem is that, well, it doesn’t work. The app just hangs. I then thought of using a ManualResetEvent or AutoResetEvent class to trigger like this:

        ManualResetEvent manualResetEvent = new ManualResetEvent(false);

        private List<ScenarioTile> GetScenarioTilesFromWebService(int scenarioId)
        {
            PanzerProxy.PanzerClient panzerClient = new PanzerProxy.PanzerClient();
            panzerClient.GetScenarioTilesCompleted += new EventHandler<PanzerProxy.GetScenarioTilesCompletedEventArgs>(panzerClient_GetScenarioTilesCompleted);
            panzerClient.GetScenarioTilesAsync(scenarioId);
            manualResetEvent.WaitOne();
            return ScenarioTiles;
        }

        void panzerClient_GetScenarioTilesCompleted(object sender, PanzerProxy.GetScenarioTilesCompletedEventArgs e)
        {
            ScenarioTiles = new List<ScenarioTile>();
            List<PanzerProxy.ScenarioTile> proxyTiles = e.Result as List<PanzerProxy.ScenarioTile>;
            foreach (PanzerProxy.ScenarioTile proxyScenarioTile in proxyTiles)
            {
                ScenarioTiles.Add(ConvertProxyScenarioTileToScenarioTile(proxyScenarioTile));
            }
            manualResetEvent.Set();
        }

Still no luck.  I then ran across this thread – basically you can’t do anything to block the Main UI thread.  Chong’s solution was to launch a 3rd thread from the secondary thread.  That seemed to me as overly complex and smelled of brittle code.  I then took a step back and realized I just had to architect my solution to get the same effect.  Basically, once the user hits the LOAD button, the MAINUI thread is done.  However, the page also subscribes to an event that the business logic raises.  Once the event fires, then the app progresses to the next page.

So instead of this:

private void SetupScenario(int scenarioId)
{
    Game.CurrentScenarioId = scenarioId;
    Game.BoardFactory.PopulateBoard(scenarioId);
    Game.CurrentBoard = Game.BoardFactory.Board;
    Game.Turns = Game.TurnFactory.GetTurnsForAScenario(scenarioId);
    this.NavigationService.Navigate(new Uri(@"/Briefing.xaml", UriKind.Relative));
}

I have this:

private void SetupScenario(int scenarioId)
{
    Game.CurrentScenarioId = scenarioId;
    Game.BoardFactory.BoardLoaded += new EventHandler<EventArgs>(BoardFactory_BoardLoaded);
    Game.BoardFactory.PopulateBoard(scenarioId);
    Game.CurrentBoard = Game.BoardFactory.Board;
    Game.Turns = Game.TurnFactory.GetTurnsForAScenario(scenarioId);

}

void BoardFactory_BoardLoaded(object sender, EventArgs e)
{
    this.NavigationService.Navigate(new Uri(@"/Briefing.xaml", UriKind.Relative));
}

The event is defined as simple as it comes:

public event EventHandler<EventArgs> BoardLoaded;

and

void TileFactory_TilesLoaded(object sender, EventArgs e)
{
    Tiles = Game.TileFactory.Tiles;
    Hexes = Game.HexFactory.GetHexes(Tiles);
    foreach (Hex hex in Hexes)
    {
        Board.MainCanvas.Children.Add(hex);
    }
    SetBoardDimensions(Board, Tiles);
    BoardLoaded(null, null);
}

Basically I just bubbled up the WCF asych event up from the lowest level to the UI page.

Using Lambdas To Increase Code Readability

I was having a spirited debate with Rob Seder yesterday about the use of lambdas – the question was weather using them increases or decreases the codes readability.  For example, here is a basic for…each:

1             foreach (Employee employee in employeeFactory.GetAllEmployees())
2             {
3                 if (employee.Name == "Moe")
4                 {
5                     Console.WriteLine(employee.ToString());
6                 }
7             }

Replacing with a lambda:

1             var moe = employeeFactory.GetAllEmployees().Where(e => e.Name == "Moe").FirstOrDefault();
2             Console.WriteLine(moe.ToString());

Readability suffers for three reasons: the function chaining. the use of single letters for the variable, and the use of the var keyword.  A more readable use of lambda is like so:

1             List<Employee> employeeList = employeeFactory.GetAllEmployees().ToList();
2             Employee selectedEmployee = employeeList.Where(employee => employee.Name == "Moe").FirstOrDefault();
3             Console.WriteLine(selectedEmployee.ToString());

Taking the problems in reverse, Rob mentioned that he uses the var keyword when he is knocking something out, then he goes back and refactors the var keyword to the correct type.  I would agree with this.  As for the single varaible, I am less convinced that readability suffers because

• Everyone does it – making this convention readability by default
• You actually don’t use the variable – it is not returned or acted on beyond the line of code.

As for function chaining, I can see why readability suffers.  Breaking out the functions into logic units of work with each getting their own line seems reasonable.