The main reason for running one Scheduled Task after another was due to the change in user running the task, so they could not be chained as the same task.

The following example is much more simplified, but the underlying solution is the same.

I have created a very simple Ping Task which displays a message, and wanted to chain a Pong task to run directly after this has completed. Creating the tasks are quite simple, but now I want to set a trigger on Pong for when the Ping task completes. This proved a little more difficult, though “On Event” appeared to be the right way to go, as the Task Scheduler outputs events at all points in the operation of a Task.

The most interesting one to me was the “Task Completed” event you can see above. Looking at XML view within the details of this event it appeared that I knew all the EventData I needed to know to run the Pong task on:

The trouble was with the Basic On an event trigger, you could only specify the Event ID which is 102 for all Task completed events on all Tasks, and not just my Ping Task:

However it is possible to define a Custom Event, though the standard filter does not allow much control over the selection of the events:

Using this as a starting point, and selecting the most that I could in this dialogue also started to populate the custom XML XPath, which would allow far more control.

Now to start writing the XPath and refering to the XML from the TaskCompleted Event:

<Event xmlns="https://schemas.microsoft.com/win/2004/08/events/event">

   <System>

      <Provider Name="Microsoft-Windows-TaskScheduler" Guid="{DE7B24EA-73C8-4A09-985D-5BDADCFA9017}" />

      <EventID>102</EventID>

      <Version>0</Version>

      <Level>4</Level>

      <Task>102</Task>

      <Opcode>2</Opcode>

      <Keywords>0x8000000000000001</Keywords>

      <TimeCreated SystemTime="2011-10-25T16:20:39.200166100Z" />

      <EventRecordID>109987</EventRecordID>

      <Correlation ActivityID="{13A3621A-839B-4FCD-83F3-B6677F1EC9F2}" />

      <Execution ProcessID="9372" ThreadID="8744" />

      <Channel>Microsoft-Windows-TaskScheduler/Operational</Channel>

   </System>

   <EventData Name="TaskSuccessEvent">

      <Data Name="TaskName">\Ping</Data>

      <Data Name="InstanceId">{13A3621A-839B-4FCD-83F3-B6677F1EC9F2}</Data>

   </EventData>

</Event>

I could use an XPath to get the Data element with TaskName of \Ping:

<QueryList>

   <Query Id="0" Path="Microsoft-Windows-TaskScheduler/Operational">

      <Select Path="Microsoft-Windows-TaskScheduler/Operational">*[EventData

[@Name='TaskSuccessEvent'][Data[@Name='TaskName']='\Ping']]</Select>

   </Query>

</QueryList>

By adding this trigger, and firing the Ping Event, the Pong Task Fires immediately after the Ping is complete.

Breaking the XPath down further:

It is now a simple case of reusing this XPath replacing the Task Name, \Ping here, with the task to run after.

   1: namespace RegexFinder

   2: {

   3:     using System;

   4:     using System.Linq;

   5:     using System.Text.RegularExpressions;

   6:     using System.Diagnostics;

   7:  

   8:     class Program

   9:     {

  10:         static void Main(string[] args)

  11:         {

  12:             if (args.Count() < 1)

  13:             {

  14:                 Console.WriteLine("You should consider giving me a regex to work on, or a pattern and a replacement to replace stuff with the -r switch");

  15:                 return;

  16:             }

  17:  

  18:             string pattern = args[0];

  19:  

  20:             string replace = null;

  21:  

  22:             if (args.Count() > 1 && args[1].StartsWith("-r"))

  23:             {

  24:                 if (args.Count() == 2)

  25:                 {

  26:                     replace = String.Empty;

  27:                 }

  28:                 else

  29:                 {

  30:                     replace = args[2];

  31:                 }

  32:             }

  33:  

  34:             string line = null;

  35:  

  36:             try

  37:             {

  38:                 while ((line = Console.ReadLine()) != null)

  39:                 {

  40:                     if (replace == null)

  41:                     {

  42:                         // do a find

  43:                         if (Regex.IsMatch(line, pattern))

  44:                         {

  45:                             Console.WriteLine(

  46:                                 line

  47:                                 );

  48:                         }

  49:                     }

  50:                     else

  51:                     {

  52:                         // do a replace

  53:                         Console.WriteLine(

  54:                             Regex.Replace(line, pattern, replace)

  55:                             );

  56:                     }

  57:                 }

  58:             }

  59:             catch (ArgumentException ex)

  60:             {

  61:                 Console.WriteLine("You should meditate on the regex, because {0}", ex.Message);

  62:             }

  63:             catch (Exception ex)

  64:             {

  65:                 Console.WriteLine("You should meditate on this error: {0}", ex.Message);

  66:             }

  67:         }

  68:     }

  69: }

