# Friday, August 28, 2009

Apparently iPhones explode. There is a report today of a 15 year old in Belgium who’s iPhone exploded. In addition there was a report about two weeks ago of an iPhone in France and there have been other reports in the UK and across the US. Luckily only minor injuries have been reported.

The European Commission is starting to investigate. Apparently Apple has not issued a warning and it could be a fluke.

posted on Friday, August 28, 2009 10:39:59 AM (Eastern Daylight Time, UTC-04:00)  #    Comments [0] Trackback
# Wednesday, August 26, 2009

The following video shows how to use the Telerik OpenAccess WCF Wizard with ADO.NET Data Services. The video is done by .NET Ninja in training Peter Bahaa and uses more or less the same code I showed yesterday on my blog. Enjoy!

 

Telerik OpenAccess WCF Wizard Part II- Astoria from Stephen Forte on Vimeo.

posted on Wednesday, August 26, 2009 9:20:33 AM (Eastern Daylight Time, UTC-04:00)  #    Comments [0] Trackback
# Tuesday, August 25, 2009

I have been a big fan of using the RESTful ADO.NET Data Services (aka Astoria). If you want to use Astoria out of the box without any modifications you really have to use the Entity Framework. But as long as you are using a data access library that supports IEnumerable and IQueryable (and IUpdateable to be useful for CRUD) you can use Astoria with just a little bit of extra work. 

Telerik OpenAccess supports LINQ and IUpdateable and can be used in Astoria as shown here. In a nutshell you have to first create your data access layer, then a web site to host your ADO .NET Data Service and then a client (in our case a Silverlight app.) You would have a solution that will look like this:

image

The problem is that if you use anything other than the Entity Framework, you need to do a little extra plumbing. In our case using OpenAccess, you have to create the IQueryable interfaces for all of your entities manually. You would need something like this:

   1:  public IQueryable<Customer> Customers
   2:  {
   3:      get
   4:      {
   5:          return this.scope.Extent<Customer>();
   6:      }
   7:  }

 

The scope variable you see on line # 5 is an instance of IObjectScope. IObjectScope is how OpenAcces implements the actual data context. According to the OpenAccess team, you have to add a few extra lines of code with these IQueryable interfaces into an “OADataContext” class. To be honest, I don’t want to do that, too much plumbing code.

Enter the OpenAccess WCF Wizard I wrote about before.

You can use the Wizard to generate the OADataContext file as well as the Astoria service file. Just point the wizard to the DAL layer file and select Astoria from the menu and generate the files and add them to the project (it is ok to overwrite the original CS file supporting the SVC file, just make sure you have the correct namespaces).

image

Now your Astoria service will look like this:

   1:      [System.ServiceModel.ServiceBehavior(IncludeExceptionDetailInFaults = true)]
   2:      public class WebDataService : DataService<AstoriaDataContext>
   3:      {
   4:          protected override void HandleException(HandleExceptionArgs args)
   5:          {
   6:              base.HandleException(args);
   7:          }
   8:   
   9:          // This method is called only once to initialize service-wide policies.
  10:          public static void InitializeService(IDataServiceConfiguration config)
  11:          {
  12:              //let all the entities be full access (CRUD)
  13:              config.SetEntitySetAccessRule("*", EntitySetRights.All);
  14:          }
  15:      }
  16:  }

This is pretty standard Astoria stuff, line #13 does all of the Astoria magic.

Now let’s look at our Silverlight client.  First let’s create some XAML, I will just show you the DataGrid code here:

   1:  <data:DataGrid Grid.ColumnSpan="2" x:Name="dataGridCustomers" AutoGenerateColumns="False" ItemsSource="{Binding}">
   2:      <data:DataGrid.Columns>
   3:         <data:DataGridTextColumn Binding="{Binding Path=CompanyName}" Header="Company Name"></data:DataGridTextColumn>
   4:         <data:DataGridTextColumn Binding="{Binding Path=ContactName}" Header="Contact Name"></data:DataGridTextColumn>
   5:      </data:DataGrid.Columns>
   6:  </data:DataGrid>

 

As I wrote the other day, you still have to use a service and call the service asynchronously. In our Silverlight application we will then set a service reference to our Astoria Service, allowing us to write LINQ statements against the RESTful Astoria service.

