RunTime is a FREE stopwatch app for Windows Phone 7.
The stopwatch continues to run in the background even if you lock the screen or leave the app.
The app allows saving laps.
The app shows both the main stopwatch timer as well as the current lap timer.

You can download the app by scanning the following QR code with Bing Vision (Press the Search button on your WP, press “Vision” then point the camera at the scree and follow the link):

Otherwise you can download it by visit the following link:

http://www.windowsphone.com/en-us/apps/e9e7b11c-242e-4d49-b4a9-c828b40f8d2d

Here are a few screenshots:

I hope you like the app! Enjoy

Making all the changes of the auto-generated code in order to test it proved to be a harder task that I initially imagined.

This article summarises my findings and for getting the system ready for testing.

First of all, here is a list of links that helped me:

Testing out the Entity Framework WCF RIA Services Domain Service

WCF RIA Services Part 8 – Testing and Debugging

Testability and Entity Framework 4.0

However, none of these resources fully describe a working solution.

Here is how I finally got it working:

• Step 1
• Create an IUnitOfWork interface that will abstract the ObjectContext object used by your domain Service
• Create additional operations the ObjectContext exposes as extension methods (e.g. AttachAsModified<TEntity>)
• Step 2
• Create an InMemoryUnitOfWork inheriting from IUnitOfWork (used for testing)
• Create an InMemoryIObjectSet<T> inheriting from IObjectSet<T> (used for testing)
• Step 3
• Create a testing base class EFTestBaseClass for putting all the things together
• Create a particular TestHelperClass for testing a particular test
• There are additional important tweeks I will highlight in bold during the example.

An automatically generated Domain Service for manipulating it will look something like:

public class DomainService1 : LinqToEntitiesDomainService<NewTechCodeTestingEntities>
    {
        ...
    }

All the methods we are interested in testing will be hosted in this class. But instantiating it for testing will result in all operations being executed against the database. In order to avoid this situation we will have to somehow decouple this class form the EF.

(Step1)

First of we have to create the previously mentioned IUnitOfWork:

public interface IUnitOfWork
    {
        IObjectSet<Book> Books { get; }

        ObjectStateManager ObjectStateManager { get; }
        int SaveChanges();
    }

This class abstracts the NewTechCodeTestingEntities.

This way we can create a special constructor for the Domain Service that we can use during testing:

public class DomainService1 : LinqToEntitiesDomainService<NewTechCodeTestingEntities>
    {
        new private readonly IUnitOfWork ObjectContext;

        public DomainService1()
        {
            this.ObjectContext = base.ObjectContext;
        }

        public DomainService1(IUnitOfWork unitOfWork)
        {
            this.ObjectContext = unitOfWork;
        }

        ...
    }

It’s important to notice how we created a new ObjectContext filed by using the new operator which either defaults to the base class ObjectContext (used for the production code when you call the parameterless contructor) or sets it to a specified one we create during  testing.

An important thing to notice is the use of IObjectSet<Book> instead of ObjectSet<Book>.

The auto-generated file exposes the object in ObjectSet<T> collections.

In order to use the current  approach you will have to manually change All the ObjectSet<T> declarations to IObjectSet<T> (Find and replace should do the trick in seconds)

The second thing you will have to do is make the NewTechCodeTestingEntities implement the IUnitOfWork.

The code will therefore look something like this:

public partial class NewTechCodeTestingEntities : ObjectContext, IUnitOfWork
    {
        ...
    }

Notice that these two steps (changing the collection declaration and inheriting from the IUnitOfWork) will have to be performed each time you update your EF model. I find this approach acceptable mostly because it is the only way I got the whole system to work.

Creating the extension methods are needed for keeping the auto generated code working. The only method I needed was AttachAsModified<T>:

 public static class Extension
    {
        public static void AttachAsModified<TEntity>(this IObjectSet<TEntity> objectSet, TEntity current, object original) where TEntity : class
        {
            throw new NotImplementedException();
        }
    }

(Step 2)

The following two classes were created for keeping the testing data:

public class InMemoryUnitOfWork : IUnitOfWork
    {
        public IObjectSet<Book> Books
        {
            get;
            set;
        }

        public ObjectStateManager ObjectStateManager
        {
            get;
            set;
        }

        public int SaveChanges()
        {
            throw new NotImplementedException();
        }
    }

and

