Contrary to popular believe you can actually run multiple ssl sites on an IIS 7 box which only has one ip address (It's easier if you have multiple ip addresses but not impossible if you don't).

This is very useful for development and test boxes running a test ssl cert but can also be used in production environments if all secure sites run under a super cert (e.g. *.mydomain.com)

Follow the guide here

http://www.sslshopper.com/article-ssl-host-headers-in-iis-7.html

However, for the certificate you can easily use a test one in non live environments

http://weblogs.asp.net/scottgu/archive/2007/04/06/tip-trick-enabling-ssl-on-iis7-using-self-signed-certificates.aspx

I recommend you install a single TestSSL certificate on a development machine and apply this process for any new SSL enabled sites in development.

The key I discovered is to assign the certificate to the first site in IIS before running the command line to enable the host headers for other sites.

EDIT: Please see Aaron Block's excellent guide to understanding TFS communiciation architecture along with tips to set this up. I have just added my thoughts in here on top now that i have found this doc:

Organisations may wish to expose their Team Foundation Server resources (including SharePoint Team Sites) using fully qualified domain names (FQDNs) both internally and externally. This document provides (almost) complete guidelines on how to do this, with particular focus on the TFS and SharePoint configuration to support FQDNs.

Install TFS 2010 Beta 2. This guide assumes a single server installation, but could easily be interpreted to work with multiple application tiers.

Set up your FQDN. For internal access, it's recommended that you update your DNS Server internally (e.g. Forward Lookup Zone for tfs.yourcompany.com) to ensure that the FQDN points to an internal IP Address when users are connected to the network (to avoid having to route out to the internet and back).

For external access, add an A record for the FQDN to the DNS zone file for your domain (via your ISP’s control panel normally). You will need to configure your perimeter network appropriately to route public 80 and 8080 (or 443 if you are going secure, not covered here) traffic through to your TFS server which is not covered here. (Although I intend to post separately on doing this with ISA 2006 soon).

Ensure your FQDN is working internally and externally as expected before continuing to configure TFS and SharePoint.

Disable the Loop Back Check on your TFS Server. http://support.microsoft.com/kb/926642. This is required otherwise the TFS Admin Console will throw errors as it won't be able to access your FQDN

Restart your server

Add your FQDN to the alternate access mapping of SharePoint for the TFS Web Application  using SharePoint 3.0 Central Administration > Operations >Alternate access mappings (use 'Add Internal Urls').

Change the RS & WSS locations by directly editing tbl_LocationMapping table in the TFS Configuration database, adding your FQDN in. (Aaron has advised this is definitely not necessary, as these urls can be altered in the TFS Admin Console, see below)

Restart IIS 7.0

Open TFS Admin Console, select Application Tier, then click on Change URLS.

Put your FQDN in the Public Url field and change the Server Url to continue to use the netbios machine name and then click OK. and click OK

Select Application Tier > SharePoint Web Applications, then select the top row in the list within the SharePoint Web Applications list box. Click 'Change SharePoint Web Application' and put your FQDN in the Friendly Name and Web Application Url fields and click OK.

Select Application Tier > Reporting and click Edit. Ensure that your FQDN is used for the Warehouse Database, Analysis Services Database, Report Server Url and Report Manager url.

Start all services again once this is completed.

Within the TFS Admin Console, select Extensions for SharePoint Products, then select the top row in the list within the list box.

Click Modify Access, and ensure the FQDN is added to the URL for Team Foundation Server and click OK.

Note! Excel Reports on the SharePoint sites don't work unless you open ports for Analysis Services (link to follow...)

You should now be ready to go!

Credits
This post builds on the work done in the post below, but is updated for Beta 2 and also includes additional configuration.
http://www.euri.com/Blog/tabid/85/EntryId/38/Changing-the-URL-of-Team-Foundation-Server-TFS-2010-Beta-1-to-a-FQDN.aspx

Despite asking, i wasn't able to get this from the tech ed organisers and was fed up with the god awful ajax scrolling nonsense

Hopefully this will make your session planning a little easier.

Word Session List

Excel Agenda

KandaAlpha has been open sourced on codeplex at http://kandaalpha.codeplex.com. My good friend Will Beattie is helping me with the project and has blogged about kandaalpha.

This article has code specifically for Kentico CMS 4.0 and can be used in a scenario where you have an image’s dimensions and want to ensure that the image fits into a known bounded box.

With Kentico CMS you retrieve images using a call to a handler at /CMSPages/GetFile.aspx. That page accepts parameters Height, Width and MaxSideSize. Height and Width can be fixed and specifying one and not the other will retain aspect ratio. MaxSideSize allows a single value to bound the height and width.

However, if you have a given bounded box on the page (e.g. say a 400 * 300 space) and you want to make sure an image fits inside that space whilst retaining aspect ratio there is no way to do this.

I’ve emailed this code to the Kentico support team to allow MaxHeight and MaxWidth properties so that we can do this. In the meantime this hack/fix within GetFile.aspx.cs code behind file will allow you to supply negative values for height and width which then act as a bounding box!

// HACK - Interpret MaxHeight and MaxWidth via negative Height and Width values (line 599)
if (this.Height < 0 || this.Width < 0)
    ApplyBoundingBox(atInfo.AttachmentImageHeight, atInfo.AttachmentImageWidth);