This was expected to be a tool only I would use, so didn’t worry too much about the quality of the error handling, however I was quite pleased with the result, especially the parts about reading the pipe coming in.  Now by using Type [inputfilename] | RegexFinder [regex] –r [replacement] > [outputfilename] i can do my replacement with the zero width assertions.

e.g.

type file.txt | grep "(?<=h)e(?=llo)" -r a

will replace all “hello”’s with “hallo”’s.

Then taking that forward to patterns with predefined groups (?<groupname>[regex]) and then the lookup (\k<groupname>) makes it very powerful and very flexible.

“a health application platform, a set of platform services and a catalyst for creating an application ecosystem that enables consumers to collect, store and share health information online.” - https://msdn.microsoft.com/en-gb/healthvault/default

From a developer’s point of view, it’s a great starting point for creating a health based application without being a medical expert yourself.  (Personally I couldn’t tell my Diastolic measurements from my Peak Expiratory Flow).

In the past I worked on HealthVault when it was only available in the US (https://healthvault.com), though now it is in the UK I hope to ease a few pains I found myself massaging within this post.

A good starting point is to install the SDK and create a new application in the tool when the installation completes.  This is also found in c:\Program Files (x86)\Microsoft HealthVault\SDK\Tools\ApplicationManager.exe

Clicking on the Create New Application button will prompt you to create a new project, and then add the certificate it generates to the Local Machine\Personal certificate store.  You can view this certificate by running the ComputerCertificates.msc management plugin (or the Local Machine Certificate snapin to mmc).

The next step is to deploy your certificate created here to HealthVault so that we can start using it.  If you wish to use the UK version close the application and modify ApplicationManager.exe.config within the same directory as the application from:

<appSettings>  

      <add key="DropOffUrl" value="https://config.healthvault-ppe.com/RegisterNewApplicationDropoff.aspx" /> 

  <add key="TurnOnUpload" value="true" />

</appSettings>

pointing to the american DropOffUrl over to:

<appSettings>  

       <add key="DropOffUrl" value="https://config.healthvault-ppe.co.uk/RegisterNewApplicationDropoff.aspx" /> 

   <add key="TurnOnUpload" value="true" />

</appSettings>

which will mean that when you right click to deploy your cert onto HealthVault, it will go to the uk portal (.co.uk) instead of the US portal (.com) though the link at the bottom of the application to the Configuration Center (https://config.healthvault-ppe.co.uk/) will still point to the American site (https://config.healthvault-ppe.com) which will not allow you to run if you are not in the US. 

Thanks to Madan kamuju for this tip in his post.

Another point to remember here is that this is a development system and not the live system (as indicated by the –ppe on the URLs).

So now we can upload our certificate to HealthVault to start us developing against HealthVault.

Running your application now created should show you the standard messages, and allow you to login to HeatlhVault using your Live Id.  Though I found that some of the samples (the OfflineAccess example as one in c:\Program Files (x86)\Microsoft HealthVault\SDK\DotNet\WebSamples) still had an issue when I changed the ApplicationId inside the Web.Config file to by my application ID for debugging purposes (Note here I also changed the ShellUrl and HealthServiceUrl to be the .co.uk versions from the .com).

I found that within the HealthVault configuration for my application:

there were “Online” and “Offline” rules for the application:

By some searching I found that I did not have access rights to write the data I wanted to modify using my application.

Using the portal it is possible to change the access rights the application has, here for debugging purposes I have enabled everything:

When I login to the application (OfflineAccess) using my live account, I am prompted to enable the application to use my HealthVault details.  Allowing access to this then makes it possible to read and write to HealthVault for my user.

One headscratcher I did have was that I enabled all these settings (as above) but it did not seem to take effect immediately, leading me to believe that it had not affected anything.  After searching the MSDN forums I found that this can take up to 30 minutes to take effect, though this is not guaranteed as the following time a change I made applied almost immediately.

I hope you all have fun writing your health application.

I have been very fortunate to be a member in the team to develop and deliver this site alongside Christopher Owczarek, Martin Grayson, Jag Dua, Sam Gates, Steve Loader, Tom Eddings and Simon Middlemiss. For this blog post I would like to point out some of the key features of the site and a little about the technologies used.

When you get to the site you see one of the first cool features of IE9 and HTML 5, which is the embedded video. This comes out of the box with IE9, and does not require any other addins such as Silverlight or Flash to play. The second cool thing is the HTML 5 canvas, it isn’t obvious here what we are using the canvas for, but one thing it allows is transforms of visuals. What we are doing here is projecting our html video onto a canvas which will render the images, but also add a rotate transform to it. While this is quite a subtle change, the application of filters and other transforms allows very powerful modifications which would only be possible in Silverlight or Flash based sites which, again would require an addin.

As we move on to create our Cool Wall, we are presented with a list of cars we can choose to place onto the wall, we have added some transforms and animations to show the names and a slightly bigger image of the cars. We have also added some rotation on these cards of the cars to make it look more like the actual Cool Wall from the show. The hardware graphics acceleration of IE9 also allows a much smoother animation of the car positions when clicking between “My Wall” the “Community” wall and the “TG Rating” or Top Gear wall. The other cool feature of IE9 and HTML 5 is Local Storage; when a user has created a Cool Wall, and they go away from the site, they would expect the Cool Wall to be how they left it when they return. By utilizing the local storage aspect of IE9 we are able to easily convert the positions of the cars into a JSON format for storage and then read it back from Local Storage when we come back to the site.

By clicking on a car a flyout with more car details appears detailing some car stats, such as price range, acceleration, maximum speed, miles per miles per gallon, the rating of the car from the show and a quote from the show about the car. We have also added the JavaScript DeepZoom control which allows you to examine the high resolution image of each car in great detail, there are also some hotspots at the bottom right of the DeepZoom picture which shows some interesting parts of the cars. Another note here is the speed in which IE9 is able to render the Deep Zoom images, and this is especially noticeable when the control is in “Full Page” mode by clicking the fourth button on the bottom right inside the image.

Another feature of the flyout is a video from the show, like the Cool Wall video at the start of the page, this uses the inbuilt video player with the IE9 tags, so again no addin’s are required to view these videos, another plus point is all the controls on these videos come out of the box with IE9, so you don’t have to spend time designing and developing a custom video player for your site.

One of the main things about the cool wall is the differences of opinions, which is why it is possible to share your Cool Wall via Facebook. By clicking on the Connect button with the Facebook logo.

When you are signed into Facebook, you will be able to share your wall with your friends, and see any friends who already have walls.

Being signed in means that you will also be adding your opinion to the community wall, which takes an average of the user’s ratings of cars. The final tab along the top is the TG Rating, or Top Gear Wall. This relates directly to the rating given from the show and the TG Rating shown on the car’s flyout.

Try it out!

You can get the beta of IE9 from https://www.beautyoftheweb.com to try out today, and you can create your own Cool Wall at https://www.topgear.com/coolwall

download available here

Outlining the security considerations developers should consider when building a service on Windows Azure.

As I have worked on Azure before and have an interest in security I found this a very interesting read, with links to some excellent msdn articles.

Identity Management

The document starts by outlining the best practices within Identity Management and Access Control and how that applies in general and to the cloud.  One reference in particular is the use of Windows Identity Foundation or “WIF” along with ADFS and using AppFabric.  I have worked with WIF in the past outside of the cloud, and while being quite complicated to understand, when you understand the basics (or play around in Visual Studio with a Secure Token Service for a while) it becomes very powerful quite quickly.

WIF SDK

Guide to Claims Based Identity

Service Layer

Then the paper starts to look into specific development considerations for the service-layer.

One consideration similar to most cross site scripting issues within web technologies is to use the Anti-Cross-Site-Scripting Library and using the ASP.NET Page.ViewStateUserKey to mitigate against Cross-Site Request Forgery attacks.  This article is excellent at explaining how the attack works and what is needed to mitigate against it:

void Page_Init (object sender, EventArgs e) {

   ViewStateUserKey = Session.SessionID;

   :

}

Now specific to Azure, is where the (hosting) Namespace and scopes.  As all azure services are hosted on *ServiceName*.cloudapp.net, it is worth pointing out that the best practice is to use a custom domain name which you have full control over, and using a CNAME to do the redirection:

blog article

This way no other applications running under the cloudapp.net domain can script to your service using your custom domain without XSS.

Secure Data

As Azure storage uses a Shared Access Signature to allow your service to read and write to blobs/queue/tables, there is a guideline to minimizing risk of using a Shared Access Signature:

· Generate Shared Access Signatures with the most restrictive set of ACLs possible that still grant the access required by the trusted party.

· Use the shortest lifetime possible.

· Use HTTPS in the request URL so the token cannot be snooped on the wire.

· Remember that these tokens are only used for temporary access to non-public blob storage – as with passwords, it’s a bad idea to use the same ones over and over.

It is also suggested for data protection to encrypt data with certificates as DPAPI is not available, and deploy them using the Azure Certificate Store and not in Azure Storage such as blobs:

My Previous Blog on this subject

Cloudy In Seattle’s Post

Infrastructure Layer

As Windows Azure deals with a lot of the infrastructure, items here are mostly within the configuration and definition of the service you write.  The ports open for example are explicitly defined within your Azure project,

example here of the Web Role:

Due to the nature of the Load Balancer within the Azure environment, Denial of Service attacks are partially mitigated, and the Azure team are also reviewing additional Distributed Denial of Service (DDoS) attacks.

The paper goes into quite deep technical detail around Spoofing, Eves dropping and Information Disclosure on a network level, and explains the Hypervisor’s role and network structure of the hosted solution.

Trust

Azure has both a custom, restricted-privilege trust model called “Windows Azure Partial Trust” and Full trust with Native Code Execution.  Though unless you need specific scenarios such as:

· Use of FastCGI or PHP.

· Migration of traditional web services to the cloud.

· Role invocation and spawning Windows sub-processes (native code or managed).

· Calls into native libraries via P/Invoke (Platform Invocation Services).

If these scenarios are not needed then you should have Windows Azure Partial Trust enabled:

To run your role under partial trust, you must add the enableNativeCodeExecution attribute on the WebRole or WorkerRole element and set it to false.

[Windows Azure Partial Trust]

The “Gatekeeper” Design Pattern

A recommended design pattern is to use the concept of a gatekeeper running under partial trust as a webrole to accept requests and messages and a KeyMater workerrole which acts as a data provider. 

The Gatekeeper can talk to the KeyMaster via an internal endpoint over HTTPS if the requests are immediate or via the Azure Storage Queue.  This also allows a separation for sanitizing the requests going to the KeyMaster and therefore the final Storage at the Gatekeeper level where the potential service of attack is small.  These 2 roles will be deployed on separate VM’s so if the GateKeeper is compromised, no storage information will be.

Sanitizing and processing the requests are still subject to secure design and coding consideration, though this will provide additional levels of security to protect the data at the heart of the application.

· Secure design, including the following topics:

· Attack surface reduction

· Defense in depth

· Principle of least privilege

· Threat modeling

· Secure coding, including the following topics:

· Cross-site scripting

· SQL injection

· Managed code security (transparency, code access security, assembly strong naming, etc.)

After some thought, I considered that by utilising anonymous delegates (Action and Func) he would be able to add testing to the existing code very easily, and utilize the Debug/Release modes within Visual Studio.

I proposed, unfortunately with out use of whiteboards or anything which would have been useful, to have within a test harness a helper method which took one of these anonymous delegates, and caught all exceptions and wrote them to Trace to allow him to view them after a test. 

public static void ExceptionHelper(Action action)

{

    try

    {

        action();

    }

    catch (Exception ex)

    {

        Trace.WriteLine(ex);

    }

}

Within the main body of the test harness to add an

#if DEBUG

to allow him to easily swap between running with exceptions handled himself or to allow them to pass through to the execution engine.

public static void TestHarness()

{

    Trace.Listeners.Add(new ConsoleTraceListener());

#if DEBUG

    ExceptionHelper(FunctionToTest);            

#else

    FunctionToTest();

#endif

}

Now when Visual Studio runs the test harness in Debug mode, the exceptions will be caught, as the delegate points to the FunctionToTest method which is executed by the action(); line in ExceptionHelper.  If the user is in Release mode (i.e. not in Debug) then the Function will be executed as normal.

For a good overview and the developer portal for Dallas can be found at:

https://www.microsoft.com/windowsazure/dallas/

In this post I am going to summarise some of the methods of consuming data from Dallas, as mentioned in the Dallas Learning Course on Channel 9:

https://channel9.msdn.com/learn/courses/Azure/Dallas/

and Zach Owen’s part of the Dallas presentation from PDC 09:

https://microsoftpdc.com/Sessions/SVC29

For details on navigating the Dallas Catalog and Datasets the first lab on Channel 9 is very helpful to get to know what is available:

https://channel9.msdn.com/learn/courses/Azure/Dallas/IntroToDallas/Exercise-1-Exploring-the-Dallas-Developer-Portal-and-Service-Explorer/

So you have found your data source and want to consume some data…

Using the Generated Proxy from C#

The first way to consume data is using the Generated Proxy Class and use managed code such as C# to access the data.

On the Dallas portal when you have subscribed to a Dataset you should see a list of credentials (Account Key and Unique User ID) and below that a link to Download C# service classes.  Download and add this class to your project where you are going to consume the data, and in your consumer class add the using statement:

using Microsoft.Dallas.Services;

Build the solution, and you should be ready to start accessing the services.

In this example I will be using the UN dataset “Free subscription for Food and Agricultural Data”.

Using the code below, populating the accountKey and uniqueUserId with the values from your subscription in the Dallas Portal, this will create a service using the generated FAO3510Service class and read all values into a strongly typed List to iterate over.

// Specify the account key and unique user ID to use for the query

string accountKey = "";

string uniqueUserId = "";

// Create a service proxy with which to execute the query. Note that the

// service proxy requires the

// account key and unique user ID

FAO3510Service service = new FAO3510Service(accountKey, new Guid(uniqueUserId));

// Invoke the query. Note that the Invoke method can take country ID and Year

// parameters. By passing in null values

// for these parameters we are not specifying any criteria for our search.

// Note also that by default, the search will return the first 100 results

// that satisfy the query.

List<FAO3510Item> results = service.Invoke(null, null);

// Set up a header row for the results

Console.WriteLine("{0,13}{1,24}{2,18}{3,7}{4,10}","Series Code", "Country or Area Code", "Country or Area", "Year", "Value");

// Iterate through the result set

foreach (FAO3510Item item in results)

{

       Console.WriteLine("{0,13}{1,24}{2,18}{3,7}{4,10}", item.SeriesCode, item.CountryOrAreaCode, item.CountryOrArea, item.Year, item.Value);

}

Console.ReadLine(); 

As these invoke queries go into strongly typed and LINQ enabled data structures, it is easy to filter and do calculations on the data.  And using LINQ’s Join, connect multiple data sets together.

A good example of this is in Zach’s video at around 17:15 https://microsoftpdc.com/Sessions/SVC29

Using RESTful calls over HTTP in Managed code

The second way of consuming data is to use HTTP calls, in this example I am going to use Managed C#.

From the Dallas portal subscription, along with the generated proxies (as above) there is also the URL which may be called along with the AccountKey and UniqueUserID.  This is essentially the same as what the proxy abstracted in the above example.

The only difference here is that we also need the URL to be declared along with the AccountKey and UniqueUserId:

string url = "https://api.sqlazureservices.com/UnService.svc/FAO/3510?$format=atom10";

string accountKey = "";

string uniqueUserId = "";

// Establish a Web Request to the Dallas Dataset Url

WebRequest request = WebRequest.Create(url);

// Specify the request headers containing our account key and unique user ID

request.Headers.Add("$accountKey", accountKey);

request.Headers.Add("$uniqueUserID", uniqueUserId);

// Get the response

HttpWebResponse response = (HttpWebResponse)request.GetResponse();

// Write the status of the response to the Console

Console.WriteLine(response.StatusDescription);

// Wait for input from the user

Console.ReadLine();

// Get the stream containing content returned by the server.

Stream dataStream = response.GetResponseStream();

// Open the stream using a StreamReader for easy access.

StreamReader reader = new StreamReader(dataStream);

// Read the content.

string responseFromServer = reader.ReadToEnd();

// Display the content to the Console.

Console.WriteLine(responseFromServer);

// Cleanup the streams and the response.

reader.Close();

dataStream.Close();

response.Close();

// Wait for input from the user before closing the Console window

Console.ReadLine();

This sets up the Web Request, specifies the accountKey and uniqueUserID in the header of the request, gets the response from that request and reads it back as a Stream.

The same thing can be done in VB.NET:

Dim url As String = "https://api.sqlazureservices.com/UnService.svc/FAO/3510?$format=atom10"

Dim accountKey As String = ""

Dim uniqueUserId As String = ""

' Create a request for the URL.

Dim request As WebRequest = WebRequest.Create(url)

' Specify the headers containing our account key and unique user ID

request.Headers.Add("$accountKey", accountKey)

request.Headers.Add("$uniqueUserID", uniqueUserId)

' Get the response.

Dim response As HttpWebResponse = CType(request.GetResponse(), _HttpWebResponse)

' Write the status of the response to the Console.

Console.WriteLine(response.StatusDescription)

' Wait for input from the user

Console.ReadLine()

' Get the stream containing content returned by the server.

Dim dataStream As Stream = response.GetResponseStream()

' Open the stream using a StreamReader for easy access.

Dim reader As New StreamReader(dataStream)

' Read the content.

Dim responseFromServer As String = reader.ReadToEnd()

' Display the content to the Console.

Console.WriteLine(responseFromServer)

' Cleanup the streams and the response.

reader.Close()

dataStream.Close()

response.Close()

' Wait for input from the user

Console.ReadLine()

Using RESTful calls with Javascript

As Zach specified in the PDC talk, the real power in Dallas is that it can be consumed by a number of different languages, in this example Javascript will be used with an XMLHTTP request.

var url = "https://api.sqlazureservices.com/UnService.svc/FAO/3510?$format=atom10";

var accountKey = "";

var uniqueUserId = "";

var xmlRequest = new ActiveXObject("Msxml2.XMLHTTP");

xmlRequest.open("GET", url);

xmlRequest.setRequestHeader('$accountKey', accountKey);

xmlRequest.setRequestHeader('$uniqueUserID', uniqueUserId);

xmlRequest.onreadystatechange = function() {

    if (xmlRequest.readyState == 4)

    {

        var response = xmlRequest.responseXML;

        // retrieve any values here and format them

        var values = response.getElementsByTagName('d:value');

        Document.Write(values);

    }

}

xmlRequest.send(null);

The main point here is that the pattern in the code is the same across languages, we setup the URL and credentials, setup a HTTP/Web request, add the accountKey and uniqueUserId to the request headers, set up a listener for the response and then do the request.

Firstly: BBC news has written an article on Eye On Earth, my previous project with Microsoft Consulting Services (MCS).

https://news.bbc.co.uk/1/hi/technology/8499059.stm

Also a proud post from Dom Green, who worked alongside me on this project and let everyone know about the article first:

https://domgreen.com/2010/02/05/eye-on-earth-hits-bbc-news/

EyeOnEarth is a rich Silverlight site, built with Bing Maps on the Azure platform utilizing the scalability of the Azure platform and data availability of SQL Azure as its main data source.

Secondly: Microsoft Consultancy Services (MCS), specifically the Solution Development Team, in which I proudly sit, launched a community blog, yesterday with two blog posts, one from Dom Green and the other from myself.  I am looking forward to seeing some great articles here, and contributing some myself.

https://blogs.msdn.com/mcsuksoldev/

(\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE\WcfTestClient.exe)

which comes with visual studio on an azure project, you will probably have come across this problem…

As the WCF service runs locally or in the cloud hosted in azure you will notice that the addresses are different between what is in the address bar in IE and the address given to run svcutil against… this is because Azure runs a load balancer and the url in the address bar is actually the load balancer’s address and not the services address.

This is a known bug in WCF, and currently there is a hotfix for this issue, which will make developing and testing Azure a lot easier.

HOTFIX

The hotfix is extremely simple to do:

Firstly if you have not already done so, go to

https://code.msdn.microsoft.com/wcfazure/Wiki/View.aspx?title=KnownIssues&referringTitle=Home

choose which OS you are using, click the downloads tab at the top, then download and install whichever version suits your OS architecture install.

Secondly in the web.config file in the same project as your WCF .svc files add the following tag in <behaviour> under <serviceBehaviours>:

<useRequestHeadersForMetadataAddress/>

so you should end up with:

<system.serviceModel>

    <behaviors>

        <serviceBehaviors>

            <behavior name="ShoutboxWebRole.ShoutsBehavior">

                <serviceMetadata httpGetEnabled="true"/>

                <serviceDebug includeExceptionDetailInFaults="false"/>

                <useRequestHeadersForMetadataAddress/>

            </behavior>

        </serviceBehaviors>

    </behaviors>

    <services>

        ...

    </services>

</system.serviceModel>

now re-run the Azure application (you may need to restart after the hotfix install), you should see the same url in both the address bar at the top and the svcutil command within the page, this means that you can now add the service address of the load balancer (now both url’s) into the WCF test client and you will be able to poke your methods to your heart’s content, or your tester’s content ;)

(Don’t worry if you’ve only seen one version of EF before now, this is only the second release).

A while back now in PDC was the session with Shyam Pather and Chris Anderson demoing new features of Entity Framework 4.0 and how it evolved from feedback from the previous EF (I think mentioned as EF 3.5 launched with .Net 3.5).

https://microsoftpdc.com/Sessions/FT10

There are a few great features in the new version including Lazy Loading of entity tracked objects in comparison to using the .Include or .Load methods in order to access your entities, using POCO or Plain Old Clr Objects to enable you to pass objects between tiers easier.

The ability to generate a database structure from the model (where before it was only possible to generate a model from the database), so there is a nice 2 way communication to start the project either from database oriented in which you would generate the EF Model from the database structure, or now if you have your conceptual object/entity model, you can generate database structure from that.

Another great feature is adding the ability to call stored procedures from code without as much overhead as before.

New Features List:

Lazy Loading

Simply put, with your auto generated classes from EF, you used to have to say .Load() or .Include(“type here”) in code to ensure that the object trees would load… this could be quite frustrating at times especially with complex object graphs.

For example, if we have a Session with many Speakers, and one Speaker can have many Sessions, if we wanted to list all Speakers with Sessions if we were doing it with EF3.5 we would have to write something along the lines of:

using (var context = new Model1Container())

{

    foreach (var speaker in context.Speakers.Include("Sessions"))

    {

        Console.WriteLine(speaker.Name);

        // alternatively to the include we could do

        // speaker.Sessions.Load();

        foreach (var session in speaker.Sessions)

        {

            Console.WriteLine("\t giving {0} at {1}", session.Title, session.Time);

        }

    }

}

and if you forgot the Load or Include, you would get exceptions at runtime.

Now you can just leave that out, and as long as the objects are generated or the objects (if defined yourself) have the lazy loading enabled.

To enable this in your own objects there are a couple of steps to do:

Firstly set all navigation properties to be virtual to allow the EF to override them with ones which know how to lazy load.

Secondly in the constructor of the container or context (extending ObjectContext) set ContextOptions.LazyLoadingEnabled = true;

public Model1Container()

    : base("name=Model1Container")

{

    ContextOptions.LazyLoadingEnabled = true;

}

and the Entity Framework will now allow you to lazy load your objects.

There will be a T4 code generation template (as demonstrated from 13:10 on the PDC video, link at the top of this post), but is not currently shipped with the beta of VS2010.

Calling to the Database

From 29:00 in the link at the top of this blog, explains how to utilize the power of SQL within the Entity Framework.  This explains that the improvements on .net 4.0 over .net 3.5 for the SQL queries generated.

From 31:46 shows how to pass a SQL Query to the Database Server as a pipe to the Database.  I can see this working very well when calling stored procedures which may not return specific entities or object graphs rather than writing heaps of SQL in your code, and a far better practice.

This goodness can be accessed directly from the context in a method called ExecuteStoreQuery<T>, which takes a type as a generic to format the output as, and a string as the SQL to execute.

Simple Example:

class Program

{

    static void Main(string[] args)

    {

        using (var context = new Model1Container())

        {

            // the sql to execute

            // also formatting it to fit in the Result object type

            var sql = @"

                    select object_id as Id, Name

                    from sys.objects";

            foreach (Result r in context.ExecuteStoreQuery<Result>(sql))

            {

                Console.WriteLine("{0}: {1}", r.Id, r.Name);

            } 

        }

    }

}

// the object formatted result to come back from the DB

public class Result

{

    public int Id { get; set; }

    public string Name { get; set; }

}

by formatting the results as a strong type, we get intellisense when using the results.

To call stored procedures we have to do a couple of things within our model:

First if the model doesn’t know about the stored procedure, go to the model designer right-click on some whitespace and select “Update Model from Database”, then add the stored procedure as you would with entities.

next we do a function import (right click the whitespace in the model designer again, click Add –> Function Import)

select the stored procedure from the dropdown list, if the type being returned is already an entity, then you can select which entity it returns.  Otherwise we can create a new complex type by doing an analyze on the database (push Get Column Information button) and entity framework will create that complex type for you.

In the code we can change the call directly to the method we just imported:

Old:

foreach (Result r in context.ExecuteStoreQuery<Result>(sql))

New:

foreach (var r in context.ExactSameThing())

// or whatever your sproc is called from the function import

Overriding SaveChanges

As the SaveChanges method is now virtual, so it is possible to do checking and access the ObjectStateManager for validation. (this is explained from 21:20 in the link at the top of this blog).

The example given to demonstrate this is to throw an InvalidOperationException if there is more than 1 entity added… a bit of a silly example but goes to show the power of this.

public partial class Model1Container

{

    public override int SaveChanges(SaveOptions options)

    {

        if (ObjectStateManager.GetObjectStateEntries(

            EntityState.Added).Count() > 1)

        {

            throw new InvalidOperationException("Simple demo code... don't use in production");

        }

        return base.SaveChanges(options);

    }

}

Remember here to put this inside the class with the same name as your context as a partial class to allow you to override.