ON Blog » .NET

Facebook, C# and ASP.NET MVC – Updated code samples for places, wall and offline access

onishimura — Mon, 15 Nov 2010 22:09:51 +0000

The big news a couple of weeks ago was the opening up of the Facebook Places API and launching a Deals Service as well. The Places API is pretty straightforward to work with so I’ve updated the Sample MVC App to show an example of calling it, specifically getting a user’s checkins and search for places given a search term, latitude and longitude, and distance. I’ve also had a few requests to show a few other calls, so I’ve included a sample for displaying a user’s wall (feed) and how to use offline_access to retrieve a user’s wall even when they aren’t logged in. Additionally, I’ve refactored some of the code a bit to be a little cleaner, but I’ve only written samples using the official C# SDk (I assume thats what everyone’s using at this point).

Setting the proper extended permissions

We’re going to be using two new extended permissions here, checkins and offline_access, so the first change we need to make is in Home/Index.aspx.

The first time you log in after making these changes you should get prompted with a confirmation dialog from facebook.

Places and checkins

The code to get a user’s checkins unsurprisingly makes a call to the Facebook Checkin service

	public ActionResult GetCheckins()
	{
		JSONObject checkins = helper.Get("/me/checkins");
		if (checkins != null)
		{
			var data = checkins.Dictionary["data"];
			List checkinData = data.Array.ToList();
			ViewData["Checkins"] = checkinData;
		}

		ViewData["Name"] = Session[Constants.FacebookNameKey];
		ViewData["isConnected"] = helper.IsConnected;

		return View("Index");
	}

The structure of the returned data is as follows:

{
   "data": [
      {
         "id": "CheckinID",
         "from": {
            "name": "UserName",
            "id": "UserId"
         },
         "place": {
            "id": "PlaceId",
            "name": "Giants World Series Victory Parade Route",
            "location": {
               "latitude": 37.78627395,
               "longitude": -122.40441083333
            }
         },
         "application": null,
         "created_time": "2010-11-03T19:45:31+0000"
      }
   ]
}

Note that the data set returned from a call to the checkins api will be paged. I’ve only ever checked in once, hence the single item in mu list.

The search call is somewhat different since you need to have 4 parameters set, the query term, the latitude and longitude of the center of the lcoation, and the distance from the center to use (the 5th parameter, ‘type’ is just set to ‘place’ in the code below). I’ve provided some sample data (which is just the sample data used in the Facebook example), which can be loaded by pressing the ‘Load Test Data’ button. If you want to test a different address and need to find a valid lat/long setting, you can use http://geocoder.us/ to convert an address.

	public ActionResult SearchPlaces(FormCollection form)
	{
		Dictionary parameters = new Dictionary();
		parameters.Add("q", form["q"]);
		parameters.Add("center", String.Format("{0},{1}",form["lat"], form["long"]));
		parameters.Add("type", "place");
		parameters.Add("distance", form["distance"]);

		JSONObject searchResults = helper.Get("/search", parameters);
		if (searchResults != null)
		{
			var data = searchResults.Dictionary["data"];
			List places = data.Array.ToList();
			ViewData["Places"] = places;
		}

		ViewData["Name"] = Session[Constants.FacebookNameKey];
		ViewData["isConnected"] = helper.IsConnected;

		return View("Index");
	}

Nothing fancy about the returned data either, it’s pretty similar to the data for the checkin. One thing to note though is that the location item may not have an address associated with it, so you need to account for that when working with the data (the sample just checks for the existence of the ‘street’ key in the location array).

{
   "data": [
      {
         "name": "Philz Coffee",
         "category": "Local business",
         "location": {
            "street": "4023 18th St",
            "city": "San Francisco",
            "state": "CA",
            "zip": "94114-2501",
            "latitude": 37.760863,
            "longitude": -122.433326
         },
         "id": "151116474914629"
      },
      {
         "name": "Ritual Coffee Roasters",
         "category": "Local business",
         "location": {
            "latitude": 37.75659,
            "longitude": -122.4211
         },
         "id": "119185971453428"
      },
	  ...
	 ]
}

