Continue reading »]]> I have been incredibly busy the last few months and some of the things I have been working on are applications for Windows Phone 7.

Today saw the publication of the first of my applications to the Windows Phone 7 marketplace, Christmas Presents.

Christmas Presents is a simple but effective application that will allow you to manage all of your Christmas shopping, ensuring that you stay on top of which presents you need to buy, who they are for and how much you are spending.

Currently features include

- A summary including the overall budget, remaining spend and a countdown to Christmas.
- Individual budgets for each person.
- Mark presents as purchsed and then wrapped.
- Shopping list displaying all presents that haven’t been purchased yet.
- Currency automatically matches your phone settings.

If you have the Zune client installed you can see the Christmas Presents app page here.

Below are some screenshots of the application.  Please comments and let me know that you think and what features you would like to see included in future versions.

Summary Screen

People List

Person Details

Shopping List

Again, please comment and let me know what you think and what features you would like to see in future versions.

Continue reading »]]> After reading Carl Dickinson’s post on Mando Group Labs about the Bing Silverlight Control, I wanted to give it a try myself.

I decided to set about using the Bing Silverlight control to display available hotels from LateRooms.com.  LateRooms.com have an affiliate scheme that exposes the availability of hotels via XML feeds (you do need an affiliate ID to use the feeds but this could easily be replaced by any other similar feed).

You can view the sample app I have created here (note: LateRooms has mostly UK hotels so probably best trying a UK location, e.g. “Southport UK”). 

To create the app I create added four controls to my page;  

• Bing Silverlight Control – This is obviously the main focus of the app.
• A text box and a button to accept a location from the user and start the request to get the hotels.
• A list box to display a picture, the name and the first line of the address for each of the hotels.

Once the user enters a location into the text box and clicks the button the following happens;

• The location entered by the user is sent to the Bing Geocode web service and providing it can find a match it returns the lattitude and longitude for the location.
• This map is then centred on this location.
• Finally the newly returned coordinates are used to get a list of available hotels from the LateRooms XML feed. This list is then iterated through and a pin for each hotel is added to the map and the list is then bound to the list box.

Finally I added an event handler to the selection changed event of the list box to re-centre the map on the coordinates of the selected hotel.

There is plently more that could be done with this app, not least making the UI a little more attractive, but I wanted to just get a feel of how easy it was to implement some basic Bing maps functionality in Silverlight.

If you are interested to see the source code to the application let me know and I can post it.  Right now I am off to try some more experiments!

Don’t forget if you liked this, subscribe to my RSS feed and / or follow my Twitter (links at the top of the page).

Technorati Tags: bing, Silverlight

Continue reading »]]> Recently I have been working on an MVC site using the Entity Framework. 

I have some related entities in my EF model, as show below in the form of “Reader” and “Category”, and the relationship between them, i.e. many to many.

When it came to proucing a view and action to perofrm the Create Reader action, I was somewhat puzzled as to how I could allow the user to select one or more categories for a reader. 

I started by having a view model that contained a list of all possible categories and then looping around these in my view and writing a check box out for each one.  When the form was submitted I looked through the form collection to find if any of the category check boxes had been selected.  I didn’t like this one bit and so I set out to find a cleaner way of carrying it out.

After some (quite a lot actually) searching, I stumbled accross the MultiSelectList type, which I could use in my ViewModel and then allow the default model binding to step in and do the leg work for me Great!

So, I created a view model, a simplified version of which you can see below;

    public class ReaderCreateViewModel : CustomViewModelBase
    {

        public ReaderCreateViewModel()
        {
            ReaderDetails = new Reader();
            CategoriesList = GetCategories(null);
        }

        public Reader ReaderDetails { get; set; }
        public MultiSelectList CategoriesList { get; private set; }
        public int[] SelectedCategories { get; set; }

        public MultiSelectList GetCategories(int[] selectedValues)
        {
            var te = new myEntities();
            List<Category> categories = te.Categories.ToList();
            return new MultiSelectList(categories, “id”, “Name”, selectedValues);
        }
    }

 As you can see from the code above, the view model contains my Reader entity, a list of type MultiSelectList, which is a list of available categories and an array of integers which represent the Id of any selected Categories.

