I just installed XBMC and I was done.

Recently I decided it would be nice if I could access it remotely (from Windows), so installed a ssh (openssh) server in it. It worked just fine, until I noticed that some applications would show strange characters, like if the text encoding was wrong, and that was what was happening, let me show you what I mean:

That application is called mc (Midnight Commander) and it’s a nice text-based file explorer. Also I’m using PuTTY to connect to my Linux box.

First thing I had to do was to check which encoding was being used in my server. To do that in Linux just open a terminal and type locale. I’m pretty sure if you do this you’ll get UTF-8 as I did.

[If you want to read a little bit about encoding and why it is that you get strange characters when you are using the wrong encoding I recommend this blog post by Joel Spolsky]

Now, to avoid the encoding problem you just have to configure PuTTY to use the right encoding so it can interpret those characters correctly. To do it just use the Window->Translation feature when configuring the connection:

And now, instead of all the â’s you get this:

If you’re thinking about doing something like this, another useful piece of information is how to do it while having a dynamic ip (assigned to you by your ISP and liable to change at any time). I’m using No-IP for it, which worked just fine for me in Ubuntu, here’s the link for it.

1. Create a Silverlight Navigation Application (for example)

2.Add a ADO.Net Entity Data Model to the Web project (the one that will provide data to be returned by the methods the WCF service):

Choose the tables you want the tool to include in your EF4 Conceptual model:

Regarding the ADO.Net Entity Data Model, you’re done.

3. The Silverlight enabled WCF service:

In the web project add a new Silverlight Enabled WCF service:

using System;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.Collections.Generic;
using UsingWCFServicesReloaded4.Web.Models;

namespace UsingWCFServicesReloaded4.Web.Services
{
    [ServiceContract(Namespace = "")]
    [SilverlightFaultBehavior]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class LendingService
    {
        [OperationContract]
        public List<Person> GetPeople()
        {
            LendsEntitiesObjectContext context = new LendsEntitiesObjectContext();            
            return context.People.ToList<Person>();
        }

        // Add more operations here and mark them with [OperationContract]
    }
}

Do not fall in the temptation of prematurely disposing of the ObjectContext. You frequently see EF4 examples where the ObjectContext for your entities is created inside a using block, something like this:

using System;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.Collections.Generic;
using UsingWCFServicesReloaded4.Web.Models;

namespace UsingWCFServicesReloaded4.Web.Services
{
    [ServiceContract(Namespace = "")]
    [SilverlightFaultBehavior]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class LendingService
    {
        [OperationContract]
        public List<person> GetPeople()
        {
            using (LendsEntitiesObjectContext context = new LendsEntitiesObjectContext())
            {
                return context.People.ToList<person>();
            }            
        }

        // Add more operations here and mark them with [OperationContract]
    }
}

This will bring you pain, I assure you. The reason for this to subtly not work is that (unless you are using POCOs with EF4, and without the virtual trick [ask me about it, if you’re interested]) the entities that were auto generated for you will contain references to the ObjectContext, in this case Person has references to LendsEntitiesObjectContext which at the time of the WCF black magic that occurs between this method (GetPeople) being invoked (which involves serializing the list of persons so it can be sent through the wire) and the results getting to the client invoking it, tragedy will happen, because that LendsEntitiesObjectContext will not exist at that time.

Now you have to add this service to your silverlight app:

Click discover and your service should be there:

So there you go, there’s not much more to it than this, just for kicks here’s the XAML and the source code of the Home.xaml file that was autogenerated by the Silverlight Navigation Application Visual Studio template that I’ve changed to display a datagrid with the results returned from the GetPeople method of the WCF service:

Views\Home.xaml’s XAML:

<navigation:Page x:Class="UsingWCFServicesReloaded4.Home" 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:navigation="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Navigation"
    mc:Ignorable="d" d:DesignWidth="640" d:DesignHeight="480"
    Title="Home"
    Style="{StaticResource PageStyle}" xmlns:sdk="http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk">

    <Grid x:Name="LayoutRoot">
        <ScrollViewer x:Name="PageScrollViewer" Style="{StaticResource PageScrollViewerStyle}">

            <StackPanel x:Name="ContentStackPanel">

                <TextBlock x:Name="HeaderText" Style="{StaticResource HeaderTextStyle}" 
                                   Text="Home"/>
                <TextBlock x:Name="ContentText" Style="{StaticResource ContentTextStyle}" 
                                   Text="Home page content"/>
                <sdk:DataGrid AutoGenerateColumns="True" 
                              Name="PeopleDataGrid"/>
                <Button x:Name="RefreshButton" Click="RefreshButton_Click">
                    Refreh
                </Button>
            </StackPanel>

        </ScrollViewer>
    </Grid>
</navigation:Page>

Code Behind:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace UsingWCFServicesReloaded4
{
    public partial class Home : Page
    {
        LendingService.LendingServiceClient _proxy = new LendingService.LendingServiceClient();
        public Home()
        {
            InitializeComponent();
        }

        // Executes when the user navigates to this page.
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            _proxy.GetPeopleCompleted += new EventHandler<LendingService.GetPeopleCompletedEventArgs>(_proxy_GetPeopleCompleted);
        }

        void _proxy_GetPeopleCompleted(object sender, LendingService.GetPeopleCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                MessageBox.Show(e.Error.Message);
            }
            else
            {
                PeopleDataGrid.ItemsSource = e.Result;                
            }
        }

        private void RefreshButton_Click(object sender, RoutedEventArgs e)
        {
            _proxy.GetPeopleAsync();
        }
    }
}

And just in case you want to try it with the simple database I’ve used here’s the DDL for it:

-- --------------------------------------------------
-- Entity Designer DDL Script for SQL Server 2005, 2008, and Azure
-- --------------------------------------------------
-- Date Created: 05/09/2011 16:03:32
-- Generated from EDMX file: ...Lends.edmx
-- --------------------------------------------------

SET QUOTED_IDENTIFIER OFF;
GO
USE [Lends];
GO
IF SCHEMA_ID(N'dbo') IS NULL EXECUTE(N'CREATE SCHEMA [dbo]');
GO

-- --------------------------------------------------
-- Dropping existing FOREIGN KEY constraints
-- --------------------------------------------------

IF OBJECT_ID(N'[dbo].[FK_Valuable_Person]', 'F') IS NOT NULL
    ALTER TABLE [dbo].[Valuables] DROP CONSTRAINT [FK_Valuable_Person];
GO

-- --------------------------------------------------
-- Dropping existing tables
-- --------------------------------------------------

IF OBJECT_ID(N'[dbo].[People]', 'U') IS NOT NULL
    DROP TABLE [dbo].[People];
GO
IF OBJECT_ID(N'[dbo].[Valuables]', 'U') IS NOT NULL
    DROP TABLE [dbo].[Valuables];
GO

-- --------------------------------------------------
-- Creating all tables
-- --------------------------------------------------

-- Creating table 'People'
CREATE TABLE [dbo].[People] (
    [ID] int IDENTITY(1,1) NOT NULL,
    [FirstName] nvarchar(50)  NOT NULL,
    [LastName] nvarchar(50)  NOT NULL
);
GO

-- Creating table 'Valuables'
CREATE TABLE [dbo].[Valuables] (
    [ID] int IDENTITY(1,1) NOT NULL,
    [Description] nvarchar(max)  NOT NULL,
    [HolderID] int  NULL
);
GO

-- --------------------------------------------------
-- Creating all PRIMARY KEY constraints
-- --------------------------------------------------

-- Creating primary key on [ID] in table 'People'
ALTER TABLE [dbo].[People]
ADD CONSTRAINT [PK_People]
    PRIMARY KEY CLUSTERED ([ID] ASC);
GO

-- Creating primary key on [ID] in table 'Valuables'
ALTER TABLE [dbo].[Valuables]
ADD CONSTRAINT [PK_Valuables]
    PRIMARY KEY CLUSTERED ([ID] ASC);
GO

-- --------------------------------------------------
-- Creating all FOREIGN KEY constraints
-- --------------------------------------------------

