LiveDB generic

using System;
using System.Collections.Generic;
using System.Linq;
using LiveDomain.Core;


namespace LiveDbFirstTest
{
    //My DomainModel
    [Serializable]
    public abstract class PersistentEntity
    {
        public Guid Id { get; set; }
    }
    [Serializable]
    public abstract class LocationEntity : PersistentEntity
    {
        public string Lat { get; set; }
        public string Lng { get; set; }
    }
    [Serializable]
    public class Tag : PersistentEntity
    {
        public string Name { get; set; }
    }
    [Serializable]
    public class Spot : LocationEntity
    {
        public string Name { get; set; }
        public IList<Tag> Tags { get; set; }

        public Spot()
        {
            this.Tags = new List<Tag>();
        }
    }

    //Model
    [Serializable]
    public class GenericModel : Model
    {
        public IDictionary<Guid, object> Entities { get; set; }

        public GenericModel()
        {
            this.Entities = new Dictionary<Guid, object>();
        }

        public T SaveOrUpdate<T>(T entity) where T : PersistentEntity
        {
            if(this.Entities.ContainsKey(entity.Id))
            {
                this.Entities[entity.Id] = entity;
            }
            else
            {
                this.Entities.Add(entity.Id, entity);
            }

            return entity;
        }

        public IEnumerable<T> GetAll<T>() where T : PersistentEntity
        {
            return this.Entities.Values.OfType<T>().ToList();
        }

        public IEnumerable<T> Find<T>(Func<T, bool> expression) where T : PersistentEntity
        {
            return this.Entities.Values.OfType<T>().Where(expression).ToList();
        }

        public T GetById<T>(Guid id) where T : PersistentEntity
        {
            return this.Entities.Values.OfType<T>().Single(p => p.Id == id);
        }

        public void Delete<T>(Guid id) where T : PersistentEntity
        {
            this.Entities.Remove(id);
        }

        public void Delete<T>(T entity) where T : PersistentEntity
        {
            this.Delete<T>(entity.Id);
        }
    }

    //Helpers for Commands
    public static class Commands
    {
        public static T SaveOrUpdate<T>(this Engine e, T entity)
            where T : PersistentEntity
        {
            var cmd = new GenericSaveCommand<T, GenericModel>(entity);
            return e.Execute(cmd) as T;
        }
        public static void Delete<T>(this Engine e, T entity)
            where T : PersistentEntity
        {
            var cmd = new GenericDeleteCommand<T, GenericModel>(entity);
            e.Execute(cmd);
        }
        public static void Delete<T>(this Engine e, Guid id)
            where T : PersistentEntity
        {
            var cmd = new GenericDeleteCommand<T, GenericModel>(id);
            e.Execute(cmd);
        }
    }

    //Helpers for Queries
    public static class Queries
    {
        public static IList<T> GetAll<T>(this Engine e)
            where T : PersistentEntity
        {
            var query = new GenericGetAllQuery<T>();
            return (IList<T>) e.Execute(query);
        }
        public static T GetById<T>(this Engine e, Guid id)
            where T : PersistentEntity
        {
            var query = new GenericGetByIdQuery<T>(id);
            return e.Execute(query) as T;
        }

        public static IEnumerable<T> Find<T>(this Engine e, Func<T,bool> expression)
            where T : PersistentEntity
        {
            var query = new GenericFindQuery<T>(expression);
            return e.Execute(query) as IEnumerable<T>;
        }
    }

    //Command - SAVE
    [Serializable]
    public class GenericSaveCommand<T, TA> : Command<TA>
        where T : PersistentEntity
        where TA : GenericModel
    {
        private readonly T _entity;

        public GenericSaveCommand(T entity)
        {
            this._entity = entity;
        }

        protected override void Execute(TA model)
        {
            model.SaveOrUpdate(this._entity);
        }
    }

    //Command - DELETE
    [Serializable]
    public class GenericDeleteCommand<T, TA> : Command<TA>
        where T : PersistentEntity
        where TA : GenericModel
    {
        private readonly Guid _id;

        public GenericDeleteCommand(T entity)
        {
            this._id = entity.Id;
        }
        public GenericDeleteCommand(Guid id)
        {
            this._id = id;
        }

        protected override void Execute(TA model)
        {
            model.Delete<T>(this._id);
        }
    }

    //Query - ALL
    [Serializable]
    public class GenericGetAllQuery<T> : Query<GenericModel, IEnumerable<T>> where T : PersistentEntity
    {
        protected override IEnumerable<T> Execute(GenericModel model)
        {
            return model.GetAll<T>();
        }
    }
    //Query - FIND
    [Serializable]
    public class GenericFindQuery<T> : Query<GenericModel, IEnumerable<T>> where T : PersistentEntity
    {
        private Func<T, bool> _expression;
        public GenericFindQuery(Func<T,bool> expression)
        {
            this._expression = expression;
        }

        protected override IEnumerable<T> Execute(GenericModel model)
        {
            return model.Find<T>(this._expression);
        }
    }
    //Query - BY ID
    [Serializable]
    public class GenericGetByIdQuery<T> : Query<GenericModel, T> where T : PersistentEntity
    {
        private readonly Guid _id;
        public GenericGetByIdQuery(Guid id)
        {
            this._id = id;
        }

        protected override T Execute(GenericModel model)
        {
            return model.GetById<T>(this._id);
        }
    }



    class Program
    {
        static void Main(string[] args)
        {
            var engine = Engine.LoadOrCreate<GenericModel>();

            var spot = new Spot
                           {
                               Lat = "62.234",
                               Lng = "17.342",
                               Name = "Localhost",
                               Id = Guid.NewGuid(),
                               Tags = new List<Tag> {new Tag {Name = "C#"}, new Tag {Name = "JavaScript"}}
                           };

            engine.SaveOrUpdate(spot);

            foreach (var s in engine.GetAll<Spot>())
            {
                Console.WriteLine(s.Id);
                Console.WriteLine(s.Name);
                foreach (var tag in s.Tags)
                {
                    Console.WriteLine(tag.Name);
                }
                Console.WriteLine();
            }

            foreach (var s in engine.Find<Spot>(p => p.Name == "Localhost"))
            {
                Console.WriteLine(s.Id);
                Console.WriteLine(s.Name);
                foreach (var tag in s.Tags)
                {
                    Console.WriteLine(tag.Name);
                }
                Console.WriteLine();
            }

            Console.ReadLine();
        }
    }
}