/// <summary>
   /// Custom Hack to interpret negative height and width values as setting bounding box
   /// </summary>
   private void ApplyBoundingBox(int imageHeight, int imageWidth)
   {

       if (this.Height >= 0 && this.Width >= 0)
           return;

       int maxHeight = 0;
       int maxWidth = 0;
       float ratio = 0;

       if (this.Height < 0)
       {
           maxHeight = this.Height * -1;
           this.Height = imageHeight;
       }

       if (this.Width < 0)
       {    
           maxWidth = this.Width * -1;
           this.Width = imageWidth;
       }

       if (maxHeight > 0 && this.Height > maxHeight)
       {
           ratio = (float)this.Height / (float)maxHeight;
           this.Height = maxHeight;          
           this.Width = (int)((float)this.Width / (float)ratio);
       }

       if (maxWidth > 0 && this.Width > maxWidth)
       { 
           ratio = (float)this.Width / (float)maxWidth;
           this.Width = maxWidth;
           this.Height = (int)((float)this.Height / (float)ratio);
       }

   }

Well, sort off…

The idea is that you have designer types who hate windows and will get ill with prolonged usage. So as to make sure you have an adequate supply and flow of decent mark up coming your way as a developer it’s in your best interests to ensure designer type is safely ensconced within the comfort zone of single button mice and strange looking speakers.

We use team foundation server, otherwise known as TFS, which helps us to manage the source control of all our development efforts. In addition, it helps us manage work items (tasks and bugs) during software projects.

If you are on a Mac and are working with TFS, you need this:
http://www.teamprise.com/products/explorer/

OK, so you can work with source control and work items, big deal, how do you actually run an asp.net website?. Well, thanks to the wonders of virtualisation you simply run a windows vm with an iis website as required and give it an appropriate host header such as macdebug.projectname.mycompany.net. Ensure FTP server is running on your windows vm with an appropriate login so that you can copy files to this website via ftp from your Mac.

Now, back on your good old macintosh, you create a TFS workspace and get latest on your lovely TFS solution to have the files locally on your mac. You use your favourite text or html editor and work on the files, checking them out and in as required, and doing all your work items, great. Obviously visual studio is the tool of choice for .net development but if all your tasks are around working with content assets, mark up and styling related files then you don’t really need all that overhead.

All you need to do is ensure that for each change you make that you have an action to FTP the file that has been changed across to the IIS website via FTP automatically. This ensures that you have the IIS website running off your latest changes.

Last thing you need to do is create a hosts file entry on your mac to point macdebug.projectname.mycompany.net to the IP address of your windows vm. Then you can fire up safari and browse to http:macdebug.projectname.mycompany.net to see your asp.net website!

I’ll post up some visuals and details on the tools we’re using on the mac when I have them.

Expression For Art's Sake from Nigel Parker on Vimeo.

I just started playing with Windows 7 RC1 and thought, i know i’ll try IE8 again, see if they’ve fixed up the main usability thing that was always annoying me which was the way the Stop and Refresh icons were on the other side of the browser from the back and forward icons.

After struggling with the Tools menu i came across this blog post.

http://blogs.msdn.com/ie/archive/2009/04/20/customization-in-ie8.aspx

Right-click IE8 command bar then select Customise > 'Show Stop and Refresh Icons before Address Bar’

If you remove all the toolbars you get a really clean interface with all the navigation buttons next to one another.

Disclaimer: This post contains unsupported guideline for configuring your Kentico CMS 4.x to utilise extensionless urls with IIS 7.0. Use with care!

Base System Requirements: IIS 7.0 with .net 3.5 SP1 on a Windows Vista dev machine or Windows 2008 server to utilise extensionless urls.

Firstly, install the marvellous IIS 7.0 URL Rewrite Module
Get it here: http://www.iis.net/downloads/default.aspx?tabid=34&g=6&i=1692
Learn about it here: http://learn.iis.net/page.aspx/460/using-url-rewrite-module/

Now, make sure Kentico is configured not to interefere with things…

Kentico automatically applies a filter to the form tags. You need to disable this here:

• Site Manager > Settings > Output Filters >
• Ensure the ‘Excluded output form filter URLs’ value is set to a single forward slash.. /
• Site Manager > Settings > Urls>
• Ensure the Friendly Url Extensions value is blank

There is currently no way of ensuring that automatically generated urls from Kentico contain a trailing slash. The user must set the Document UrlPath for each page in Page > Properties > Urls to include the trailing slash. However the trailing slash is enforced via in IIS 7 rewriting rule. It is hoped that a future version of Kentico will allow for this to avoid the extra 301 redirect.

Now apply the following website configuration….

Place the following code in the Page_Load of your master page.
            // ensure we fix up the form action if required
            if (!String.IsNullOrEmpty(Request.ServerVariables["HTTP_X_ORIGINAL_URL"]))
            {
                form1.Action = Request.ServerVariables["HTTP_X_ORIGINAL_URL"];
            }

This ensures that Asp.Net postback and ajax work correctly with the IIS7 URL Rewrite Module

Now all you need to do now is apply whatever special rewriting rule syou like within the web.config, utilising the IIS Rewrite Module’s capabilities as you need them. (Note that you don’t need to do anything within IIS, you can manage everything within the web.config and simply deploy it out to target servers without worrying about any additional configuration).

For example, the EnforceTrailingSlash rule below will ensure that a trailing slash is added to all urls without extensions, performing a 301 redirect in the process. This is so to avoid multiple urls (ones with and without slashes) returning the same content which isn’t ideal from an SEO perspective.

The TrailingSlashToAspx rule below will ensure that a trailing slash is rewritten internally to .aspx, so that the kentico rewriting engine can take over. Note that the Kentico CMS folders are ignored (ones starting with CMS..)