-- Creating foreign key on [HolderID] in table 'Valuables'
ALTER TABLE [dbo].[Valuables]
ADD CONSTRAINT [FK_Valuable_Person]
    FOREIGN KEY ([HolderID])
    REFERENCES [dbo].[People]
        ([ID])
    ON DELETE NO ACTION ON UPDATE NO ACTION;

-- Creating non-clustered index for FOREIGN KEY 'FK_Valuable_Person'
CREATE INDEX [IX_FK_Valuable_Person]
ON [dbo].[Valuables]
    ([HolderID]);
GO

-- --------------------------------------------------
-- Script has ended
-- --------------------------------------------------

If your new to Entity Framework this will definitely sound alien, but fear not, I’ll shortly describe what I think is the minimum information necessary to make sense of it all.

First, what is Entity Framework, what’s its purpose?

It is an ORM (object relational mapper), which aims at providing an automated way of getting your relational data (the data you have stored in the database) to objects you use in your code, and vice-versa. And to achieve that you need to have a mapping that describes how the properties in your objects relate to the particular columns in the corresponding tables in your database. For example you have a Person class in your code with two strings, FirstName and LastName, and a table also named Person with two nvarchar columns with Name, and Surname. Your mapping will describe that FirstName should be “synched” with Name and LastName with “Surname”.

That’s what ORM’s are about. The nice thing about EF, is that you have the notion of Entity. In EF the mapping is between the Entities and the Tables in the database, which is nice because there are situations where it might be better for you if your model classes aren’t a perfect reflection of your database tables. (As an exercise think how you’d represent a many-to-many relationship in a relational database and how you’d represent it in an OO language). And the reason why this is so nice will become more obvious when you know how to use your own POCOs, but that’s later in the text.

So in EF, there are entities and a mapping between them and the DB. Entities can have Scalar properties (which you can think of normal properties, like a Name string) and Navigation properties, which represent relationships between entities. For example if you have an Entity that represents a Book, and that Book has an Owner (which is represented by an entity Person), Owner would be a Navigation property (btw, in the DB this would be represented by having the Book table have a OwnerID column which is a Foreign Key to Person). Navigation properties can have different multiplicities: 0..1, 1, or * (which means many; also probably 1..* but I’m feeling too lazy to check).

The entities and their relationships (that are translated to navigation properties) are often referred to as Conceptual Model, but I’ve heard people call it Object model too, but I’m pretty sure conceptual model is the right term.

The really nice thing about EF is that in Visual Studio 2010 you can auto generate the model from the database  metadata. You can also do it the other way around: create a conceptual model and then ask for the database schema to be generated (although this option is kind of hidden, ask me about it if you are curious about it).

If you want to have a look at how the Conceptual Model and Mappings are represented just open the EF’s edmx files in a XML editor and have a look.

The last important concept is the ObjectContext. To understand its importance bear with me through this imaginary scenario.

You get a collection of Books (that were gotten for you by EF [if you’re wondering how, don’t, it’s not important for you to get this part]), you decide to change the Title of one of them, you do it… and now what? You have the mappings and all, but how will that be (automatically) translated into an Update to your DB?

It’s the ObjectContext’s responsibility to do that, to figure out that the entity was changed and that that should be translated into an Update to the corresponding row in the Books table in the database. [This is a ridiculously simplistic description, but I think it’s sufficient]

The way ObjectContext does this varies if you use the auto generate feature or if you use POCOs. If you use the auto generate feature (this is the default) you get classes that represent the entities in your conceptual model and that inherit from EntityObject. These classes have logic that notify the ObjectContext of the changes that are done to them. If you use POCOs the way that change tracking works is by storing a copy of your object and when you decide to commit your changes the ObjectContext will compare the new version of your objects with the one it had when they were created (the metaphor is of a Snapshot that is taken at creation time and at commit time, you compare both and then do the right thing so that the DB gets “synched” with your objects).

Ok, now for the reason of this post: how to use your own model classes (POCOs) and Entity Framework. Baby step by baby step.

Step One: Get a database to try this, here’s the DDL for the one I used in this simple example, just open SQL Management Studio and paste it to a new query (or just use your favorite way of creating the database). [I’m using SQLServer 2008 Express, and Management Studio 2008 Express]

