public static IList<IAccountFamily> GetAccountFamilies(IDalSession session, IAssetManager assetManager)
 {
     List<ICriterion> expressions = new List<ICriterion>();
     if (!assetManager.IsStichting)
         expressions.Add(Expression.Eq("AssetManager.Key", assetManager.Key));
     return session.GetTypedList<AccountFamily,IAccountFamily>(expressions);
 }

        public IAsset Handle(IAssetManager assetManager, string name, IRawAsset data)
        {
            if (data is CompiledAsset)
            {
                return new UberEffectAsset(_kernel, _assetContentManager, _rawLaunchArguments, name, null, data.GetProperty<PlatformData>("PlatformData"), false);
            }

            PlatformData platformData = null;
            if (data.GetProperty<PlatformData>("PlatformData") != null)
            {
                platformData = new PlatformData
                {
                    Platform = data.GetProperty<PlatformData>("PlatformData").Platform,
                    Data = data.GetProperty<PlatformData>("PlatformData").Data
                };
            }

            var effect = new UberEffectAsset(
                _kernel,
                _assetContentManager,
                _rawLaunchArguments,
                name,
                data.GetProperty<string>("Code"), 
                platformData, 
                data.GetProperty<bool>("SourcedFromRaw"));

            return effect;
        }

        public MyGameWorld(
            I2DRenderUtilities renderUtilities,
            IAssetManagerProvider assetManagerProvider,
            IEntityFactory entityFactory)
        {
            this.Entities = new List<IEntity>();

            _renderUtilities = renderUtilities;
            _assetManager = assetManagerProvider.GetAssetManager();
            _defaultFont = this._assetManager.Get<FontAsset>("font.Default");

            // You can also save the entity factory in a field and use it, e.g. in the Update
            // loop or anywhere else in your game.
            var entityA = entityFactory.CreateExampleEntity("EntityA");
            entityA.X = 100;
            entityA.Y = 50;
            var entityB = entityFactory.CreateExampleEntity("EntityB");
            entityB.X = 120;
            entityB.Y = 100;

            // Don't forget to add your entities to the world!
            this.Entities.Add(entityA);
            this.Entities.Add(entityB);

            // This pulls in the texture asset via the asset manager.  Note that
            // the folder seperator from "texture/Player" has been translated
            // into a single dot.
            _playerTexture = _assetManager.Get<TextureAsset>("texture.Player");
        }

 public IAsset GetNew(IAssetManager assetManager, string name)
 {
     return new ElementDefinitionAsset(
         assetManager,
         name,
         null);
 }

 public LabelUserInterfaceNodeProcessor(
     IAssetManagerProvider assetManagerProvider,
     INodeColorParser nodeColorParser)
 {
     _nodeColorParser = nodeColorParser;
     _assetManager = assetManagerProvider.GetAssetManager();
 }

        /// <summary>
        /// This method retrieves a list of counter account instances that meet the passed in arguments. 
        /// When an argument is ommitted it is not used to filter the counter accounts
        /// </summary>
        /// <param name="session">An instance of the Data Access Library <see cref="T:B4F.TotalGiro.DAL.NHSession">NHSession</see> class</param>
        /// <param name="assetManager">The asset manager the customer belongs to</param>
        /// <param name="counterAccountNumber">Number of the counter account</param>
        /// <param name="counterAccountName">Name of the counter account</param>
        /// <param name="contactName">The name of the contact</param>
        /// <param name="accountNumber">The account's number of the account</param>
        /// <param name="showActive">Show for active contacts</param>
        /// <param name="showInactive">Show for inactive contacts</param>
        /// <param name="isPublic">Show public contacts</param>
        /// <returns>A list of counter account instances</returns>
        public static IList<ICounterAccount> GetCounterAccounts(IDalSession session, IAssetManager assetManager,
            string counterAccountNumber, string counterAccountName, 
            string contactName, string accountNumber, bool showActive, 
            bool showInactive, bool isPublic)
        {
            Hashtable parameters = new Hashtable();

            if (assetManager != null)
                parameters.Add("managementCompanyId", assetManager.Key);
            if (counterAccountNumber != null && counterAccountNumber.Length > 0)
                parameters.Add("counterAccountNumber", Util.PrepareNamedParameterWithWildcard(counterAccountNumber, MatchModes.Anywhere));
            if (counterAccountName != null && counterAccountName.Length > 0)
                parameters.Add("counterAccountName", Util.PrepareNamedParameterWithWildcard(counterAccountName, MatchModes.Anywhere));
            if (contactName != null && contactName.Length > 0)
                parameters.Add("contactName", Util.PrepareNamedParameterWithWildcard(contactName, MatchModes.Anywhere));
            parameters.Add("isPublic", isPublic);
            if (showActive && !showInactive)
                parameters.Add("isActive", true);
            if (!showActive && showInactive)
                parameters.Add("isActive", false);

            if (accountNumber != null && accountNumber.Length > 0)
                parameters.Add("accountNumber", Util.PrepareNamedParameterWithWildcard(accountNumber, MatchModes.Anywhere));

            return session.GetTypedListByNamedQuery<ICounterAccount>(
                "B4F.TotalGiro.Accounts.CounterAccount.GetCounterAccounts",
                parameters);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="GameSystemBase" /> class.
 /// </summary>
 /// <param name="registry">The registry.</param>
 /// <remarks>
 /// The GameSystem is expecting the following services to be registered: <see cref="IGame"/> and <see cref="IAssetManager"/>.
 /// </remarks>
 protected GameSystemBase(IServiceRegistry registry)
 {
     if (registry == null) throw new ArgumentNullException("registry");
     this.registry = registry;
     game = (GameBase)Services.GetServiceAs<IGame>();
     assetManager = Services.GetSafeServiceAs<IAssetManager>();
 }

 /// <summary>
 /// Handles loading the specified LogicControl asset from it's raw data.
 /// </summary>
 /// <param name="assetManager">The asset manager.</param>
 /// <param name="name">The name of the LogicControl script.</param>
 /// <param name="data">The raw data associated with the asset.</param>
 /// <returns>The ScriptAsset from the load.</returns>
 public IAsset Handle(IAssetManager assetManager, string name, IRawAsset data)
 {
     return new ScriptAsset(
         name,
         data.GetProperty<string>("Code"),
         new LogicControlScriptEngine(data.GetProperty<string>("Code")));
 }

 public IAsset Handle(IAssetManager assetManager, string name, dynamic data)
 {
     return new ElementDefinitionAsset(
         assetManager,
         name,
         (string)data.DisplayNameName);
 }

 public DefaultAutomaticAssetReload(
     IAssetManager assetManager,
     IRawAssetLoader rawAssetLoader)
 {
     _assetManager = assetManager;
     _rawAssetLoader = rawAssetLoader;
     _started = false;
 }

 public static IList GetAccountCategories(IDalSession session, IAssetManager am)
 {
     List<ICriterion> expressions = new List<ICriterion>();
     expressions.Add(Expression.Eq("AssetManager.Key", am.Key));
     List<Order> orderings = new List<Order>();
     orderings.Add(Order.Asc("CustomerType"));
     return session.GetList(typeof(AccountCategory), expressions, orderings, null, null);
 }

 public StatusBar(
     I2DRenderUtilities twodRenderUtilities,
     IAssetManagerProvider assetManagerProvider)
 {
     this.m_2DRenderUtilities = twodRenderUtilities;
     this.m_AssetManager = assetManagerProvider.GetAssetManager();
     this.m_DefaultFont = this.m_AssetManager.Get<FontAsset>("font.Default");
 }

 public IAsset Handle(IAssetManager assetManager, string name, IRawAsset data)
 {
     return new UserInterfaceAsset(
         name,
         data.GetProperty<string>("UserInterfaceData"),
         data.GetProperty<UserInterfaceFormat>("UserInterfaceFormat"),
         data.GetProperty<string>("SourcePath"));
 }

 /// <summary>
 /// The handle.
 /// </summary>
 /// <param name="assetManager">
 /// The asset manager.
 /// </param>
 /// <param name="name">
 /// The name.
 /// </param>
 /// <param name="data">
 /// The data.
 /// </param>
 /// <returns>
 /// The <see cref="IAsset"/>.
 /// </returns>
 public IAsset Handle(IAssetManager assetManager, string name, IRawAsset data)
 {
     return new LevelAsset(
         name, 
         data.GetProperty<string>("LevelData"),
         data.GetProperty<LevelDataFormat>("LevelDataFormat"),
         data.GetProperty<string>("SourcePath"));
 }

 public TychaiaSkin(
     I2DRenderUtilities twodRenderUtilities,
     IAssetManagerProvider assetManagerProvider,
     BasicSkin basicSkin)
 {
     this.m_2DRenderUtilities = twodRenderUtilities;
     this.m_BasicSkin = basicSkin;
     this.m_AssetManager = assetManagerProvider.GetAssetManager(false);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="BasicSkin"/> class.
 /// </summary>
 /// <param name="skin">
 /// The skin.
 /// </param>
 /// <param name="renderUtilities">
 /// The render utilities.
 /// </param>
 /// <param name="assetManagerProvider">
 /// The asset manager provider.
 /// </param>
 public BasicSkin(
     IBasicSkin skin, 
     I2DRenderUtilities renderUtilities, 
     IAssetManagerProvider assetManagerProvider)
 {
     this.m_BasicSkin = skin;
     this.m_RenderUtilities = renderUtilities;
     this.m_AssetManager = assetManagerProvider.GetAssetManager(false);
 }

        public override void Initialize()
        {
            // import required services;
            this._assetManager = (IAssetManager)this.Game.Services.GetService(typeof(IAssetManager));
            if (this._assetManager == null)
                throw new NullReferenceException("Can not find asset manager component.");

            base.Initialize();
        }

 /// <summary>
 /// The handle.
 /// </summary>
 /// <param name="assetManager">
 /// The asset manager.
 /// </param>
 /// <param name="name">
 /// The name.
 /// </param>
 /// <param name="data">
 /// The data.
 /// </param>
 /// <returns>
 /// The <see cref="IAsset"/>.
 /// </returns>
 public IAsset Handle(IAssetManager assetManager, string name, IRawAsset data)
 {
     return new TilesetAsset(
         assetManager,
         name,
         data.GetProperty<string>("TextureName"),
         data.GetProperty<int>("CellWidth"),
         data.GetProperty<int>("CellHeight"));
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MenuItem"/> class.
        /// </summary>
        /// <param name="assetManagerProvider">
        /// The asset manager provider.
        /// </param>
        /// <param name="renderUtilities">
        /// The render utilities.
        /// </param>
        public MenuItem(IAssetManagerProvider assetManagerProvider, I2DRenderUtilities renderUtilities)
        {
            this.m_RenderUtilities = renderUtilities;
            this.m_AssetManager = assetManagerProvider.GetAssetManager(false);
            this.Active = false;

            // Give menu items a higher visibility over other things.
            this.Order = 10;
        }

        public static List<IRemisier> GetRemisiers(IDalSession session, IAssetManager assetManager, RemisierFilterTypes remisierFilterType)
        {
            List<IRemisier> list = GetRemisiers(session, assetManager, null, ActivityReturnFilter.Active);

            if (remisierFilterType != RemisierFilterTypes.All)
                return list.Where(r => r.IsInternal == (remisierFilterType == RemisierFilterTypes.Internal))
                           .ToList();
            else
                return list;
        }