image

Just like before we will have a LoadData() private method that our page load and “refresh” buttons will call. This will use LINQ to talk to the Astoria service and fetch all of the Customers. First we set up a LINQ data context (lines 4-5) and then a LINQ query (lines 8-9). Then we will use a code block (lines 13-14) to catch the async code (instead of a separate event handler) and perform the actual binding to the grid.

   1:  private void LoadData()
   2:  {
   3:      //this uses the LINQ to REST proxy (WebDataService)
   4:      AstoriaDataContext dat = new AstoriaDataContext(
   5:          new Uri("WebDataService.svc", UriKind.Relative));
   6:      
   7:      //link statement to get the data, can use WHERE, Orderby, etc
   8:      var customers = 
   9:          (from c in dat.Customers select c) as DataServiceQuery<WebDataService.Customer>;
  10:   
  11:      //use code block to perform the binding at the end of the async call
  12:      //casting the Customers to a LIST
  13:      customers.BeginExecute(
  14:          (ar) => dataGridCustomers.DataContext = customers.EndExecute(ar).ToList(), null);
  15:  }

When we run our code, we will get data right away:

image

We can also perform an update. We have a global collection called editedCustomers and we trap the BeginEdit method of the Silverlight grid and put an instance of each row (a Customer) that was edited into this collection. Then we provide an update button that will call UpdateData() shown below. UpdateData() will loop through each dirty customer in the editedCustomers collection (lines 8-11) and update them using the Astoria LINQ services (lines 10-11). Inside of our loop we are doing another code block (lines 12-25) to catch the async update. We use a counter to figure out when we are done (lines 16-22), since in an async model, your 3rd update out of 5 can be the last one to finish!

 

   1:  private void UpdateData()
   2:  {
   3:      //this uses the LINQ to REST proxy (WebDataService)
   4:      AstoriaDataContext dat = new AstoriaDataContext(
   5:          new Uri("WebDataService.svc", UriKind.Relative));
   6:   
   7:      //editedCustomers is a local collection containing only the dirty records
   8:      foreach (WebDataService.Customer customer in editedCustomers)
   9:      {
  10:          dat.AttachTo("Customers", customer);
  11:          dat.UpdateObject(customer);
  12:          //code block to handle the async call to updates
  13:          dat.BeginSaveChanges(
  14:              (ar) =>
  15:              {
  16:                  updatedCounter++;
  17:                  //once we are finished with all items in the collection, we are done
  18:                  if (updatedCounter == this.editedCustomers.Count)
  19:                  {
  20:                      MessageBox.Show("Customers have been changed successfull!", "Saving Changes", MessageBoxButton.OK);
  21:                      this.editedCustomers.Clear();
  22:                  }
  23:   
  24:                  dat.EndSaveChanges(ar);
  25:              }
  26:              , null);
  27:      }
  28:  }

 

That is it to build an Astoria based Silverlight application using OpenAccess. The OpenAccess WCF Wizard takes care of building the OpenAccess specific plumbing DataContext class for you as well as the Astoria service. Soon I will post another video by .NET Ninja in training Peter Bahaa on this demo as well as some more code examples using the WCF REST Toolkit and the OpenAccess WCF Wizard.

The code is available here. Enjoy!

posted on Tuesday, August 25, 2009 11:31:37 AM (Eastern Daylight Time, UTC-04:00)  #    Comments [0] Trackback
# Sunday, August 23, 2009

Last week I showed how to use the Telerik OpenAccess WCF Wizard on this blog. The wizard creates some of the boring WCF code for you automatically. You can create endpoints for WCF, Astoria, REST collection and ATOM Pub services. Our first demo used WCF, later we will show you the other services. This is what we did:

  • Created a data access layer automatically using OpenAccess
  • Created a WCF Service automatically using the wizard
  • Created a Silverlight 3.0 application that used WCF to databind the Customers table to a datagrid, enabling editing automatically

Here is a video by Peter Bahaa (aka Pedro), .NET ninja in training, using the wizard with the above scenario. You can get the code here. Enjoy!

Telerik OpenAccess WCF Wizard Part I from Stephen Forte on Vimeo.