Retrieving a user’s wall

The previous iteration of the sample including an example on how to post to a user’s wall, so getting a user’s wall is a natural corollary. Getting a user’s feed is accomplished by making a call to ‘me/feed’

	public ActionResult GetWall()
	{
		JSONObject wallData = helper.Get("/me/feed");
		if (wallData != null)
		{
			var data = wallData.Dictionary["data"];
			List wallPosts = data.Array.ToList();
			ViewData["Wall"] = wallPosts;
		}

		ViewData["Name"] = Session[Constants.FacebookNameKey];
		ViewData["isConnected"] = helper.IsConnected;

		return View("Index");
	}

The returned data can differ depending on the type of the wall post, so when working with the data you just need to check for the presence of the appropriate dictionary keys before trying to use it. For example:

	<%
		foreach (Facebook.JSONObject wallItem in wallPosts)
		{
			string wallItemType = wallItem.Dictionary["type"].String;
			if (wallItemType == "photo" || wallItemType == "video")
			{
	%>
		<% if (wallItem.Dictionary.ContainsKey("name")) {  %><%= wallItem.Dictionary["name"].String%> <% } %> (<%= wallItemType %>) 			
 <%= wallItem.Dictionary["link"].String %>
	 <% }
		else if (wallItemType == "status") {  %>
			<%= wallItem.Dictionary["from"].Dictionary["name"].String%> 
 <%= wallItem.Dictionary["message"].String%>
	 <% } %>

Note that a picture or video may or may not have a name so you’ll need to check for that as well.

Offline Access

The offline_access extended permission is pretty cool, it basically extends the life of the access_token you receive after logging in via OAuth. The example I wrote just stores this in a cookie (named FacebookAccessToken) the first time you log in with your account. Normally you’d want to store this in a database or some other more permanent store.

	public ActionResult GetOfflineWall()
	{
		if (HttpContext.Request.Cookies[Constants.TokenCookieName] == null ||
			String.IsNullOrEmpty(HttpContext.Request.Cookies[Constants.TokenCookieName].Value))
		{
			return View("Index");
		}

		JSONObject wallData = helper.GetWhileOffline("/me/feed");
		if (wallData != null)
		{
			var data = wallData.Dictionary["data"];
			List wallPosts = data.Array.ToList();
			ViewData["OfflineWall"] = wallPosts;
		}

		return View("Index");
	}

The GetWhileOffline method beind used there just takes the access_token out of the FacebookAccessToken cookie and uses that when instantiating the FacebookAPI object…(in FacebookHelper.cs)

	public JSONObject GetWhileOffline(string apiCall)
	{
		JSONObject jsonObject = null;

		if (HttpContext.Current.Request.Cookies[Constants.TokenCookieName] != null ||
			!String.IsNullOrEmpty(HttpContext.Current.Request.Cookies[Constants.TokenCookieName].Value))
		{ 

			string token = HttpContext.Current.Request.Cookies[Constants.TokenCookieName].Value;
			token = HttpUtility.UrlDecode(token);

			Facebook.FacebookAPI api = new Facebook.FacebookAPI(token);
			jsonObject = api.Get(apiCall);
		}

		return jsonObject;
	}

Thats really all there is to it, as long as you have the extended permission ‘offline_access’ and an access_token that was created when a user logs in after granting this permission, you should be able to make offline calls.

Download the latest version here

Facebook, C# and ASP.NET MVC – Code samples for friends list, activities list and wall posts

onishimura — Wed, 11 Aug 2010 09:50:17 +0000

A few weeks back I wrote about the official C# SDK from Facebook and provided some sample code demonstrating how to use it to get some basic information about the logged in user. Admittedly the initial sample asp.net mvc code was fairly simple in order for it to be straight forward and easy to understand. I’ve decided to expand a bit on the sample in order to demonstrate how to use the Open graph API to perform a few more interesting calls, notably:

Post to a user’s wall
Retrieve a list of the user’s friends
Retrieve a list of the user’s activities

The original sample code demonstrated how to authenticate a user and make calls using both the official C# sdk and a home grown solution. I’ve kept that approach but have organized and refactored the samples a bit better to make it hopefully more clear. The new version of the sample code allows you to login/out to facebook only on the home page. Once logged in you can go to the ‘Official’ and ‘Custom’ tabs to view your friends, activities or to post a message to your wall. While the functionality is the same between the two tabs, the code behind them is different. I assume most people would use the official SDK but I provided an alternative just as a point of interest. OK, I was bored really, and just wanted to see how it could be done differently.

In any case, the first step before running the code is to make sure you clear any previous permissions granted to this app (or whatever app you will be using with the sample code). The login button on the home page now requests extended permissions so you’ll probably need to remove it from your list of allowed applications if you’re running the latest code with a facebook app that was using the original sample code. The actual list of permissions being request are perms=’read_stream,publish_stream,read_friendlists,user_activities’, and the full list of permissions available can be found here http://developers.facebook.com/docs/authentication/permissions.

Official C# SDK

The code to use the Facebook API can be found in the OfficialFacebookController. By default index view will simply show the name of the logged in user, which uses the same code present in the HomeController (and the original post<)

string token = HttpUtility.UrlDecode(fbConnect.AccessToken);
FacebookAPI api = new FacebookAPI(token);
JSONObject me = api.Get(“/” + fbConnect.UserID);
ViewData["Name"] = me.Dictionary["name"].String;

There are three other actions a logged in user can take here, view their friends list, view their activity list, and post a message to their wall.

Clicking the Get Friends button will call the GetFriends action in the controller. The call is simply api.Get("me/friends"), which returns a dictionary with a data key and an array of JSONObjects, representing all of the friends for the user. You could also call it with something like, api.Get("/" + fbConnect.UserID + "/friends"): "me" just uses the currently logged in user.
```
Facebook.FacebookAPI api = new Facebook.FacebookAPI(token);
JSONObject me = api.Get("/" + fbConnect.UserID);
JSONObject friendsData = api.Get("/me/friends");
var data = friendsData.Dictionary["data"];
List friendsList = data.Array.ToList();

ViewData["Name"] = me.Dictionary["name"].String;
ViewData["Friends"] = friendsList;
```
The data itself is just the name and facebook id of the user's friends, so the view just loops through the friendsList collection and displays in this format Name - Id
```
<%= friend.Dictionary["name"].String %> - <%= friend.Dictionary["id"].String %>
```
Similarly, clicking the Get Activities button will call the GetActivities controller. The code is pretty much the same as the above friends code, but calls api.Get("/me/activities");. The data is also slightly different, since the activity data contains more information (such as category, and create_date). So, the view follows pretty much the same format but displays more fields:
```
<%= activity.Dictionary["name"].String%> - <%= activity.Dictionary["id"].String%>- <%= activity.Dictionary["category"].String%>- <%= activity.Dictionary["created_time"].String%>
```
Finally, the message section allows the user to enter a message and post it to a user's wall. Entering text and clicking the Post Message button will call the PostMessage action. Instead of calling the Get method of the FacebookAPI class, we call Post:
```
Dictionary postArgs = new Dictionary();
postArgs["message"] = message;
JSONObject post = api.Post("/" + fbConnect.UserID + "/feed", postArgs);
```
The post call also returns a JSONObject which contains the id of the new post. Just for verification, we show this in the view.

Custom C# classes

The display of the custom code looks pretty much the same as the official sdk, so I won't post any images of the views. The primary classes involved are FacebookConnect.cs, FacebookObjects.cs and OpenGraph.cs. Note that compared to the original sample code I've removed the "DEMO" prefix and added a few more methods to OpenGraph, renamed the DEMOFacebookUser to FacebookObjects, and added objects to FacebookObjects.cs. These serve as the definition for our extra calls

You might also notice in FacebookObjects that the DataContract and DataMember attributes have been removed from FacebookUser. One of the more significant changes is the way in which the Call method in the OpenGraph class works. Initially it was using the DataContractJsonSerializer class, which required you to mark your class and it's properties with DataContract and DataMember attributes. However, this serializer seems to have some issues parsing certain JSON strings. So instead I've changed the code to use the JavascriptSerializer which seems to work just fine. In fact it's more flexible and seems to take less configuration than DataContractJsonSerializer, which is why it was probably undeprecated (dedeprecated?). In addition to the use of JavascriptSerializer, the Call method also takes an additional parameter to specify the type of http request made. This allows us to use the same code to make a POST request, which is necessary when writing to a user's wall. The new Call method looks like this:

private T Call(string url, string methodType) where T : class
{
	T result;
	HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
	request.Method = methodType;

	using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
	using (StreamReader reader = new StreamReader(response.GetResponseStream()))
	{
		JavaScriptSerializer jsSerializer = new JavaScriptSerializer();
		string jsonData = reader.ReadToEnd();
		result = (T)jsSerializer.Deserialize(jsonData);
	}

	return result;
}

The various Get/Post methods in the OpenGraph class are pretty similar to the original GetCurrentUser method and rely on the objects defined in the FacebookObjects.cs file. For example, the GetCurrentUserFriends looks like the following:

public List GetCurrentUserFriends(string accessToken)
{
	string parameters = "me/friends?access_token=" + accessToken;
	string url = baseUrl + parameters;

	FacebookFriendData call = Call(url, GET);

	return call.Data;
}

The action just needs to call this method with a valid access_token. For example, the GetFriends action in CustomFacebookController, calls the following:

List friends =  openGraph.GetCurrentUserFriends(fbConnect.AccessToken);

Once this has been placed into the ViewData dictionary, we can just pull it out and iterate through it like so:

<%
	List friendsList = ViewData["Friends"] as List;
	foreach(FacebookSampleMVC2App.FacebookFriend friend in friendsList) {
%>
	<%= friend.Name %> - <%= friend.Id %>

<%  } %>

The logic/view for retrieving the user's activities and posting to the user's wall are fairly similar.

Wrap up

So there you have it, some sample code to do a bit more than just display the user's name and facebook id. The custom classes and the official sdk are pretty similar in the sense that they both just call REST methods like 'me/friends', 'me/activities' and 'me/feed' from https://graph.facebook.com/. The official SDK is more flexible however, since it doesn't need to have classes defined for each of the types, instead relying on JSONObject to wrap the dictionaries/arrays/scalars returned from the api calls.

Download the code here

Update - 11/15/2010

I recently updated the sample project with more samples, which can be viewed here: http://onishimura.com/2010/11/15/facebook-c-and-asp-net-mvc-updated-code-samples-for-places-wall-offline-access/

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

Facebook C# – Sample ASP.NET application and access tokens

onishimura — Mon, 19 Jul 2010 08:05:58 +0000

Put together another quick sample app, this time for ASP.NET 4.0, instead of MVC.
I’ve also added an example of how to post to a user’s wall, using the Facebook C# SDK

As I mentioned earlier, the facebookconnect class included is just a helper class I used to pull values out of the fbs_[appid] cookie. You can get the access_token out of the cookie directly if you want using something like the following:

string accessToken = HttpContext.Current.Request.Cookies["fbs_" + ConfigurationManager.AppSettings["AppID"]]["\"access_token"];

Assuming you have AppID as an appsetting in your web.config. Also, as usual you should change the app id in the sample project to match whatever your current app is using.

Download the code here

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