The database has two tables: Person and Valuable (the idea is that you can store People and Valuables and who holds those valuables, so 2 tables, and a foreign key):

Table Person:

ID, FirstName, LastName

ID is primary Key

Table Valuable:

ID, Description, OwnerID

ID is primary key

OwnerID is Foreign Key to Person.ID (can be null)

The DDL:

-- --------------------------------------------------
-- Entity Designer DDL Script for SQL Server 2005, 2008, and Azure
-- --------------------------------------------------
-- Date Created: 05/06/2011 15:27:10
-- Generated from EDMX file: ...\Lends.edmx
-- --------------------------------------------------

SET QUOTED_IDENTIFIER OFF;
GO
USE [Lends];
GO
IF SCHEMA_ID(N'dbo') IS NULL EXECUTE(N'CREATE SCHEMA [dbo]');
GO

-- --------------------------------------------------
-- Dropping existing FOREIGN KEY constraints
-- --------------------------------------------------

IF OBJECT_ID(N'[dbo].[FK_Valuable_Person]', 'F') IS NOT NULL
    ALTER TABLE [dbo].[Valuables] DROP CONSTRAINT [FK_Valuable_Person];
GO

-- --------------------------------------------------
-- Dropping existing tables
-- --------------------------------------------------

IF OBJECT_ID(N'[dbo].[People]', 'U') IS NOT NULL
    DROP TABLE [dbo].[People];
GO
IF OBJECT_ID(N'[dbo].[Valuables]', 'U') IS NOT NULL
    DROP TABLE [dbo].[Valuables];
GO

-- --------------------------------------------------
-- Creating all tables
-- --------------------------------------------------

-- Creating table 'People'
CREATE TABLE [dbo].[People] (
    [ID] int IDENTITY(1,1) NOT NULL,
    [FirstName] nvarchar(50)  NOT NULL,
    [LastName] nvarchar(50)  NOT NULL
);
GO

-- Creating table 'Valuables'
CREATE TABLE [dbo].[Valuables] (
    [ID] int IDENTITY(1,1) NOT NULL,
    [Description] nvarchar(max)  NOT NULL,
    [HolderID] int  NULL
);
GO

-- --------------------------------------------------
-- Creating all PRIMARY KEY constraints
-- --------------------------------------------------

-- Creating primary key on [ID] in table 'People'
ALTER TABLE [dbo].[People]
ADD CONSTRAINT [PK_People]
    PRIMARY KEY CLUSTERED ([ID] ASC);
GO

-- Creating primary key on [ID] in table 'Valuables'
ALTER TABLE [dbo].[Valuables]
ADD CONSTRAINT [PK_Valuables]
    PRIMARY KEY CLUSTERED ([ID] ASC);
GO

-- --------------------------------------------------
-- Creating all FOREIGN KEY constraints
-- --------------------------------------------------

-- Creating foreign key on [HolderID] in table 'Valuables'
ALTER TABLE [dbo].[Valuables]
ADD CONSTRAINT [FK_Valuable_Person1]
    FOREIGN KEY ([HolderID])
    REFERENCES [dbo].[People]
        ([ID])
    ON DELETE NO ACTION ON UPDATE NO ACTION;

-- Creating non-clustered index for FOREIGN KEY 'FK_Valuable_Person1'
CREATE INDEX [IX_FK_Valuable_Person1]
ON [dbo].[Valuables]
    ([HolderID]);
GO

-- --------------------------------------------------
-- Script has ended
-- --------------------------------------------------

Step Two: Open Visual Studio 2010, File->New Project->Console Application (because we want to keep it simple).

Step Three: Add the EF4 model:

(I named it Lends)

Click Add:

Generate from database, click Next:

Choose the appropriate data connection for the database you created in step one, change the name of the connection string if you want (I left the default: LendsEnitites), click Next:

Select the tables, and if you are from a non-speaking English country like me, you don’t get the “Pluralize or singularize generated object names” selected by default. Because our DB has English names select it. This is a nice feature because it names the EntitySets using the plural form of the Entity names. For example, the entity Person will be stored in an EntitySet named People (yes, People, its smart, it didn’t name it Persons, although I think that’s also correct). It’s just a nice feature, don’t worry too much about it.