posted on Sunday, August 23, 2009 7:34:48 PM (Eastern Daylight Time, UTC-04:00)  #    Comments [0] Trackback
# Wednesday, August 19, 2009

Microsoft’s Silverlight 3.0 is a great new platform for building line of business applications. With every new technology advancement, we always seem to lose something. With Silverlight we lose the dirt simple data access since Silverlight does not support System.Data.SQLClient and talking to a database directly. This forces us into a service oriented architecture and an asynchronous model. While this is definitely a best practice, it sometimes takes a little getting used to.

With Silverlight we have to wrap up our data access layer into WCF services. (Or Astoria, RIA Services, or something similar.) It is also pretty standard to use some kind of ORM like the Entity Framework or Telerik OpenAccess to map to your database tables and then expose those entities as part of your WCF service. Mapping tables to entities may save you time, however, the part that bothers me is that there is a lot of generic “plumbing” code that has to get written for the WCF service to function.

That is why Telerik created the OpenAccess WCF Wizard. The Telerik OpenAccess WCF Wizard is a tool that will automatically create the C# “plumbing” code and necessary project files for using OpenAccess entities with the following services:

  • Astoria (ADO .NET Data Services)
  • WCF
  • REST Collection Services (WCF REST Starter Kit)
  • ATOM Publishing Services (WCF REST Starter Kit)

Using the wizard is pretty easy. If you already have a project with OpenAccess mapped entities in it, all you have to do is point the wizard to that location and have it generate the scv and .cs files of the WCF service (or Astoria, REST Collection or ATOM Pub service) as shown below. This will eliminate the need for you to write all of the WCF plumbing code.

image

 

We’ll map the Northwind tables and run the wizard and then create a WCF service project. Once you create the service, replace the .cs file with the one generated by the wizard and then create a new Silverlight project (or any project that wants to communicate with your OpenAccess enabled WCF service.) Then set a Service Reference to the WCF service and you can start to consume the it. Your projects in the solution will look like this:

image

Where:

  • OA.WCFWizard.Demo.DAL is the project containing your OpenAccess entities (mapped to Northwind tables).
  • OA.WCFWizard.Demo.SL is the project containing your Silverlight project, including the service reference to your WCF service. (First arrow.)
  • OA.WCFWizard.Demo.WCFService is the project containing the WCF service created by the WCF wizard (second arrow.)
  • OA.WCFWizard.Demo.Web is the asp.net site hosting your Silverlight application

Writing some Silverlight code to consume the WCF service

Consuming the service is pretty easy once you have the service reference set up. We’ll start with some basic XAML, but I will spare you the major XAML details since I am not a XAML expert. Here is my datagrid in XAML, notice that I am using data binding and predefined columns to make life a little easier:

<data:DataGrid x:Name="dataGridCustomers" Grid.ColumnSpan="2" AutoGenerateColumns="False" ItemsSource="{Binding}">
     <data:DataGrid.Columns>
         <data:DataGridTextColumn Binding="{Binding Path=CompanyName}" Header="Company Name"></data:DataGridTextColumn>
         <data:DataGridTextColumn Binding="{Binding Path=ContactName}" Header="Contact Name"></data:DataGridTextColumn>
     </data:DataGrid.Columns>
</data:DataGrid>

When filled, it looks like this:

image

Pretty basic stuff, if you want more advanced looking grids and controls, talk to a designer. :)

Ok, so how can we easily consume this service and bring this data from Northwind via OpenAccess and WCF to the Silverlight grid? Once you have a service reference set up (NorthwindWCFService) in your Silverlight project, you have to do a few things to call it. I created a LoadData() method to contain the code to fill the grid. We can call this on the page load event as well as on the UI with a “refresh” button, or after any “save” method.

Inside of the LoadData() method, first you have to create an instance of the proxy or the “client” as shown in line 4 of the first code block below. Once you have this set up, you then have to register an event for the method you are going to call, as shown on line 6 below. This means that when you call your ReadCustomers method asynchronously the client_ReadCustomersCompleted event handler will fire when the ReadCustomers method is done. This is where you put your binding code (more on that in a second.)  Lastly we have to call our ReadCustomers method, we can only call the asynchronous version of this method as shown in line 9.

   1:  private void LoadData()
   2:  {
   3:      //ref to our service proxy
   4:      NorthwindWCFService.SampleWCFServiceClient wcf = new NorthwindWCFService.SampleWCFServiceClient();
   5:      //register the event handler-can move this up if you want
   6:      wcf.ReadCustomersCompleted += new EventHandler<NorthwindWCFService.ReadCustomersCompletedEventArgs>(client_ReadCustomersCompleted);
   7:      //make an async call to ReadCustomer method of our WCF serice
   8:      //get only the first 100 records (default)
   9:      wcf.ReadCustomersAsync(0, 100);
  10:  }

 