public class InMemoryIObjectSet<T> : IObjectSet<T> where T : class
    {
        public InMemoryIObjectSet()
            : this(Enumerable.Empty<T>())
        {
        }

        public InMemoryIObjectSet(IEnumerable<T> entities)
        {
            _set = new HashSet<T>();
            foreach (var entity in entities)
            {
                _set.Add(entity);
            }
            _queryableSet = _set.AsQueryable();
        }
        public void AddObject(T entity)
        {
            _set.Add(entity);
        }
        public void Attach(T entity)
        {
            _set.Add(entity);
        }
        public void DeleteObject(T entity)
        {
            _set.Remove(entity);
        }
        public void Detach(T entity)
        {
            _set.Remove(entity);
        }
        public Type ElementType
        {
            get { return _queryableSet.ElementType; }
        }
        public Expression Expression
        {
            get { return _queryableSet.Expression; }
        }

        public IQueryProvider Provider
        {
            get { return _queryableSet.Provider; }
        }

        public IEnumerator<T> GetEnumerator()
        {
            return _set.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        readonly HashSet<T> _set;

        readonly IQueryable<T> _queryableSet;
    }

If you are interested in finding more about these classes check the links at the beginning of the article.

(Step 3)

 public class EFTestBaseClass
    {
        public EFTestBaseClass()
        {
            this.unitOfWork = new InMemoryUnitOfWork();
            this.controller = new DomainService1(unitOfWork);
        }

        protected InMemoryUnitOfWork unitOfWork;
        protected DomainService1 controller;
    }

and

 public class BooksTestHelper : EFTestBaseClass
    {
        protected IList<Book> books;

        protected InMemoryIObjectSet<Book> repositoryBooks;

        public BooksTestHelper()
        {
            this.PopulateCatalogueMaster();
        }

        public void PopulateCatalogueMaster()
        {
            this.books = CreateCatalogueMasters().ToList();
            this.repositoryBooks = new InMemoryIObjectSet<Book>(this.books);
            this.unitOfWork.Books = repositoryBooks;
        }

        public static IEnumerable<Book> CreateCatalogueMasters()
        {
            yield return new Book()
            {
                Id = 1,
                Title = "Madame Bovary",
                Author = "Gustave Flauber"
            };
            yield return new Book()
            {
                Id = 2,
                Title = "The Lady of the Camellias",
                Author = "Alexandre Dumas, fils"
            };
            yield return new Book()
            {
                Id = 3,
                Title = "Notre Dame de Paris",
                Author = "Victor Hugo"
            };
        }
    }

allows us to create the following test:

[TestClass]
    public class BooksTest : BooksTestHelper
    {
        [TestMethod]
        public void GetBooks()
        {
            var books = controller.GetBooks();
            // insert test here
        }
    }

The tweeks that helped me get the system working were the observations highlighted in green which on top of the knowledge you get by reading the introduction articles should help you in testing your application.

Grab a piece! is an entertaining puzzle game with configurable levels and different game modes.

The trial offers all the functionalities of the game so you can experience the gameplay in all game modes and difficulty levels. It contains two puzzle image packs of seven images each.

The paid version contains five puzzle image packs, the ability to use pictures from the phone’s media library and also pictures captured with your camera. The paid version is ad free, so you have more space for your puzzle pieces and no distractions. Transform your best pictures into puzzles and start have fun arranging their pieces!

The application can be downloaded from the Zune marketplace by following this link:

Here are some screenshots:

Here are two videos about the game:

Presentation

Managing personal puzzles

Enjoy!

More details soon.

More details soon!

I’m proud to present my first personal app for Windows Phone 7.

tell me the color!  is a productivity tool for color-blind people to help them distinguish the color of the objects the camera is looking at.

The application can be downloaded for free from the Zune marketplace by following this link:

Here are some screenshot of the app:

As I’ve tested it only in the emulator, in case you get the chance to test it on a device let me know how it works.

Enjoy!

• Isolated Storage Explorer – command line tool for exploring Isolated Storage files and folder structure; Can be found in

C:\Program files (x86)\Microsoft SDK\Windows Phone\v7.1\Tools\isolatedStorageExplorerTool\ISETool.exe

• LINQ to SQL, User Data and OData
• Reworked WebClient that runs on the originated thread instead of the UI thread
• Socket support, TCP and UDP
• Local Tile API, MultiTile and Back of Tile support.
• Windows Phone Marketplace Test Kit http://msdn.microsoft.com/en-us/library/hh394032(VS.92).aspx  is a great SDK component which allows you to run the markeplace verification tests before actually submitting it to the Marketplace

Examples:

1. There are 4 men who want to cross a bridge. They all begin on the same side. You have 17 minutes to get all of them across to the other side. It is night. There is one flashlight. A maximum of two people can cross at one time. Any party, who crosses, either 1 or 2 people, must have the flashlight with them. The flashlight must be walked back and forth; it cannot be thrown, etc. Each man walks at a different speed. A pair must walk together at the rate of the slower man’s pace. Man 1: 1 minute to cross; Man 2: 2 minutes to cross; Man 3: 5 minutes to cross; Man 4: 10 minutes to cross
2. Try to carry Wolf, Goat and Cabbage across a river in a boat. You can take on the boat with you only one of them in each trip. If you leave Wolf and Goat on the same bank, Wolf will eat Goat. If you leave Goat and Cabbage on the same bank, Goat will eat Cabbage. Although, they will never eat one another while you stay with them. Make sure they all safely reach the other river bank.
3. Once upon a time a farmer went to market and purchased a fox, a goose, and a bag of beans. On his way home, the farmer came to the bank of a river and hired a boat. But in crossing the river by boat, the farmer could carry only himself and a single one of his purchases – the fox, the goose, or the bag of the beans.If left alone, the fox would eat the goose, and the goose would eat the beans.The farmer’s challenge was to carry himself and his purchases to the far bank of the river, leaving each purchase intact. How did he do it?
4. In the missionaries and cannibals problem, three missionaries and three cannibals must cross a river using a boat which can carry at most two people, under the constraint that, for both banks, if there are missionaries present on the bank, they cannot be outnumbered by cannibals (if they were, the cannibals would eat the missionaries.) The boat cannot cross the river by itself with no people on board.

The app is going to be a turn-based Puzzle game, called Puzzle Match, that can be  played in either singleplayer mode or multiplayer, over a WI-FI network.

The current requirements I defined for the game are:

• Easy to create a new game, with as little user intervention as possible
• Easy to attend a live game
• The ability to use personal photos as puzzles, either from the gallery, from the camera or from an URL