Then to add a listbox to my view that will bind the MultiSelectList, I simply insert the following into my view.

            <p>
             <label for=”SelectedCategories”>Categories:</label>
        <%= Html.ListBox(“SelectedCategories”, Model.CategoriesList) %>
            </p>

Finally in my controller, I can simply check the SelectedItems object in my model for any selected Ids and add them to the Reader Categories list like this;

            if (model.SelectedCategories != null)
            {
                foreach (var selectedCat in model.SelectedCategories)
                {
                    int selectedCatId = selectedCat;
                    Category category = DataContext.Categories.Where(c => c.id                  == selectedCatId).FirstOrDefault();
                    reader.Categories.Add(category);
                }
            }

And that’s it.  Now there is probably a much better way of doing all or some of the above, but this worked perfectly for me when I needed it, so I hope it helps someone else out as well.  The final multi-select list box looked something like this;

Technorati Tags: ASP.NET MVC, Entity Framework, MVC

Continue reading »]]> If like me you are using ASP.NET MVC for some of your web applications these days and use MasterPages within them, then you may have come accross the need to pass ViewData to the MasterPage.  For example, this might be for a dynamically generated navigation bar.

When I first started using MVC, I simply passed the ViewData required for the MasterPage along with every action, but even with a small site, this was a lot of code replication.

To solve this problem, we can create an ApplicationController class which inherits from the Controller class we all know and love.  Your applications’ controllers then in turn simply inherit from this new ApplicationController.

Below is a simple example of an ApplicationController.

namespace MvcSite.Controllers
{
    public abstract class ApplicationController : Controller
    {
        private MyEntities _dataContext = new MyEntities();

        public MyEntities DataContext
        {
            get { return _dataContext; }
        }

        public ApplicationController()
        {
            ViewData["categories"] = DataContext.Categories.ToList();
        }

    }
}

Hope this helps someone else as well. Certainly removed a headache for me!

Technorati Tags: ASP.NET MVC

Continue reading »]]> Visual Studio 2010 and .Net 4.0 Beta 2 has now been released to members of MSDN, with a public download available from Wednesday.

Beta 2 brings many improvements to the table, including improvements in Sharepoint, WPF, ASP.NET, WinForms, as well as improvements to the core IDE and testing tools. I saw some of these IDE improvements at an event with Scott Gu in Manchester a couple of weeks ago and they look pretty cool.

Visual Studio now comes in several flavours, namely Premium, Professional and Ultimate and the good news is that TFS 2010 comes out of the box with all three.  Apparently it only takes 20 minutes to setup source control, bug and issue tracking and automated build with it.

Finally, another great piece of news is that this release also ships with a Go-live license, so this can be used for production projects if you wish

If you are a member of MSDN and want to download the beta now, you can get it from here.

For more information on the release visit Scott Gu’s blog where you he has started a series of posts on the new features in 2010 Beta 2.

Have any of you been using Beta 1? Will you be using Beta 2? What do you think of the way 2010 and .Net 4.0 are shaping up?

Technorati Tags: .NET 4.0, beta 2, visual studio 2010, vs2010

Continue reading »]]>

Title: Professional Refactoring in C# and ASP.Net

Publisher: Wrox

Author: Danijel Arsenovski

Even the most experienced developers can sometimes be found sat staring at their monitor trying to decide which way to implement a solution. Asking a fellow developer for input will probably result in more avenues to consider as opposed to narrowing down the initial choice. But all things considered if the end result meets the user’s requirements does it really matter which design choice we make?

Well……yes. The code will still need to be maintained and updated; this can be time consuming if the code is unstructured or messy. However with some refactoring techniques to follow it’s possible to make the right decisions during design and implementation and this book contains the techniques to help you make those decisions.

Why did I read this book?

