ON Blog » Silverlight

Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 3

onishimura — Thu, 29 Jul 2010 09:27:44 +0000

This is part 3 in a 3 part tutorial for creating a notes application using Silverlight and Windows Phone 7. The previous articles can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 1
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2

Download the code here

Currently our application can display a list of notes, and create and save a new note. The last piece of the puzzle is to allow the user to delete an existing note. To accomplish this all we really need to do is add an application bar button to the details page, remove it from the working items list, and save it to isolated storage.

Add the appbar.save.rest.png image in C:\Program Files\Microsoft SDKs\Windows Phone\v7.0\Icons to the Images folder in the project, and set it’s ‘Build Action’ to Content’, and it’s ‘Copy to Output Directory’ proerpty to ‘Copy if newer’.

Change DetailsPage.xaml to include an application bar, with the following code:
```
	
		
		
	
```
The two ApplicationBarIconButton added here will allow the user to return to the main list of notes, or delete the current note being viewed.

Modify the DetailsPage class (DetaislPage.xaml.cs) to do the following

Create a private instance variable to represent the current index of current note
Change the ‘OnNavigatedTo’ method to set this index when the page gets focus
Add event handlers for the delete and back buttons

The DetailsPage class uses an index scoped to the OnNavigatedTo method, and sets the pages DataContext using it. All we really need to do is change it to an instance member and set it in OnNavigated To like so:

private int index;

protected override void OnNavigatedTo(NavigationEventArgs e)
{
	base.OnNavigatedTo(e);

	string selectedIndex = "";
	if (NavigationContext.QueryString.TryGetValue("selectedItem", out selectedIndex))
	{
		index = int.Parse(selectedIndex);
		DataContext = App.ViewModel.Items[index];
	}
}

The event handlers are fairly straightforward. For the delete button, it should remove the note from the working list, save the current list to isolated storage, and finally navigate to the MainPage. The back button should simply navigate the user back to the MainPage.