Click Finish:

Here’s the view of your conceptual model. The rounded boxes are the entities, the Properties are the Scalar properties and the Navigation properties are … well the Navigation properties. The line between the two entities is the Relationship that defines the navigation properties.

I’m going to change the name of the Valuable navigation property from Person to Holder, because that makes more sense to me (and just because I can, and to illustrate that has an effect on your POCO class):

Now I’m going to turn off the auto generate feature (which is what happens by default, you get classes that represent your entities and that inherit from EntityObject) because this post is not about that, it is about using your classes (not generated code) as the model.

Be sure that the designer window is selected, to do this click anywhere in it, and then go to properties and change the “Code Generation Strategy” from Default to None:

Now we just have to create the class that will be our ObjectContext and our model classes (the POCOs).

There are some things you have to know about the class that will have the role of being the ObjectContext:

1. It has to inherit from ObjectContext (the namespace is System.Data.Objects)
2. It has to call base to initialize in the constructor, I recommend you use this overload of the base constructor: base(“name=ConnectionStringName”, “EntityContainerName”)
1. You can check the name of the connection string at App.config, and the EntityContainerName in the conceptual model properties in the designer
2. In the constructor turn on LazyLoading (LazyLoading just makes it so that when you use the object context to get, for example a Person, it doesn’t automatically get all the Valuables that are associated with that Person, I didn’t try it with it off, so bear with me, and usually you’ll want to use this for performance reasons anyway)
3. It has to have a ObjectSet<T> property for each type of entity, where T is your POCO class

Here’s the class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Objects;

namespace UsingEF4WithPOCOsReloaded
{
    class LendsObjectContext : ObjectContext
    {
        public LendsObjectContext()
            : base("name=LendsEntities", "LendsEntities")
        {
            this.ContextOptions.LazyLoadingEnabled = true;
        }

        private ObjectSet _people;
        public ObjectSet People
        {
            get
            {
                return _people ?? (_people = CreateObjectSet());
            }
        }

        private ObjectSet _valuables;
        public ObjectSet Valuables
        {
            get
            {
                return _valuables ?? (_valuables = CreateObjectSet());
            }
        }
    }
}

Just in case you don’t know, the ?? operator returns the first non-null value.

Now our model classes themselves:

Some notes:

1. They have to have the same name as the corresponding entities in the conceptual model
2. The have to have properties with exactly the same name as the scalar properties of the corresponding entity in the conceptual model
   1. Don’t mess this up, you’ll only get notified (via exceptions) at runtime
3. Have ICollection<T> properties for the relations that have more than multiplicity of one (for example, in our case a Person can have several Valuables associated with him/her)
4. Have the corresponding POCO property for 0/0..1/1 multiplicity relationships (for example, a valuable has only one Holder).