The code for the event handler is pretty straightforward, we just set the datagrid’s DataContext to the e.Result of the event handler. This will contain an ObservableCollection<Customers> that was defined automatically for you via the proxy when you created your service reference.

   1:  void client_ReadCustomersCompleted(object sender, OA.WCFWizard.Demo.SL.NorthwindWCFService.ReadCustomersCompletedEventArgs e)
   2:  {
   3:      dataGridCustomers.DataContext = e.Result; 
   4:  }

 

That is it! I will soon post a video here showing how to do this in more detail as well as an update method since our grid is editable (it is super easy.) Next week I will show some examples using ADO .NET Data Services (Astoria) where the wizard will also automatically create the IObjectScope OpenAccess and Astoria plumbing code for you.

posted on Wednesday, August 19, 2009 6:04:20 PM (Eastern Daylight Time, UTC-04:00)  #    Comments [0] Trackback
# Thursday, August 06, 2009

The reason why Apple products are so slick and cool is two fold, the first is that they are a great consumer product/design company hands down. But the second is an equally important reason, a reason that will potentially prevent them from massive long term market share (like Windows, Oracle, etc.) The second reason why Apple products look and work so nicely is that they have a tight control over the software installed on their devices. For example if you are a software developer and want to build an application for the iPhone or the Mac, you need to follow the strict Apple design guidelines and then get approval from Apple before you can sell (or give away) your software.

This is great, it gives the vendor (Apple) near complete control over what gets installed by the user base and the vendor (Apple) can control the user experience. This of course has some great benefits: less virus attacks, less crashes (windows is usually unstable due to people like me: software developers) and less hacks. You can also guarantee that there is no porn or politically sensitive content on your device.

This also has a negative side effect. Pissed off developers. Tech blog TechCrunch reports that many software developers are getting angry with Apple due to the rejection of their apps, random removal of their apps, or rejection of an upgrade of their original app from the Apple AppStore. This will only anger more and more devs and over time, will limit the developer community on that platform. As we all know, with the apps, there will be no platform.

I am not saying that this is happening (developers leaving in droves) now, but it can happen. A recent decision to pull an app may have started the revolution. Apple last week pulled the Google Voice application from its AppStoe. Google Voice is pretty cool and allows you to use VOIP to make and receive calls (among over cool stuff.) So free phone calls means less minutes AT&T (and other international carriers) can sell.

This caused a bit of an uproar in the tech world. Some major influencers including prominent Apple supporters decided to quit using the iPhone over the decision to remove Google Voice. Google’s CEO Eric Schmidt has decided to step down from Apple’s board due to the conflict of interest. Lastly, the US government has gotten interested, last week, the FCC launched an investigation about the removal of Google Voice.

Apple (and AT&T) should allow any application to be installed on the iPhone as well as any other phone for that matter. On the regular wired internet, I can buy a PC and then download and install anything I want, my ISP does not control what computer I can buy and what I can see and what I can’t see. Why is it different for phones? I can’t install everything I want, nor can I even buy whatever phone that I want, I have to buy the phone from the carrier in a “locked” mode.

There is a reason: the United States is large country by land mass. The government has let the carriers have some control due to them promising to wire the whole country-this is why you can get signal in remote places where there is not a lot of demand. But now years later we are paying the price. It is time to open up the airwaves and allow us to buy any phone and install any application. The Apple AppStore is a walled garden that eventually will fail. While Apple risks losing a few design points and some system crashes and AT&T will lose some revenue, over the long run, if they allow anyone to develop software and anyone to install it, we all will be better off.

posted on Thursday, August 06, 2009 5:14:53 AM (Eastern Daylight Time, UTC-04:00)  #    Comments [0] Trackback