I’ve read a couple of books on the subject of refactoring, these where mainly concerned with the business logic layer side of applications so I was interested in what this book had to say about refactoring ASP.Net.

First Impressions

The book starts with a good introduction of refactoring including its benefits and also spends some time “Debunking Common Misconceptions” (one or two I’ve firsthand experience of trying to dismiss) and “Smells”. This isn’t a scratch and sniff section but a way of identifying code that is a candidate for refactoring. Throughout the book Smells will be introduced along with ways to detect them, which refactoring technique to use to eliminate them and the rational for removing them.

The Introduction chapter includes an index of the Smells as well as Refactorings and Object-Orientated Design Principles so they can be quickly found and referenced. I found this to be really useful as I was working my way through the book. 

What’s Covered

In the words of the book;

“This book covers the refactoring techniques that will enable you to become more efficient and productive. You will be able to use this information to respond to change and improve the design of existing code”.

In my opinion this book does indeed go a long way to achieving the above statement.

The book covers the following areas;

• Assembling a refactoring toolkit
• Techniques for performing unit testing 
• Tips on refactoring to patterns
• Using refactoring to upgrade legacy C# and ASP.Net code
• Using method extraction to eliminate duplicated code
• Making code more simple and easier to understand
• OO theory and design patterns
• Methods for using LINQ and C# 3.0 enhancements

What I Liked?

I enjoyed the chapters on “LINQ and Other C# 3.0 Enhancements” and “Refactoring ASP.NET Applications” which I found very insightful and will be using some of these techniques in the future.

Most of this book is, obviously, based around Refactoring Techniques and these chapters are very well presented with good code examples. I like the way that the Smells and Refactorings are emphasised throughout the chapters as this reinforces the point being made as well as making the sections easier to locate when you want to reference them.

Although I have read about refactoring before I did enjoy reading through these chapters which reinforced what I had previously read and having the examples in C# was a real advantage as this is the language that I currently develop with.

What Could Be Better?

I’m a big advocate of Test Driven Development (TDD) and I think that this methodology is key when refactoring. Always having a number of tests for the code that you are refactoring allows you the confidence to alter the code knowing that if your change was to impact an area you weren’t expecting this would be highlighted to you with a failed test. Although this is mentioned in this book I think that this should have been given more emphasis.

The Final Verdict

All in all this was a good and worthwhile read and although I would not recommend relying on simply this book for all areas of knowledge of this subject (i.e. TDD), I would certainly recommend the book to my peers.

Technorati Tags: ASP.Net, book review, C#, refactoring, wrox

Continue reading »]]> Title: ASP.NET MVC 1.0 Problem – Design – Solution

Publisher: Wrox

Authors: Nick Beradi, Al Katawazi, Marco Bellinaso

It seems that recently every man and his dog have been talking about ASP.Net MVC and the many advantages it brings along with it.  I have to admit that, up until now, I have not really looked into it a great deal, except for watching a couple of sessions at last years MSDN Roadshow.  Anyway, I decided that it was about time I found out more about ASP.Net MVC and see if it really was worth all of the hype.

Why did I read THIS book?

The reason I chose this book was two fold – firstly, it claimed to give you a good grounding in using ASP.Net MVC to those with experience of ASP.Net Web Development.  Secondly, in the books’ own words it provided “solid, workable solutions to real work problems” (I was dubious about this claim….many books I have read have claimed to do this and failed miserably with the first couple of chapters).

First Impressions

Right from the very first chapter it starts off on the correct foot, giving an overview of the application you will create as you work through the book, that application being The Beer House, which is available for download as a starter kit.  The main attraction of this application to me was that it contained many of the features I often implement in my own applications, such as forums, article management and user profile / membership management.  The idea of reading a book that directly relates to my real-world programming was a big pull for me.

Thankfully, this book certainly does not try and force MVC down your throat as a must-use solution, instead giving an honest opinion that, yes MVC is very useful in many situations, but that in other situations, classic ASP.Net Web Forms may still be the more logical option.  This is a refreshing change from some of the other more self-righteous books I have had the des-pleasure of sampling where they simply see their subject matter and related methods as the only way to go.