Here are the POCO classes for the Person and Valuable:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace UsingEF4WithPOCOsReloaded
{
    public class Person
    {
        public Person()
        {
            Valuables = new List();
        }

        public int ID { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public ICollection Valuables { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace UsingEF4WithPOCOsReloaded
{
    public class Valuable
    {
        public int ID { get; set; }
        public string Description { get; set; }
        public int HolderID { get; set; }
        public Person Holder { get; set; }
    }
}

Always double check the name of the properties, they have to be exactly the same as in the conceptual model.

And finally here’s my main class, it lists all People and their valuables, and ask you to to insert the data for a person and a valuable. If that person already exists that valuable is associated with him/her, and if that valuable already exists it gets associated with the person you entered:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace UsingEF4WithPOCOsReloaded
{
    class Program
    {
        static void Main(string[] args)
        {
            using (LendsObjectContext context = new LendsObjectContext())
            {
                foreach (Person person in context.People)
                {
                    Console.WriteLine("Person: {0}, {1} holds the following items: ", person.LastName, person.FirstName);
                    //Handling Lazy Loading: if you don't do this with 
                    //Lazy Loading enabled, the Valuables collections (that is linked by EF to 
                    //a navigation property) would be empty
                    context.LoadProperty(person, p => p.Valuables);
                    if (person.Valuables.Count == 0)
                    {
                        Console.WriteLine(" None");
                    }
                    else
                    {
                        foreach (Valuable valuable in person.Valuables)
                        {
                            Console.WriteLine(" -{0}", valuable.Description);
                        }
                    }
                    //By the way, this scenario is what is described as the N+1 problem when performance is mentioned in the context of ORMs
                    //it's N+1 because you have 1 query for Person and N queries for the Valuables
                    //The best way to deal with this is to use Stored Procedures (not mentioned in this post)
                }

                Console.WriteLine();
                Console.WriteLine("Add a new Person/Valuable:");
                Console.Write("First Name: ");
                string firstName = Console.ReadLine();
                Console.Write("Last Name: ");
                string lastName = Console.ReadLine();
                Console.Write("Valuable's Description: ");
                string valuableDescription = Console.ReadLine();

                var personQuery = from p in context.People
                                  where (p.FirstName == firstName && p.LastName == lastName)
                                  select p;

                Person holder;
                if (personQuery.Count() == 0)
                {
                    holder = new Person();
                    holder.FirstName = firstName;
                    holder.LastName = lastName;
                    context.People.AddObject(holder);
                }
                else
                {
                    holder = personQuery.First();
                }

                var valuableQuery = from v in context.Valuables
                                    where v.Description == valuableDescription
                                    select v;
                Valuable item;
                if (valuableQuery.Count() == 0)
                {
                    item = new Valuable();
                    item.Description = valuableDescription;
                    context.Valuables.AddObject(item);
                }
                else
                {
                    item = valuableQuery.First();
                }

                item.Holder = holder;                
                context.SaveChanges();
            }


        }        
    }
}

Disclaimer: this code is an insult and a mockery of best practices, it is only to illustrate how to use EF4 with POCOs, you really shouldn’t copy&paste it and use it in a production environment.

So, imagine this, you are a more or less experienced developer, but you have never developed in ASP. Someone asks you to lend a hand in an ASP project. You think, I feel pretty confident about doing web development, how hard can it be? Well, knowing this now, I can say this: harder than it should.

If you had to enumerate what you had to do before you starting something like this, it would probably look a bit like this:

1. Install a web server that can serve ASP pages. Internet Information Server (IIS) is really the only choice here.
2. Install ASP in IIS. IIS does not support ASP out of the box, you have to install it
3. Get a copy of the source code and put it running on your local machine
4. Start developing

Sounds pretty easy huh? Well it should, however for me it was not (it never is, disagree? read this).

Let us start by (1). Installing IIS. The preferred way to get IIS running in your machine nowadays is to use Microsoft Web Platform Installer (WPI). If you do not know what I am talking about, check it out, it is really nice (if it is works in your machine).

By the way, I am using a Windows 7 Professional 64Bit.

Here is what happened, I would start WPI and choose Web Platform and Web Server. Actually I chose the customize option and realized I could install ASP from WPI, so I would get 1 & 2 at the same time. At that time I thought, man this WPI is really nice.

However… as soon I clicked the Install button… tragedy happened…

It would not install a thing, everything would throw an error. I do not actually recall the exact error, or what was in the log (update: I had this in my browser search history: web platform installer Unattended setup returned ‘-2147467259′; and this one: web platform installer download manager error), I do know that I eventually found out why it was throwing all those errors, my TrustedInstaller.exe was missing. The process of finding out this was happening because TrustedInstaller was missing was not obvious at all. Making a long story short, I discovered it was missing when I tried to do run SFC (System file checker) and got another error (sorry this one I did not really wrote down, but it is easy to provoke if you really want to, just delete TrustedInstaller and then try to run SFC )

Oh, and just another symptom that a missing TrustedInstaller will cause: if you go to Control Panel->Programs->Turn Windows features On Off you’ll get an empty list.

By the way, you should have your TrustedInstaller.exe file in C:\Windows\servicing.

I still do not know for sure how it got deleted, but it turns out that Avast antivirus might sometimes delete it. I do use Avast so, that might have been it…

So now what? You have a pretty important system file missing, what do you do? Some people would just go about formatting their pc and reinstalling everything they need. Some are a bit more organized and they keep a clean image file of their system that they have created after a fresh installation.

I am neither of these people. I do not keep an image of a fresh install nor am I willing to format my PC every time something like this happens.

I do not know if you know this but you can access individual files from your Windows installation disk. Here’s how you do it: download 7-Zip file manager, then insert your Windows DVD and browse to sources/install.wim. Use 7-Zip to open it.

Inside install.wim you will find a bunch of folders and a file named 1.xml. I’d advise you to open it in Internet Explorer if you do not have any program that can automatically indent it for you (it has no line breaks). Look for the <Image Index=”x”> tag that contains a child element named ‘NAME’ that corresponds to your version of Windows. In my case it was <NAME>Windows 7 PROFESSIONAL</NAME> inside <IMAGE INDEX=”3“> meaning that the files for my installation are under the folder named 3.

Now you just have to browse through your corresponding folder and extract the file you need. In this case TrustedInstaller.exe under Windows\servicing.

If you have never done something like this before, you will be surprised if you try to copy that file to your installation of Windows. You will be presented with a “Permission denied” error message. You have to take ownership of that folder (using takeown) and give permissions to it before you can copy the file there.

Ok! After all this I was able to install IIS 7.5 and ASP using the WPI! What should have happened here after the install had finished, is me creating a simple ASP file, putting it under C:\inetput\wwwroot\ and then opening http://localhost/helloworld.asp and seeing magic happen. This did not work…

Although I had used the customize option in WPI and chosen to install IIS and ASP apparently, regarding ASP, nothing happened. I do not actually know for sure if ASP was installed by WPI or not, but I know that it was not ready to be used in IIS. To make it work you have to go to Control Panel->Programs->Turn Windows Features On Off and choose: Internet Information Services->World Wide Web Services->Application Development Features->ASP.

Now helloworld.asp works!

For making the real project work copy it to C:\Inetput\wwwroot\YourProject. Now, I am not entirely sure, but I think it did not work at that time, you have to open a console as an administrator and takeown of C:\Inetput\wwwroot\YourProject like this: takeown /f C:\Inetput\wwwroot\YourProject -r. And then edit the permissions using Explorer by right-clicking in C:\Inetput\wwwroot\YourProject, and then give permissions to your user and IIS_USRS.

The project my friend sent me had some errors, but I could not see much when I tried to run it. What I got from the browser was a “friendly” error message that hid the error details from me. Actually IIS does not provide that information at all. To get ASP errors to be displayed in Internet Explorer you have to configure IIS to display them: Open IIS manager, go to ASP->Compilations->Debugging Properties and enable Scrip Error Message.

Then disable Friendly Error Messages in IE by going to Tools->Internet Options->Browsing and then disable Show Friendly HTTP Error Messages.

But the story does not end here… The site was really old and was accessing a Microsoft Access Database. When I tried to run it I got this message:

Microsoft OLE DB Provider for ODBC Drivers error ’80004005′

[Microsoft][ODBC Driver Manager] Data source name not found and no default driver specified

Making a long story short (again!), there aren’t any 64-Bit drivers for Access. You can try to install this, but beware, I installed the 32 bit version by mistake and then I could not install the 64 bit version. I tried uninstalling the 32 bit installation and then installing the 64 bit one, just to get a message from the 64 bit version prompting me to uninstall the 32 bit version that I had already uninstalled!

But really, the easiest way is not that one (you probably have to have Access installed for this to work. I did, so I cannot really tell if this would work otherwise). Change IIS’s Application Pool to run in 32 Bit mode. To do this open IIS manager, then go to Application Pools; to your relevant application pool, select it and in the right pane select Advanced Settings… and in (General) set Enable 32-Bit Applications to True. And now you are done! At least I was.

So… how hard can it be? Harder than I had imagined, but then again nothing that should strike you as being out of the ordinary if you have done this kind of thing a couple of times. The truth is, it really rarely works at the first try.