private void appbar_button1_Click(object sender, EventArgs e)
{
	if (index < App.ViewModel.Items.Count)
	{
		App.ViewModel.Items.RemoveAt(index);
		StorageHelper.Save>(App.NotesFileName, App.ViewModel.Items);
	}
	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

private void appbar_button2_Click(object sender, EventArgs e)
{
	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

After all of these changes your class should look like this

using System;
using System.Collections.ObjectModel;
using System.Windows.Navigation;
using Microsoft.Phone.Controls;

namespace MyNotes
{
    public partial class DetailsPage : PhoneApplicationPage
    {
        // Constructor
        public DetailsPage()
        {
            InitializeComponent();
        }

        private int index;

        // When page is navigated to, set data context to selected item in list
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            string selectedIndex = "";
            if (NavigationContext.QueryString.TryGetValue("selectedItem", out selectedIndex))
            {
                index = int.Parse(selectedIndex);
                DataContext = App.ViewModel.Items[index];
            }
        }

        private void appbar_button1_Click(object sender, EventArgs e)
        {
            if (index < App.ViewModel.Items.Count)
            {
                App.ViewModel.Items.RemoveAt(index);
                StorageHelper.Save>(App.NotesFileName, App.ViewModel.Items);
            }
            NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
        }

        private void appbar_button2_Click(object sender, EventArgs e)
        {
            NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
        }
    }
}

And thats it. We can now add a new note, view a list of current notes and delete an existing note. This note app for Windows Phone 7 is fairly simple in functionality, so naturally there’s many more features you can add. For example, we could allow the editing of notes, or the addition of different types of notes, such as sketches. I’ve added the completed project below.

Download the code here

Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2

onishimura — Tue, 27 Jul 2010 09:19:50 +0000

This is part 2 in a 3 part tutorial for creating a notes application using Silverlight and Windows Phone 7. The other articles can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 1
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 3

In part one of the tutorial we created the project, added a new Note class to serve as our model, and added a StorageHelper class to help us manage IsolatedStorage. The next step is to add support for adding a note to the app. We’ll keep it simple and just use a button on the main page’s application bar to add a note. When a user clicks the add note button on the main page, a new Windows Phone 7 page will load, which will enable the user to enter a note title and note text. They’ll also be able to save the note, or cancel the save, which will return them to the main page.

Add default icons to the project in order to support adding a note, saving a note and canceling the action. When you install the Windows Phone 7 SDK it also installs a number of default icons in C:\Program Files\Microsoft SDKs\Windows Phone\v7.0\Icons. For our purposes we’re going to use the icons in the dark folder, specifically add the following to the Images folder:
- appbar.add.rest.png
- appbar.save.rest.png
- appbar.cancel.rest.png
After adding these icons, modify their properties so that their Resource type is Content and Copy to output directory is ‘Copy if newer’. This allows us to configure the IconUri property on the ApplicationBarIconButton to a path like the following: IconUri=”/Images/appbar.add.rest.png”.
Modify MainPage.xaml and MainPage.xaml.cs to do the following:
- Display the notes properly
- Add a new application bar button
- An event handler for the button’s click
- Refresh the list of displayed notes whenever the page is navigated to. This will allow the user to see the new notes that they’ve added.
In MainPage.xaml change the StackPanel in MainListBox to the following:
```
   
   
```
This allows the notes to be displayed on the main page, displaying the note’s title and createdate. Now add the following application bar before the closing phone:PhoneApplicationPage tag
```
   
        
   
```
This will add our appbar button and use the add icon we added earlier as it’s image. Next we change MainPage.xaml.cs to handle the app bar button’s click event. First add an event handler:
```
        private void appbar_button1_Click(object sender, EventArgs e)
        {
            // Navigate to the new page
            NavigationService.Navigate(new Uri("/AddPage.xaml", UriKind.Relative));

            // Reset selected index to -1 (no selection)
            MainListBox.SelectedIndex = -1;
        }
	
```
This simply uses the base navigation framework in the windows phone 7 version of silverlight to navigate the user to the AddPage page, which we’ll add in a bit. Now modify the OnNavigatedTo method to refresh the data list whenever the page gets focus
```
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            if (DataContext == null)
                DataContext = App.ViewModel;

            App.ViewModel.Refresh();
            MainListBox.ItemsSource = App.ViewModel.Items;
        }
	
```
Modify MainViewModel.cs to add a Refresh method that will set the ViewModel’s current Items property to the latest data in isolated storage. All we really need to do is call the Load method in our StorageHelper class
```
public void Refresh()
{
    Items = StorageHelper.Load>(App.NotesFileName);
}
```
Also, remove the code in the MainViewModel.cs constructor that initializes the ObservableCollection of ItemViewModels. The Refresh method will be called by the MainPage’s OnNavigateTo method (which is also called when the page is first displayed)

Finally, add a new Silverlight xaml page, AddPage.xaml and configure it with Silverlight controls (textblocks and textboxes) for title and note. Additionally, add the application bar items to the AddPage.xaml file for saving and canceling, and modify AddPage.xaml.cs to handle the click events

The xaml for AddPage.xaml should look like the following. Note that we’re using the save and cancel icons we added earlier, for the application bar

The code behind for this page really only needs two events added to it, to save the note and navigate back to the main page, and to navigate back to the main page when the user clicks ‘cancel’

private void button1_Click(object sender, EventArgs e)
{
	Note newNote = new Note { Title = textTitle.Text, NoteText = textNote.Text, CreateDate = DateTime.Now };
	newNote.Save();

	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

private void button2_Click(object sender, EventArgs e)
{
	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

And thats it! We should now be able to add a note to our notes.dat file, and view the new note in a list of notes on our main page. As you can see adding controls and event handlers in silverlight and windows phone 7 is quick and easy. Next up, deleting a note…..

Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 1

onishimura — Sun, 25 Jul 2010 08:24:28 +0000

This is part 1 in a 3 part tutorial for creating a notes application using Silverlight and Windows Phone 7. The other articles can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 3

Admittedly a bouncing ball on Windows Phone 7 isn’t all that useful, so I decided to create a sample application that could do a little more than draw a ball or say ‘hello world’. Ideally I wanted to work with some of the core concepts on the phone, such as lists, navigation and the application bar. Additionally I wanted a Windows Phone 7 app that persisted it’s data, which meant working with Isolated Storage. Obviously this calls for a note-taking app…after all who doesn’t love taking notes? Notes are only second to bouncing balls in my book.

To keep the scope of the app small and focused, I wanted the note app to do only the following

View a list of notes
Add a note
Delete a note

Pretty simple, right? The actual implementation turned out to be fairly quick as well. The full step by step is a little long for a single blog post so I’m breaking it up into three posts. The first post covers creating the project, adding a support class to help manage the isolated storage, and defining the model. The second post will cover adding a note, and the third post will cover deleting a note.

To start with, create a Windows Phone List Application, named MyNotes. This will create a basic silverlight template for managing list-based apps. The structure of the project follows the MVVM pattern, so the views are populated by ViewModel classes, defined in the ViewModel folder.

Here’s a quick run down of the files in the base list project:
- MainPage.xaml : The initial screen of the site, which displays data in a ListBox named MainListBox by default. Selecting an item fires the MainListBox_SelectionChanged which navigates the user to the details page
- DetailsPage.xaml : Individual item details for each item in the list. Clicking on an item on the main page brings you here
- MainViewModelSampleData.xaml : Just as the name states, sample data that’s displayed during design time. Basically allows the design surface to render with the xaml designer.
- MainViewModel.cs : ViewModel for the MainPage, by default the project populates itself with dummy “runtime” data when the project is run. The application has a property, ViewModel, which is an instance of this class and used in both the main page and details page to show the items.
- ItemViewModel.cs : ViewModel for each individual item in the list. This default class has really only three properties, LineOne, LineTwo, LineThree, but also demonstrates an implementation for INotifyPropertyChanged

Create a helper class to save notes data. Local data storage using silverlight in Windows Phone 7 is currently limited to using isolated storage. There’s no limit on the amount of data that can be stored though, other than the physical limit of the device of course. I’ve used something similar to the following in the past (This uses System.Runtime.Serialization so you’ll have to add that as a reference):

using System.IO.IsolatedStorage;
using System.Runtime.Serialization;

namespace MyNotes
{
    public class StorageHelper
    {
        public static T Load(string name) where T : class, new()
        {
            T loadedObject = null;
            using (IsolatedStorageFile storageFile = IsolatedStorageFile.GetUserStoreForApplication())
            using (IsolatedStorageFileStream storageFileStream = new IsolatedStorageFileStream(name, System.IO.FileMode.OpenOrCreate, storageFile))
            {
                if (storageFileStream.Length > 0)
                {
                    DataContractSerializer serializer = new DataContractSerializer(typeof(T));
                    loadedObject = serializer.ReadObject(storageFileStream) as T;
                }
                if (loadedObject == null)
                {
                    loadedObject = new T();
                }
            }

            return loadedObject;
        }

        public static void Save(string name, T objectToSave)
        {
            using (IsolatedStorageFile storageFile = IsolatedStorageFile.GetUserStoreForApplication())
            using (IsolatedStorageFileStream storageFileStream = new IsolatedStorageFileStream(name, System.IO.FileMode.Create, storageFile))
            {
                DataContractSerializer serializer = new DataContractSerializer(typeof(T));
                serializer.WriteObject(storageFileStream, objectToSave);
            }
        }

        public static void Delete(string name)
        {
            using (IsolatedStorageFile storageFile = IsolatedStorageFile.GetUserStoreForApplication())
            {
                storageFile.Remove();
            }
        }
    }
}

Instead of using the ItemViewModel class, we’re going to add our own Model, Note. This requires us to make changes in MainPage.xaml, MainViewModel.cs, DetailsPage.xaml and MainViewModelSampleData.xaml as well, to reflect the new properties. So, create a new folder title Models, and add the Note class below, to it. Also, change all references from ItemViewModel to Note, as this will be the Model we’ll be using going forward (I just did a find and replace on the entire project).

using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.Serialization;

namespace MyNotes
{
    [DataContract]
    public class Note : INotifyPropertyChanged
    {
        private string title;
        [DataMember]
        public string Title
        {
            get
            {
                return title;
            }
            set
            {
                if (value != title)
                {
                    title = value;
                    NotifyPropertyChanged("Title");
                }
            }
        }

        private string noteText;
        [DataMember]
        public string NoteText
        {
            get
            {
                return noteText;
            }
            set
            {
                if (value != noteText)
                {
                    noteText = value;
                    NotifyPropertyChanged("NoteText");
                }
            }
        }

        private DateTime createDate;
        [DataMember]
        public DateTime CreateDate
        {
            get
            {
                return createDate;
            }
            set
            {
                if (value != createDate)
                {
                    createDate = value;
                    NotifyPropertyChanged("CreateDate");
                }
            }
        }

        public void Save()
        {
            ObservableCollection currentNotes = StorageHelper.Load>(App.NotesFileName);
            currentNotes.Add(this);
            StorageHelper.Save>(App.NotesFileName, currentNotes);
        }

        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(String propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (null != handler)
            {
                handler(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}

For xaml files, such as MainViewModelSampleData.xaml you’ll need to change the properties that are bound, for example

Modify your App.xaml.cs file to add the following property. This is just the name of the notes file that will be stored in isolated storage.
```
	public static string NotesFileName
	{
		get { return "notes.dat"; }
	}
```

So now we have a fairly simple starting point. We have a main page, a details page, a class to help us manage isolated storage, and our base model class, Note. Next up, adding a note…

Part 2 is now up and can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2

Windows Phone 7 – List of Tutorials and Resources

onishimura — Thu, 22 Jul 2010 08:11:41 +0000

Following up on yesterday’s post on Windows Phone 7 development, here’s a few of the tutorials and guides I’ve been looking at the past few days. There’s a lot of info to digest so I’ll be adding to this post as I come across more resoucres.

Tutorials and Samples

Scott Guthrie’s Tutorial
http://weblogs.asp.net/scottgu/archive/2010/03/18/building-a-windows-phone-7-twitter-application-using-silverlight.aspx
Introduction to Silverlight on Windows Phone 7 – Creating a list application
http://10rem.net/blog/2010/03/15/building-your-first-silverlight-for-windows-phone-application
Introduction to XNA
http://mobile.tutsplus.com/tutorials/windows/introduction-to-xna-on-windows-phone-7/
Channel 9 Developer Training Kit
http://channel9.msdn.com/learn/courses/WP7TrainingKit/
Code Samples for Windows Phone
http://msdn.microsoft.com/en-us/library/ff431744(VS.92).aspx
Charles Petzold’s Free ebook
http://blogs.msdn.com/b/microsoft_press/archive/2010/03/15/free-ebook-programming-windows-phone-7-series-draft-preview.aspx

Blogs/Community

Windows Phone Developer Blog
http://windowsteamblog.com/Windows_Phone/b/wpdev/
Smarty Pants Coding
http://www.smartypantscoding.com/
Nick Gravelyn’s Blog – Focused on the XNA Framework and game development
http://blogs.msdn.com/b/nicgrave/
Jesse Liberty – Check out the mini-tutorials
http://jesseliberty.com/Tags/phone/
Paul Thurrott
http://windowsphonesecrets.com/
Windows Phone 7 Forums
http://social.msdn.microsoft.com/Forums/en-US/windowsphone7series/threads

Documentation and Resources

Official Developer Portal
http://developer.windowsphone.com/
Class Library Reference
http://msdn.microsoft.com/en-us/library/ff626516(v=VS.92).aspx
Programming Guide for Windows Phone
http://msdn.microsoft.com/en-us/library/ff402551(v=VS.92).aspx
Developer Tools Resouces – Getting started and Developer Fundamentals
http://msdn.microsoft.com/en-us/library/ff402523(v=VS.92).aspx
Design Resources
http://msdn.microsoft.com/en-us/library/ff637515(VS.92).aspx
Windows Phone 7 Jump Start Training Resources
http://borntolearn.mslearn.net/wp7/m/classresources/default.aspx

Windows Phone 7 and Silverlight – Getting started with a Bouncing Ball

onishimura — Tue, 20 Jul 2010 23:55:36 +0000

The beta of the developer tools for Windows Phone 7 was released last week. I was curious to see how different/easy it was to develop for this platform so I decided to convert my old SL 3 bouncing ball app, done AGES ago, to Silverlight 4 and Windows Phone 7. The process was pretty painless and even allowed me to add a few features:

1. Install the tools from http://www.microsoft.com/downloads/details.aspx?FamilyID=c8496c2a-54d9-4b11-9491-a1bfaf32f2e3&displaylang=en if you haven’t already

2. Create a new Windows Phone Application (from templaes: Visual C# – Silverlight for Windows Phone – Windows Phone Application)

3. Modify the ContentGrid, change it to a canvas and add an ellipse:

4. Uncomment the sample app bar code and change it to the following, to add a click event and some descriptive text:

5. In the code behind add the following private instance variables, which are used to determine the initial speed of the ball and the current state of the ball:

private int xVelocity = 5;
private int yVelocity = 5;
private bool isBouncing = false;

6. Add a helper method to start a new bounce, randoming the directions and speed:

private void startNewBounce()
{
	//Make speed, direction random
	Random r = new Random();
	xVelocity = r.Next(3, 10);
	yVelocity = r.Next(3, 10);
	int coin = r.Next(100);
	if (coin > 50)
	{
		xVelocity *= -1;
	}
	coin = r.Next(100);
	if (coin > 50)
	{
		yVelocity *= -1;
	}

	ellipseStoryboard.Begin();
	isBouncing = true;
}

7. Add the storyboard_Completed event. This will move the ellipse and also check for collisions against the layoutroots dimensions. If a collision is found it will reverse the direction. Note that the Y axis is a little funnky here, I had to tweak the upper and lower bounds a bit, partially because of the space the title grid takes up.

protected void ellipseStoryboard_Completed(object sender, EventArgs e)
{
	double ellipseX = (double)ellipseObject.GetValue(Canvas.LeftProperty);
	double ellipseY = (double)ellipseObject.GetValue(Canvas.TopProperty);

	//NOTE: canvas.width - ellipse.width for max, since the left and top properties
	//are based on upper left corner of the object
	//+/- 250 if title is present
	if (ellipseX >= (LayoutRoot.ActualWidth - ellipseObject.ActualWidth) || ellipseX <= 0)
	{
		xVelocity *= -1;
	}
	if (ellipseY >= ((LayoutRoot.ActualHeight - 300) + ellipseObject.ActualHeight) || ellipseY <= -150)
	{
		yVelocity *= -1;
	}

	ellipseX += xVelocity;
	ellipseY += yVelocity;

	ellipseObject.SetValue(Canvas.LeftProperty, ellipseX);
	ellipseObject.SetValue(Canvas.TopProperty, ellipseY);

	ellipseStoryboard.Begin();
}

8. Add an event handler for the app bar button click. All we need to do is start a new bounce (if the ball is already moving this will change the speed/direction of the ball too):

private void appbar_button1_Click(object sender, EventArgs e)
{
	startNewBounce();
}

9. One last piece of functionality, add a start/stop toggle if the user touches the screen. On the emulator this boils down to basically clicking the mouse on the screen. The events used to detect touch inputs are OnManipulationStarted, OnManipulationDelta and OnManipulationComepleted.

protected override void OnManipulationStarted(ManipulationStartedEventArgs e)
{
	base.OnManipulationStarted(e);
	if (isBouncing)
	{
		ellipseStoryboard.Stop();
		isBouncing = false;
	}
	else
	{
		ellipseStoryboard.Begin();
		isBouncing = true;
	}

}

10. Hit f5 and let the emulator load up, it could take a bit but even on my old machine it wasn't too bad. A lot faster than the Android emulator in Eclipse was at least.

The fact that the development language and environment is pretty much the same is compelling. There are some differences though. Debugging in the emulator worked failry well too, clicking on the home button would stop the debugging process but leave the emulator running. Performance on the emulator wasn't fantastic but I guess that's to be expected. Just means I need to get a new computer. As I mentioned I did have to make some adjustments in the collision detection code to account for the title, but there's still a small bar at the top of the emulator that makes it look like the ball isn't hitting the exact top. It might look better on an actual device though, tough to say without having a device to test on.

Download the code here

Silverlight 3 – Simple consumption of a WCF Service

onishimura — Sun, 29 Mar 2009 23:59:28 +0000

Last night we were *supposed* to watch Monsters vs. Aliens but unfortunately those plans went out the window once I realized I was missing a credit card. I managed to find it eventually but since we had missed the movie I figured I’d spend some time playing around with Silverlight 3 and WCF to see if there were any big changes in the beta (other than the obvious new RIA Services). I’ve used WCF in past silverlight projects and for the most part there were no real changes in Silverlight 3. A quick rundown of the steps involved:

Add a new Silverlight project
Add a new Linq to Sql class (Add New Item – Linq to Sql Classes) and add a table from an existing database to the designer (e.g. Orders from Northwind)
Add a new WCF Service to the web project and modify your service implemntation to return a list of orders. (Add New Item – WCF Service). Note that this is a standard WCF service and not a Silverlight-enabled WCF Service.
Modify the endpoint element in your web.config so that it used basicHttpBinding instead of wsHttpBinding (Silverlight only supports basic binding)
Add a datagrid to your MainPage.xaml
Add a Service Reference to the Silverlight project for brevity’s sake. Ensure the ServiceReferences.ClientConfig has the proper values for the endpoint (especially the address and contract attributes). David Betz has a good overview of WCF and assembly reuse in Silverlight.
Modify the MainPage.xaml.cs to load the appropriate data on the load event. For example:

void MainPage_Loaded(object sender, RoutedEventArgs e)
{
ServiceReference1.Service1Client svc = new SL2WCF.ServiceReference1.Service1Client();
svc.GetAllOrdersCompleted += (object aSender, SL2WCF.ServiceReference1.GetAllOrdersCompletedEventArgs args) =>
{
dgMain.ItemsSource = args.Result;
};
svc.GetAllOrdersAsync();
}

No real issues compared to SL 2, but a few gotchas you might run into….

1. When a new service reference is added to a Silverlight 3 project, a ServiceReferences.ClientConfig file is automatically created. However, it seems to set the default contract attribute on the endpoint element to the wrong value. When you run the project for the first time after adding a reference, you’ll likely get the following error:

Could not find default endpoint element that references contract ‘ProjectName.ServiceReference1.IService1′ in the ServiceModel client configuration section. This might be because no configuration file was found for your application, or because no endpoint element matching this contract could be found in the client element.

If you look at the config file you’ll see contract=”ServiceReference1.IService1″. This needs to be a fully qualified namespace, and should be changed to contract=”ProjectName.ServiceReference1.IService1″ (or whatever namespace is specified in your Reference.cs file)

2. If you’re using the dbml designer and have relationships defined between your objects, you’ll likely get an error thrown during the serialization process due to a circular reference. You may get an exception like the following:

ex = {“Object graph for type ‘System.Data.Linq.EntitySet`1[[SL2WCF.Web.ListInvite, SL2WCF.Web, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]’ contains cycles and cannot be serialized if reference tracking is disabled.”}

The primary symptom of this is that your service is called properly without errors, but nothing is returned to the silverlight client. You need to do 2 things in order to resolve the circular reference

Use DataLoadOptions with the DataContext before executing the linq command
Set the Serialization Mode for the dbml to Unidirectional – Essentially this will add the DataContract attribute to your generated classes in ListDb.designer.cs

3. Silverlight cannot handle faults so if your Silverlight WCF Web Service call returns the following:

The remote server returned an error: NotFound

it could be for a number of reasons. To help debug this you can use Web Development Helper or turn on tracing

Getting started with Silverlight 3 – Hello Bouncing Ball

onishimura — Wed, 25 Mar 2009 19:44:25 +0000

I’ve been playing with Silverlight 3 lately and thought I’d post a quick guide on getting started. Note that once installed you can only develop silverlight 3 applications since VS doesn’t support multi-targeting for Silverlight apps.

Also, in order to start the initial install you’ll have to uninstall any previous betas of Blend you may have installed. I had Expression Blend 2.5 installed and received this: Beta and preview versions of Microsoft Expression Blend must be uninstalled before installation can continue. Don’t worry about Silverlight 2, it will automatically uninstall Silverlight 2 for you. All of the links below are available at http://silverlight.net/getstarted/silverlight3/default.aspx, I’ve just added direct links to the files.

Download and install Silverlight 3 Tools (which will also install the SDK and runtime) : Silverlight 3 Toolkit March 2009.msi. Installs to C:Program FilesMicrosoft Silverlight
Download and install Expression Blend 3 Preview : Blend_Trial_en.exe. Installs to Installs to C:Program FilesMicrosoft Expression
Download and install the Silverlight 3 Toolkit : Silverlight3_Tools.exe. Installs to C:Program FilesMicrosoft SDKsSilverlightv3.0ToolkitMarch 2009
Download and install .NET RIA Services preview : RiaServices.msi. Installs to C:Program FilesMicrosoft SDKsRIA Services

Siverlight 3 Videos : http://silverlight.net/learn/videocat.aspx?cat=12#sl3
Silverlight 3 Labs : http://silverlight.net/learn/labs.aspx

One thing to keep in mind, with any new silverlight install, you may need to add the .xap MIME type to IIS (or the web project’s web.config) if you’re running it via IIS instead of casini. This is usually the case when you get a Sys.InvalidOperationException : Could not download the Silverlight application. To do this, add .xap to the MIME types under the IIS category on the main page, and map it to application/x-silverlight-app.

To verify the install worked, let’s create a Hello World application. Create a new project in Silverlight 3 and select ‘Silverligh Application’ as it’s type. Select the defaults for hosting the project in a new asp.net web site. Once the project has loaded modify the MainPage.xaml file so that it looks like this:

Essentially all I’ve done here is to add the controls namespace to the UserControl, and added a label with ‘Hello World’ as it’s content. While this is great for verifying an install it’s pretty boring considering the cool things silverlight is capable of, so I decided to add a bouncing ball to play a bit with the animations in Silverlight. First let’s add a game loop in the form of a storyboard to MainPage.xaml:

Note that there’s really no animations defined here so it will just call the Completed event immediately. Next, add a canvas and an ellipse to the LayoutRoot of the page:

The designer should show a blue ball on a gray background. Now modify the MainPage class to begin the storyboard and move the ball in the ellipseStoryboard_Completed event:

public partial class MainPage : UserControl
    {
        private int xVelocity = 5;
        private int yVelocity = 5;

        public MainPage()
        {
            InitializeComponent();

            ellipseStoryboard.Begin();
        }

        ///
        /// Storyboard loop : this plays continuously since we have nothing defined for the storyboard
        ///
        ///
        ///
        protected void ellipseStoryboard_Completed(object sender, EventArgs e)
        {
            double ellipseX = (double)ellipseObject.GetValue(Canvas.LeftProperty);
            double ellipseY = (double)ellipseObject.GetValue(Canvas.TopProperty);

            //NOTE: canvas.width - ellipse.width for max, since the left and top properties
            //are based on upper left corner of the object
            if (ellipseX >= (canvasMain.ActualWidth - ellipseObject.ActualWidth) || ellipseX <= 0)
            {
                xVelocity *= -1;
            }
            if (ellipseY >= ((canvasMain.ActualHeight) + ellipseObject.ActualHeight) || ellipseY <= 0)
            {
                yVelocity *= -1;
            }

            ellipseX += xVelocity;
            ellipseY += yVelocity;

            ellipseObject.SetValue(Canvas.LeftProperty, ellipseX);
            ellipseObject.SetValue(Canvas.TopProperty, ellipseY);

            ellipseStoryboard.Begin();
        }
    }

This starts the storyboard in the page's constructor, modifies the position and velocity of the ellipse based on it's current position, and reverses velocity if a border has been reached. Note that we call storyboard.begin() again at the end of the completed event, in order to ensure it continuously loops. There's a lot of different ways to implement this, such as using a DispatcherTimer

Big news day from Mix 09

onishimura — Wed, 18 Mar 2009 09:04:19 +0000

Lots of news coming out of Mix 09….

ASP.NET MVC Released

Scott Guthrie recently posted a great (and free) tutorial from his upcoming book here. Not a whole lot of changes from RC2, but you’ll have to uninstall previous versions obviously. You can get the installer here. Note that some addins can cause problems during the install (notably Azure tools), but there’s a hotfix available for it.

Silverlight

Silverlight 3 beta announced : Getting started with Silverlight 3. Tim Heuer has a pretty detailed post regarding the new featuresLooks like there’s a ton of features in the works, new codecs (H.264, AAC,MPEG-4), improved graphics support (3D transform effects). hardware acceleration, and even standalone silverlight apps. Interestingly the download for the silverlight 3 install is smaller than the current silverlight 2 install.

.NET RIA Services

An overview can be found here. Essentially a product/framework that will ease data access for silverlight apps via asp.net. Seems analogous to Adobe’s LiveCycle Data Services

Azure

You can download the latest SDK and Visual Studio tools. On track to release this year, apparently. Some new CTP features have been added, notably FastCGI , .NET full trust., and geolocation (currently limited to two locations in the US). PHP in Azure! This is some needed good news after they suffered a day long outage over the weekend