<system.webServer>
        <rewrite>
            <rules>
                <rule name=”EnforceTrailingSlash”>
                    <match url=”^(.*)$” ignoreCase=”false” />
                    <conditions>
                        <add input=”{REQUEST_FILENAME}” matchType=”IsFile” negate=”true” />
                        <add input=”{REQUEST_URI}” negate=”true” pattern=”(.*)\.([a-zA-Z]+)(\?.*)?$” />
                        <add input=”{REQUEST_URI}” negate=”true” pattern=”(.*)/$” />                       
                    </conditions>
                    <action type=”Redirect” url=”{R:1}/” redirectType=”Permanent” />
                </rule>

                <rule name=”TrailingSlashToAspx”>
                    <match url=”^(.*)/$” />
                    <conditions>
                        <add input=”{REQUEST_FILENAME}” matchType=”IsFile” negate=”true” />
                        <add input=”{REQUEST_URI}” negate=”true” pattern=”/cms(.*)$” />
                        <add input=”{REQUEST_URI}” negate=”true” pattern=”^(.*)/\.aspx[#\w=\|\&amp;%-]*$” />
                    </conditions>
                    <action type=”Rewrite” url=”{R:1}.aspx” />
                </rule>
            </rules>
        </rewrite>
    </system.webServer>

And so there you have it, a relatively painless way to get yourself all SEOd with IIS 7.0 and Kentico CMS 4.0.

We’ve just launched another brand spanking new website for Yellow in Yellow Maps. It gives you the ability to do general map and direction searches a la Google but also do specific yellow business listing searches. You can layer on points of interest and see these pop up on your directions from one place to another.

The site was built using Kentico CMS 4, .Net 3.5 SP1, JQuery and the Yellow and Google APIs. Thanks to Calvin, Darren, Campbell and late night pizza from Hell we made it!

My good friend Nigel Parker over at Microsoft beat me to the post with this excellent blog post on Marker Studio's new search site for Yellow and customised IE8 browser experience:

http://blogs.msdn.com/nigel/archive/2009/03/17/yellow-blackcaps-first-to-build-and-deploy-on-ie8-in-new-zealand.aspx

The launch has been very successful with over 10,000 downloads of the Yellow IE8 browser in the first 2 days!

To add a bit of technical detail to Nigel's post we made heavy usage of the Google Search Ajax APIs. I kind of wish they still had the SOAP apis as it would have been easier in many respects using .net to bind the results using server side asp.net rather than be forced to work primarily with the ajax apis. Also, the ajax apis come with handy code snippets http://code.google.com/apis/ajaxsearch/ but they assumed things like ajax calls for paging requests which means the user can't book mark the urls. Aside from that a few workarounds here and there got us enabling Google integrated search quite easily. I would like people to note that the Live Search apis were superior in terms of the range of ways one could consume and make use search services and relevance in my book is very comparable between the two.

We made use of Linq to XML when consuming the core Yellow listings api which is REST based. This made the consumption and binding of the search results to the page using a standard asp.net repeater much easier. In fact, i cringed to think of the additional effort that was involved before Linq for XML in navigating XML Documents with the .net 2.0 xml apis which I never found particularly intuitive.

There is also some Salesforce integration for helping to manage competition entries where we created custom lead objects in Salesforce. It's kind of nice to have the ability to regenerate the wsdl for the web service after you make changes in the gui to core field information. It would be even nicer to have this discoverable at runtime so i could just regenerate proxies using a url rather than having to download the wsdl and re-run svcutil across the wsdl locally.

And let's not forget our good friend JQuery, and loving that Intellisense support in Vs.Net 2008;) Also a shout to facebox for those obligatory modals with rounded corners.

Oh, and the whole thing is powered by Kentico CMS. Kentico CMS is a powerful, flexible and affordable content and document management system that i have been personally recommending to all and sundry since i first came across it in 2005. At Marker  <shamelessPlug>we have a great team of experienced Kentico developers should be looking in this direction. Please give me a yell if you would like to discuss further</shamelessPlug>.

I just realised there exists today more helpful free software than i could ever possibly imagine. A few years back I remember it being hard to find good little utilities to do even the most basic things like FTP in a reliable usable way.

TwitterFeed.com

Anyways...I've resuscitated my usage of Twitter by using www.twitterfeed.com. Essentially, this allows me to automatically prefix and post up tweets from RSS Feeds.

In my case, i'm automatically tweeting from Google Reader shared items (i simply click a share item in Google Reader, and a tweet is imminent..) and from this blog.

FriendFeed.com

In addition, i thought i would blabber a bit about www.friendfeed.com which is essentially an aggregation portal for your online activity.

I've integrated friendfeed activity directly into my blog (on the right hand side panel) which should make some of the things i'm doing without the need for formal blog posts.

You *could* if you wanted have twitter feed pull from all your online activity via freidn feed, but you would have to exclude twitter from friendfeed to avoid a nasty infinite loop of friendfeed/twitter posts;)