What’s Covered?

I don’t think I can put the content of the book in better words that the book itself, so here are those very words;

All of the above is covered in ample detail and I really did find this book extremely useful when relating the MVC implementation with my tradition Web Forms methods.

I especially liked the fact that attention was paid to the design of the application you create.  Coming from a web design background I am often astounded by the lack of attention paid to this area and it was pleasing to see a chapter dedicated to this for the non-design minded developer.

The other thing I loved about this book was that as well as ensuring every detail was covered off when developing each solution for the Beer House application, the authors have made a clear effort to highlight when something more may be needed in different circumstances and provided sample code and examples where needed.

Source Code Problems

Probably the only bad thing I have to say about this book were the problems I had when attempting to get the source code to compile once I had downloaded it from the Wrox web site.  I think the main problem was that the code on the site was possibly an old version with several other versions kicking around the internet.  I am unsure as to which was the correct up-to-date copy.

However, all that said, with some tinkering, I did manage to get it to compile and what a lovely application it is.

The Final Verdict

I found this book to be an extremely concise and focused journey through ASP.Net MVC and a perfect introduction to the subject and I would highly recommend it to anybody who is looking for a good grounding in the subject.

This was also my first read of a book from the Problem – Design – Solution series from Wrox, and if the other books in the series are in a similar style, then I look forward to reading more as the straight forward style with real-world connections suited me down to the ground.  

You can find this book for sale on Amazon or from the Wiley web site.

Technorati Tags: ASP.Net, ASP.NET MVC, book review, C#, wrox

Continue reading »]]> Following up on my recent post about the improvements to the Entity Framework in .Net 4.0 this is the first in a series of posts examining some of the new features and showing you how to put some of them into practice.

In this post I am going to look at one of the most anticipated features, Model First.  In the first version of the Entity Framework, you took a pre-existing database and the tools would generate your entity model for you.  In v2.0, you now have the option of creating your entity model first and then generating your database DDL from your finished model.

To follow this tutorial you will need Visual Studio 2010 Beta 1, .Net Framework 4.0 Beta 1 installed, SQL 2005 or 2008 / SQL Express.

Please bear with me and let me know if there are any parts of this tutorial that are not completely clear.  I am new to writing these! So any comments welcome….

Creating your project and adding your blank entity model

Open Visual Studio 2010 and create a new Dynamic Data Entities Web Application project(you could another project type to host your entity model, such as an ASP.Net Web Application).

Once your project has been created add a new ADO.Net Entity Data Model to the project. 

You will then be asked about what the model should contain.  As with version 1 of the Entity Framework, you have two options, Generate from Database and Empty Model.  To a large extent, the latter was redundant in the first version of the framework, but with version 2 it becomes very useful.  Select Empty Model and click Finish.

Adding an entity and scalar properties to your model

You will now be presented with your empty model designer ready for you to add your entities.  Right click on the designer and select Add –> Entity…  For this example we will name our entity “Customer” and the entity set “Customers”.  This will create your Customer entity in the designer.

You will now need to add some properties to the entity.  You can do this by right clicking the entity and Add –> Scalar Property and then selecting the data type of the property. Do this and create two string scalar properties for Name and Email.

Adding complex types

You should now have a Customer entity with properties for the customer’s name and email address. A complex type is essentially a property that can contain sub properties.  To display this we are going to create one for the customer’s mailing address.

In your model browser, right click on the “Complex Types” folder and select Create Complex Type.  Rename this created type “Address”.  Now right click on the Address object you have created and select Add –> Scalar Property –> String.  Rename the created property “Line 1”.  Repeat this, adding properties for Line 2, Town, County, Post Code (you could use City, State, Zip if you are in the U.S. for example).

Once you have created your complex type, you can add this to your Customer entity by right clicking the entity and selecting Add –> Complex Property. If you name your property Address, then the property type should automatically be set to Address, which is what we have just created.  You can check this and alter the type via the properties of the complex property (that’s a lot of properties )

Create some additional entities

Once I had created my Customer entity, I then went through the same steps to create two additional entities for Order and Product. If you do this, then you should end up with something like below.

Adding entity associations

Now that we have our entities for Customer, Order and Product, we need to tell the model how the entities are associated.  For example, a customer will have related orders and an order will have related products.

To add our first association, right click the Customer entity and select Add –> Association. You will then be presented with the dialog shown below to actually define the association.  As you can see, the primary entity for this association is Customer which is related to Order with a multiplicity of one-to-many.  Here is where we also set the navigation properties which will allow us to access related entities.  So for example, the Customer entity will have a navigation property of “Orders”.  There is also a plain English description of the association you are about to create to ensure that you are creating it correctly.

Once you are happy click ok and the association will be shown on your model connecting the Customer and Order entities.

We now need to also create an association between the Order and Product entities using the same steps as above, but this time the properties of the association are slightly different as the multiplicity is many-to-many as show below.

Generating the database

Ok, so we have our model containing our entities.  Our entities have their properties and their associations, but we still do not have a database for our model to map to.  This is the bit I really like.  Right click on the model designer area and click “Generate Database Script From Model…”.

This will then open the standard database connection dialog we are all used to in Visual Studio. Add a connection, select your server and enter a name for your database (use a name that does not already exist, I called mine “ModelFirstTestDb”…..original I know!), then click OK.  You should then be prompted to create the database as seen below, so click Yes to create the database.

You should now see your new connection selected and the option to store the credentials in the web.config should be checked. Click next and the database schema scripts (DDL) will be generated for you and you will be presented with the generated script as below.  Take a minute to have a look through the DDL and see how it has created the tables and fields.  In the image below you can see the fields that have been generated to map to the complex type for the Customer address we created earlier.

Now we just need to click Finish and we will be warned that our existing mappings and store schema will be overwritten, click Yes to continue.

Execute your DDL

Now you need to take the generated script and execute it against your database.  The database itself will have been created, but in this beta version you still need to execute the scripts manually.  The ADO.Net team have indicated that this will not be the case in the final version.

Running your Dynamic Data Entities application

If you now open the Global.asax.cs file in your project and add the following line in the RegisterRoutes method, you should be able to run your application and see your new model and database in action;

DefaultModel.RegisterContext(typeof(Model1Container),new ContextConfiguration() { ScaffoldAllTables = true });

Technorati Tags: .net 4, ADO.NET, Entity Framework, tutorial, visual studio 2010

Continue reading »]]> So, I have my Windows 7 RC up and running and I am now itching to get hold of a beta of Visual Studio 2010.

I held off downloading the Virtual PC CTP ion order to wait for an installable version, but that seems to have been a long time coming.

The wait may be over this week though as a lot of rumours are going around that put the release of a beta within the TechEd timeframe (May 11 – May 15).

Fingers Crossed!

Have you tried the CTP yet? What did you think?

Technorati Tags: beta, visual studio 2010

Continue reading »]]> Odd title you are thinking??  Well, I have gotten to thinking that I should write a post when I publish a new web site for any of my clients, so that I can get comments and feedback from you all.

Lakemere Environmental Services are a domestic and commercial cleaning services company, who offer amongst other things wheelie bin cleaning (hence the title).

Their web site, which I have developed using Expression Web 2, went live recently.  It is written in ASP.Net / C#, has a SQL 2005 back end and uses ASP.Net Dynamic Data for the administration panel for updating news etc.  The web site also features basic WorldPay integration.  However, I am most pleased with the look and feel of this web site and the initial feedback from the client has been fantastic.  They have already had several new online orders roll in.

So, if you want to see the web site to check out the design, or you fancy getting some wheelie bin cleaning or commercial cleaning services for yourself, I can highly recommend Lakemere Environmental Services for the job.

Seriously though, shamless plug aside, please do leave a comment and let me know what you think.  I also have some more sites due to go live in the coming weeks and I will link to them as well.