To avoid this, you can filter the friendfeed rss by service, but you can only select one service;( i wanted to create a feed for everything apart from twitter but couldn't do this.

This is why i'm manually adding feeds to twitterfeed.

Have fun!

And one more exam to get the web developer certification. This adds 3 points to our Microsoft partnership, only a few points left for gold! Some less boring posts soon i promise...

Another exam another certification, one more for MCPD and then i can retire safe in the knowledge I have contributed handsomely to the development and continuance of one of the world's largest corporations.

Just found a really really useful whitepaper on Entity Framework mapping possibilities. If you're doing any work with EF this will certainly come in useful.

http://download.microsoft.com/download/b/3/3/b333d63e-0df2-4d43-978a-1ce9d2f39801/EntityFrameworkMappingWhitepaper.pdf

I am now officially a genius after scoring 929/1000 in my Moss (SharePoint) configuration exam. Thank you.

We created the following extension methods for entity framework to avoid code bloat in consuming applications when working with these key types. I hope you find them useful if you are working with the Entity Framework.

EntityObject

/// <summary>
/// Extension methods for EntityObject
/// </summary>
public static class EntityObjectExtensions
{

    /// <summary>
    /// Gets the original value for a modified entity object's property
    /// </summary>
    /// <returns>the value before the property was modified</returns>
    public static T GetOriginalValue<T>(this EntityObject entityObject, string propertyName)
    {
        if (entityObject == null)
            return default(T);
        if (entityObject.EntityState == EntityState.Modified)
        {
            ObjectContext context = [YOUR OBJECT CONTEXT]
            ObjectStateEntry stateEntry = null;
            context.ObjectStateManager.TryGetObjectStateEntry(entityObject, out stateEntry);

            if (stateEntry != null)
                return (T)stateEntry.OriginalValues.GetValue(stateEntry.OriginalValues.GetOrdinal(propertyName));

        }

        // return the value of the property
        return (T)entityObject.GetType().GetProperty(propertyName).GetValue(entityObject, null);
    }

EntityCollection<T>

/// <summary>
   /// Extension methods for EntityCollection
   /// </summary>
   public static class EntityCollectionExtensions
   {
       /// <summary>
       /// Loads the entity collection if it hasn't already been loaded
       /// </summary>
       /// <typeparam name="T">Type of entity collection</typeparam>
       /// <param name="entityCollection">Entity collection to potentially load entities into</param>
       /// <param name="entitySource">The source entity which has the entity collection relationship (modified or unchanged only)</param>
       public static void EnsureLoaded<T>(this EntityCollection<T> entityCollection, EntityObject entitySource) where T : class, IEntityWithRelationships
       {
           if (entitySource != null && entityCollection != null && !entityCollection.IsLoaded )
           {
               if (entitySource.EntityState == System.Data.EntityState.Modified || entitySource.EntityState == System.Data.EntityState.Unchanged)
               {
                   entityCollection.Load();
               }
           }
       }

       /// <summary>
       /// Returns the collection as a queryable type
       /// </summary>
       /// <typeparam name="T">Type of entity collection</typeparam>
       /// <param name="entityCollection">Entity collection to return as a queryable object</param>
       /// <param name="ensureLoaded">Flag to determine if to load the collection if it has not been done so already</param>
       /// <returns>Queryable object for the in memory collection</returns>
       public static IQueryable<T> AsQueryable<T>(this EntityCollection<T> entityCollection, bool ensureLoaded, EntityObject entitySource) where T : class, IEntityWithRelationships
       {
           if (ensureLoaded)
               EnsureLoaded(entityCollection, entitySource);
           return entityCollection.AsQueryable();
       }

EntityReference<T>

/// <summary>
   /// Extension methods for EntityReference
   /// </summary>
   public static class EntityReferenceExtensions
   {

       /// <summary>
       /// Loads the entity reference or its value if it hasn't already been loaded.
       /// </summary>
       /// <typeparam name="T">Type of entity reference</typeparam>
       /// <param name="entitySource">The source entity which has the entity reference relationship (added, modified or unchanged only)</param>
       public static void EnsureLoaded<T>(this EntityReference<T> entityReference, EntityObject entitySource) where T : class, IEntityWithRelationships
       {
           if (entitySource != null && entityReference != null && !entityReference.IsLoaded && entityReference.EntityKey != null)
           {
               if (entitySource.EntityState == System.Data.EntityState.Added) // add the value directly as load will throw
               {
                   if (entityReference.Value == null)
                       entityReference.Value = LoadByKey<T>(entityReference.EntityKey);
               }
               else if (entitySource.EntityState == System.Data.EntityState.Modified || entitySource.EntityState == System.Data.EntityState.Unchanged)
               {
                   entityReference.Load();
               }
           }
       }

privateT LoadByKey<T>(object entityKey)
{
    if (entityKey == null)
        throw new ArgumentNullException("Supplied entity key is null, unable to load entity", "entityKey");
    // make sure the object is loaded in the object context
    ObjectContext objectContext = [YOUR OBJECT CONTEXT];
    EntityKey key = (EntityKey)entityKey;
    ObjectStateEntry entry;
    if (!objectContext.ObjectStateManager.TryGetObjectStateEntry(entityKey, out entry) || entry.Entity == null)
    {
        return (T)objectContext.GetObjectByKey(key);
    }
    return (T)entry.Entity;
}

       /// <summary>
       /// Whether or not the entity reference has an entity key with a value present
       /// </summary>
       public static bool HasEntityKeyFirstValue<T>(this EntityReference<T> entityReference) where T : class, IEntityWithRelationships
       {
           return entityReference != null && entityReference.EntityKey.HasFirstValue<int>();
       }

       /// <summary>
       /// Get entity key with a value present
       /// </summary>
       public static int GetEntityKeyFirstValue<T>(this EntityReference<T> entityReference) where T : class, IEntityWithRelationships
       {
           if (entityReference != null)
               return entityReference.EntityKey.GetFirstValue<int>();
           return 0;
       }

EntityKey

/// <summary>
   /// Extension methods for EntityKey
   /// </summary>
   public static class EntityKeyExtensions
   {

       /// <summary>
       /// Gets the first entity key value
       /// </summary>
       /// <returns>the first entity key value</returns>
       public static T GetFirstValue<T>(this EntityKey entityKey)
       {
           if (entityKey != null && entityKey.EntityKeyValues != null && entityKey.EntityKeyValues.Length > 0)
               return (T)entityKey.EntityKeyValues.First().Value;
           return default(T);
       }

       /// <summary>
       /// Sets the first entity key value
       /// </summary>
       public static void SetFirstValue<T>(this EntityKey entityKey, T value)
       {
           if (entityKey != null && entityKey.EntityKeyValues != null && entityKey.EntityKeyValues.Length > 0)
               entityKey.EntityKeyValues.First().Value = value;
           return;
       }

       /// <summary>
       /// Whether or not the entity key has a first value
       /// </summary>
       public static bool HasFirstValue<T>(this EntityKey entityKey)
       {
           var firstValue = GetFirstValue<T>(entityKey);
           var defaultValue = default(T);
           return (!firstValue.Equals(defaultValue));
       }

I saw the following code on a customer object which made me think about affording a better way to query domain relationships without the extra methods, extension methods come to the rescue!

I realise transparent lazy loading a la Nhibernate is another option, but i think that this way keeps the spirit of explicitly loading from the database, but reduces the amount of code clutter on the client side so you are not forever checking whether a relationship is loaded or not, you simply request an IQueryable from the EntityCollection<T>.

        /// <summary>
        /// Finds a customer account with the specified ID
        /// </summary>
        /// <param name="customerAccountID">ID of the customer account to find</param>
        /// <returns>Customer account with the specified ID</returns>
        public CustomerAccount FindAccount(int customerAccountID)
        {
            if(!this.CustomerAccounts.IsLoaded)
            {
                this.CustomerAccounts.Load();
            }

            var query =
                from ca in this.CustomerAccounts
                where ca.CustomerAccountID == customerAccountID
                select ca;

            return query.FirstOrDefault();
        }

I added a static class with the extension methods for the EntityCollection type as follows:

public static class EntityCollectionExtensions
    {
        public static EntityCollection<T> EnsureLoaded<T>(this EntityCollection<T> entityCollection) where T : class, IEntityWithRelationships
        {
            if (!entityCollection.IsLoaded)
                entityCollection.Load();
            return entityCollection;
        }

        public static IQueryable<T> AsQueryable<T>(this EntityCollection<T> entityCollection, bool ensureLoaded) where T : class, IEntityWithRelationships
        {
            if (ensureLoaded)
                entityCollection = EnsureLoaded<T>(entityCollection);
            return entityCollection.AsQueryable();        }
    }

This allows you to do the following, which will only go to the database if the relationship is not loaded.

            var query =
                from ca in this.CustomerAccounts.AsQueryable(true) // ensure the relationship is loaded and return a queryable on it
                where ca.CustomerAccountID == customerAccountID
                select ca;
    return query.FirstOrDefault();

I saw a post from the alt.net community here saying the EF was crap basically....http://efvote.wufoo.com/forms/ado-net-entity-framework-vote-of-no-confidence/

The core complaints raise some important issues, but i really don't think we need to go ballistic, and in some cases the concerns are just plain wrong. Time would be better spent finishing the Linq for NHibernate provider don't you think??

I've been working solidly with EF since the SP1 beta came out and can honestly say it's holding up very well across a large, enterprise data model structure, and alongside usage of a repository pattern and dependency injection to factor out most of the direct dependencies on the EF ObjectContext, we have a system that can move towards POCO over time with relatively little refactoring.

Here's some of my responses:

The design of the framework entities is that they are data only, causing issues in maintainability and making it difficult or impossible to implement business objects or more “real-world” objects. 
Wrong, you use partial classes to extend the generated aspects of the entities. This is explicitly encouraged and we use it a lot for core business rules and validation. There is nothing to stop you adding new non persistent properties or methods, or indeed new classes that are used alongside the entities.

The design of the framework entities is that they cannot be persistence ignorant, so things like unit testing become next to impossible because you cannot test the model without the database (for instance).
There are (admittedly difficult) ways to get close to POCO. Rather than tear your hair out, we used the repository pattern around the EF and avoid using the object context directly. You are then only dependent on EntityObject, EntityReference and EntityCollection on your entities. If you are sensible about it and don't work on object context, your refactoring when vnext comes along will be significantly reduced. This is a happy compromise for us and works well.

Lazy loading is not supported at all and requires a lot of extra code to make work.  This confuses me.  I thought I saw "lazy-loading" demoed internally but I might be mistaken.
KP > 'By design';) but honestly pretty easy to wire it up, not really a "lot of extra code". I have worked for years with NH too, and the time saved using the designer with EF more than makes up for it:)

Shared, canonical models contradict software best practices.  This appears to be related to using a single shared model for multiple contexts in the EF, rather than multiple models, one for each individual context. 
KP > Well, it may be a criticism of the vision of EF (the more than just an ORM story), but not of its core ORM functionality. Our clients are interested in the reporting aspects on their entity models without writing excessive code. It remained to be seen how this will pan out, but surely this is not a reason to pledge a vote of no confidence in a piece of technology?

Excessive merge conflicts with source control.  Apparently, since the diagram contains the model and the visualization, it causes tons of merge conflicts when a team is using it.
A somewhat moot point for most teams. We've settled on having a 'domain master', not a biggy for most teams? shared design on the database, entities and relationships would get messy in the best of worlds, i don't think this is a biggy.

Wow, what a sexy title!

This post shows how you can have a repository pattern with the entity framework .

So, here we have a generic repository interface through which you can do all the nice things. You would normally use Castle Windsor (or similar Dependency Injection tool) to configure the Repository implementation (such as EFRepository) so you then just have a dependency on the interface, which is nice. Here's a snippet of how to configure the EFRepository to be used for all requests for IRepository from Castle Windsor. Note the ability to change object contexts and even the repository implementation, as long as IRepository is supported, the application won't care.

<castle>
    <components>

         <component id="objectContext" type="YourObjectContext"  ></component>
      <component id="iEFRepository" service="YourIRepository" type="YourEFRepository"
        <parameters>
          <objectContext>${objectContext}</objectContext>
        </parameters>
      </component>
    </components>
  </castle>

Note the reflection in the EFRepository implementation which allows you to query and work with all types in a hierarchy. By default you can't work directly with sub types in EF, you have to do extra work to get to them. The reflection gets the base type before communication with the ObjectContext to ensure minimal fussing about for the developer. Note i don't understand why this isn't built in to be honest, perhaps they ran out of time!

The whole point of this is that you avoid using your application's ObjectContext explicitly and only work with the core business entities that are then managed by the Entity Framework. This allows us to have a good separation of concerns between the various layers (although our entities are not pure POCO sadly). Note that i have only exposed the most widely used features of ObjectContext, you can extend your Repository interface and implementation to expose more advanced parts of the ObjectContext implementation if needs be.

In the future, EF may move towards greater persistence ignorance, but in the mean time structuring your application working off a Repository interface will mean minimal changes as EF changes moving forwards.

IRepository interface

public interface IRepository
  {

      /// <summary>
      /// Return reference to an underlying repository context
      /// </summary>
      /// <returns>the repository context</returns>
      object GetRepositoryContext();

      /// <summary>
      /// Return strongly typed IQueryable
      /// </summary>
      IQueryable<T> GetQuery<T>();

      /// <summary>
      /// Load entity from the repository or store if necessary
      /// </summary>
      /// <typeparam name="T">the entity type to load</typeparam>
      /// <param name="where">where condition</param>
      /// <returns>the loaded entity</returns>
      T Load<T>(Expression<Func<T, bool>> whereCondition);

      /// <summary>
      /// Mark entity to be deleted within the repository
      /// </summary>
      /// <param name="entity">The entity to delete</param>
      void Delete<T>(T entity);

      /// <summary>
      /// Add entity to the repository
      /// </summary>
      /// <param name="entity">the entity to add</param>
      /// <returns>The added entity</returns>
      void Add<T>(T entity);

      /// <summary>
      /// Updates entity within the the repository
      /// </summary>
      /// <param name="entity">the entity to update</param>
      /// <returns>The updates entity</returns>
      void Update<T>(T entity);

      /// <summary>
      /// Save all changes from repository to store
      /// </summary>
      /// <returns>Total number of objects affected</returns>
      int SaveChanges();

  }

Now we have our proper EFRepository.......

EFRepository implementation

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

public class EFRepository : IRepository, IDisposable
  {
      private ObjectContext _objectContext;

      private Type GetBaseType(Type type)
      {
          Type baseType = type.BaseType;
          if (baseType != null && baseType != typeof(EntityObject))
          {
              return GetBaseType(type.BaseType);
          }
          return type;
      }

      private bool HasBaseType(Type type, out Type baseType)
      {
          Type originalType = type.GetType();
          baseType = GetBaseType(type);
          return baseType != originalType;
      }

      public EFRepository(ObjectContext objectContext)
      {
          _objectContext = objectContext;
      }

      public ObjectContext ObjectContext
      {
          get
          {
              return _objectContext;
          }
      }

      public object GetRepositoryContext()
      {
          return this.ObjectContext;
      }

      public IQueryable<T> GetQuery<T>()
      {
          Type baseType;
          if (HasBaseType(typeof(T), out baseType))
          {
              return this.ObjectContext.CreateQuery<T>("[" + baseType.Name.ToString() + "]").OfType<T>();
          }
          else
          {
              return this.ObjectContext.CreateQuery<T>("[" + typeof(T).Name.ToString() + "]");
          }
      }

      public T Load<T>(Expression<Func<T, bool>> whereCondition)
      {
          return this.GetQuery<T>().Where(whereCondition).First();
      }

      public void Add<T>(T entity)
      {
          this.ObjectContext.AddObject(GetBaseType(typeof(T)).Name.ToString(), entity);      
      }

      public void Update<T>(T entity)
      {
          EntityObject entityObject = entity as EntityObject;
          ObjectContext objectContext = this.ObjectContext;
          objectContext.ApplyPropertyChanges(
              GetBaseType(typeof(T)).Name.ToString(),
              objectContext.GetObjectByKey(entityObject.EntityKey)
          );
      }

      public void Delete<T>(T entity)
      {
          this.ObjectContext.DeleteObject(entity);
      }

      public int SaveChanges()
      {
          return this.ObjectContext.SaveChanges();
      }

      public void Dispose()
      {
          if (_objectContext != null)
          {
              _objectContext.Dispose();
          }
      }

  }

http://friendfeed.com/kpatton contains a list of all my online activity, essentially blog posts, youtube, flickr and twitter stuff. Nice idea, although there seems to be a new social networking site every 5 minutes and i'm struggling to keep up!

We've just built a complete 64 bit moss 2007 development environment and thought i'd share the process via a pdf this time rather than 10 huge blog entries so you can download it from one place.

64 bit is the recommended set up for Moss and it's strongly rumoured that future versions of Moss will be 64 bit only. It makes sense to have your development environment running in 64 bit if your Build, UAT and Authoring/Production farms are going to be runnign 64 bit too.

Download the Moss 2007 64 bit Development Environment Setup Guide Now

All comments welcomed!

Lots of people are obviously intending to install the office service pack 1 onto their Moss installations. However, what's the advice if you are (like me) creating a new multi-server moss farm and you want to ensure you rollout moss 2007 with SP1 applied?

Well, looking at the official documentation just didn't look like it was easily possible, and there was conflicting advice on the web around when to install SP1.

e.g. Configure your whole farm or just the SSP? Run the updates after the initial installation but don't run the config wizard? etc. etc.

This is until that is you realise that you can use the /Updates folder on the root of the Moss installation files, which is what the folder is for, to provision updates/patches.

So follow these five steps to Moss 2007 with SP1 install heaven:

1. Copy the contents of the MOSS 2007 CD to your hard drive (e.g. C:\MossWithSP1)

2. Download WSS 3.0 SP1 and Office 2007 SP1 (e.g C:\MossSp1)

3. Extract the contents to the Updates folder within your locally copied Moss installation by running the following at the command prompt: 

C:\MossSp1\Wssv3sp1-kb936988-x86-fullfile-en-us.exe /extract:c:\MossWithSP1
C:\MossSp1\Officeserver2007sp1-kb936984-x86-fullfile-en-us.exe /extract:c:\MossWithSP1

4. Use ImgBurn to burn the C:\MossWithSp1 back to an iso or to cd.

5. Use this disc on all future new Moss farms you build to avoid the need to upgrade to SP1

Now why on earth didn't Microsoft do this for new installations and make it available on MSDN!!??

Well, back in July last year i posted 10 steps to heaven with the installation of MOSS 2007 for usage by a developer.

Trouble was, some of the assumptions led to the need to have some manual steps at the end most notably the requirement to be attached to a corporate domain and this brought in the need to sysprep any such image so it would be unique on the ad network.

When we thought about this we realised that in a lot of ways having hte image as a domain controller made sense, we could install everything on one box and then just clone the VM. However, we didn't want to have a domain popup for every developer that was developing in Moss.

Along then came the NAT mode in VMWare Server. This allows us to run a completely private Moss domain for each developer whilst retaining corporate and internet connectivity from that VM.

After much trial and error we think we have come acrss the ideal way to carry out team development in SharePoint and i hope this helps people in developing their SharePoint solutions too.

See the updated post on how to build a complete moss 2007 64 bit virtual development environment here:

http://blog.keithpatton.com/2008/03/05/MOSS+2007+64+Bit+Virtual+Development+Environment.aspx

It's not often i gush about windows software, particularly considering how utterly vista has failed to capture the imagination of the ordinary user. Included with vista was the nice Windows Photo Gallery which was really an IPhoto equivalent built into the OS.

Now, Windows Live Photo Gallery (wikipedia: http://en.wikipedia.org/wiki/Windows_Live_Photo_Gallery, download: http://get.live.com/photogallery/overview) is available for XP and Vista users which is essentially an upgrade to this vista application with some lovely new features that i think should make it an essential download for any blogger or user who publishes images and videos to the web on a regular basis.

First off, the name, Windows Live Media Gallery anyone?

I think MS made a mistake in calling the application Windows Live Photo Gallery, instead it should be Windows Live Media Gallery because it handles the tagging, previewing, burning, playing and publishing of video content just as gracefully as photo media. I suspect this was to avoid confusion with the Windows Media Player application. Perhaps the whole interface should be merged who knows...

Importing Media

When you import photos and videos into Windows Live Photo Gallery you get very granular control over where the files go and crucially the auto-tagging of the files. In the base version of Windows Photo Gallery on vista, you could only tag in an all or nothing way for all imported files. So, getting stuff in and organising your import is a breeze.

Tagging and Publishing Media

Creating, organising and assigning media to tags is easy, with drag and drop support throughout. Best of all, tags are retained when publishing media. A new Publish menu item appears at the top of the main interface, allowing you to publish images to MSN Spaces AND Flickr. I highly recommend Flickr and it's great to see MS support a 3rd party service out of the box like this. Tagging is preserved when publishing to Flickr and Flickr has officially announced support for Windows Live Photo Gallery.

Unfortunately, the only thing that lets down the Publish option is that for video only MSN Video is supported, although i hope YouTube support will be forthcoming perhaps in a future release. MSN Video is fine and dandy and free, but i have all my videos at YouTube and really want to publish there with full tagging integration a la Flickr support. In the meantime, i simply utilise the YouTube multi file upload interface and manually re-assign tags not a biggy as i don't have as many videos as photos.

Windows Live Writer

Whatever blog you use, you should really use Windows Live Writer as an excellent editor for publishing to your blog. It will work with almos any blog out there and is easy to set up as long as you have your blog's home page url, username and password. I find it much nicer to write up blog posts rather than having to login to my blog website each time.

It is also a highly extensible little applicaiton and already has plugins such as a Flickr Plugin to support selecting one or more images from your Flickr stream.

You can also easily insert videos you have posted to YouTube, Google Video or MSN Video.

There is a site, Windows Live Writer plugins, where you can view even more useful plugins for this essential blogging tool.

Congrats to Andy, Teresa, Chris et al at Hyro NZ for getting this up and running. Despite many obstacles this is now a New Zealand first which i've been helping Andy get up and running for months. I think this'll take off once the other channels eye ball it and i wish the team all the very best of luck with this over the coming months.

Check it out on Sky Channel 65, txts only $0.99 each!

Well, perhaps not, but it is a very cool piece of software for your mobile. http://www.fring.com/

Essentially, it integrates with Skype, MSN and GTalk to provide unified VOIP capabilities. It also has Twitter capabilities for the very geeky amongst you.

Now, 3G chargs in NZ being what they are (and i imagine elsewhere), this is only really of interest in Wifi zones e.g. at home, work or at cafes. However, it does mean you can use your mobile to send/receive Skype calls from home without having to sit in front of your computer and/or buy a special Skype enabled handset.

Fring also has the advantage of being able to incorporate new VOIP services over time and provides a single presence notification for all your contacts, choosing VOIP if available or GSM if not.

As services like WIMAX become available, i'm hoping that we will have a genuine, low-cost alternative (akin to fixed line broadband plans) to mobile operators and their fees within the next 5 years. I'm actually expecting commercial availability of WiMax capable mobiles in or around 2010, we'll wait and see on that one!

In the meantime, if you have a compatible handset and access to wifi or affordable 3g (is there such as thing), get fring immediately.

Yet another gadget, this time a chrissy present to myself in the Nokia N95. i've resited buying a new mobile for some time now, but the pitcure and video quality on this phone means i'll probalby not bother taking a camera or camcorder with me on holidays. it posts up pictures automagically to flickr and i'm going to have a stab at coding things so that it will upload videos and pictures to the blog. The rich media side of things has been sorely lacking of late dear readers so rest assured there will be more videos of tommy, annabel shouting at me and general tomfoolery to come shortly.

We've been working on this one for a while, finally goes live, http://www.avjennings.com.au. Built using www.kentico.com our favourite CMS.

Woohoo! My GPS wristwatch thingy has arrived. It measures distance, speed, elevation, heart rate, calorie count as you run. Even allows you to race against your previous runs and export the runs to google maps!

https://buy.garmin.com/shop/shop.do?pID=349 

Our work is moving offices tomorrow and we did a nice little flash thing for the move. Shout out to Big Tau for the design;)

http://movielibrary.lynda.com/html/modPage.asp?ID=384

http://movielibrary.lynda.com/html/modListing.asp?vid=70

http://silverlight.net/quickstarts/blend_quickstart/default.aspx

Hi, Pointless little post to ensure my technorati profile gets set up ok.

OK, here we go, the complete guide to setting up a MOSS2007Development Environment Virtual Server

[Updated 05/03/2007: See the following post with downloadable pdf for the entire process]

http://blog.keithpatton.com/2008/03/05/MOSS+2007+64+Bit+Virtual+Development+Environment.aspx

OK, here we go, the complete guide to setting up a MOSS2007Development Environment Virtual Machine

[Note: 05/03/2008 Updated to become a downloadable pdf, see below]

http://blog.keithpatton.com/2008/03/05/MOSS+2007+64+Bit+Virtual+Development+Environment.aspx

I just had to blog about a really great website i just found for building family trees called www.geni.com. It really is one of the most easy to use websites i've ever seen, have a try. It also doubles as a handy birthday reminder tool and you can store family photos etc.

Steve Jobs and Bill Gates in a very, very rare interview together.

http://d5.allthingsd.com/20070530/steve-jobs-and-bill-gates-together-part-1-of-7/

working in software is so much fun;)

I posted previously about the truly awful UI experience in IE7, particularly the fact that it is not customisable.

Well, glory be the wonderful free add on Quero makes IE 7 worth using again as it groups all the navigation options (back, forwards, refresh, stop and home) where they should be, next to each other!

There are also some other nifty features such as search highlighting, themes and the ability to put the main menu navigation back where it shoudl be, at the top of the window!

I just downloaded the latest updates for windows vista to find some lovely little videos you can setup as the background for your desktop environment.

Now, let me state up front i am no LAMP or Firefox bigot. For better or worse i am an MS fan, already having converted my household to Vista and OneCare. However...having used IE7 since the early betas i'm afraid to say that Firefox is by far the most usable, quicker browser. Although my evidence is anecdotal (i work and consult with many other developers,project managers, business analysts who all for the most part corroborate my theory), IE 7 is confusing on a very basic level..

OK, i have a widescreen, so these screenshots look worse than on a normal monitor. But hey, wasn't Vista developed with widescreen in mind (sidebar gadgetry etc.)? Anyway, i've marked the key web navigation elements in red below. Note how in IE 7 the back and forward buttons are standalone, but if you want to Stop or Refresh the page you have to go to the right of the address bar. And if you want to go home, you have to go underneath to the tab level, mmm.

I won't even mention the fact that MS broke all previous design and decided to hide the menu navigation. OK, you can show it, but then it doesn't appear where you would expect it at the top, but strangely nestled between the address bar level and the tab level. It just looks well, awkward...

All this would be almost forgivable if like most MS applications you could tinker with the menus, but lo and behold for some strange reason you can't do diddly except hide and show things, the position of everything is fixed, damn!

IE7

Contrast this with Firefox, which places all the key navigation elements right next to each other, and logicall places the menu bar at the top were it belongs. You can drag stuff about levels and the whole experience (particularly on a widescreen) is so much more pleasant.

Firefox

mmm, www.sky.co.nz. Want to talk with a human being at nz's digital tv monopoly...try and find the phone number. They changed their website some months ago and no longer want you to ring them. Poor Sky, they obviously don't make enough money out of us already that they think a crappy forum system treating us like 6 year olds is the best way to provide customer service.

It is there, but you have to hunt

http://www.skytv.co.nz/index.cfm?pageid=408