public void Test_HasNext_True()
        {
            Type type = typeof(TestArticle);

            TypeNavigator navigator = new TypeNavigator(type);

            Assert.IsTrue(navigator.HasNext, "HasNext is false when it should be true.");
        }
        public void Test_HasNext_False()
        {
            Type type = typeof(object);

            TypeNavigator navigator = new TypeNavigator(type);

            Assert.IsFalse(navigator.HasNext, "HasNext is true when it should be false.");
        }
        public void Test_Next()
        {
            Type type = typeof(TestArticle);

            TypeNavigator navigator = new TypeNavigator(type);

            ArrayList list = new ArrayList();

            while (navigator.HasNext)
            {
                list.Add(navigator.Next());
            }

            Assert.AreEqual(4, list.Count, "Invalid number of types identified.");
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Locates the reaction info for performing the specified action with the specified type by looking at the base types of the provided type.
        /// </summary>
        /// <param name="action">The action that is to be performed by the reaction.</param>
        /// <param name="type">The type that is involved in the action.</param>
        /// <returns>The reaction info for the specified scenario.</returns>
        public ReactionInfo[] LocateFromBaseTypes(string action, Type type)
        {
            ReactionInfoCollection reactionInfos = new ReactionInfoCollection();

            // Logging commented out to boost performance
            //using (LogGroup logGroup = LogGroup.StartDebug("Locating reaction via the base types of the '" + (type != null ? type.FullName : "[null]") + "' type."))
            //{
                if (action == null)
                    throw new ArgumentNullException("action");

                if (action == String.Empty)
                    throw new ArgumentException("An action must be specified.");

                if (type == null)
                    throw new ArgumentNullException("type");

                TypeNavigator navigator = new TypeNavigator(type);

                while (navigator.HasNext)
                {
                    Type nextType = navigator.Next();

                    if (nextType != null)
                    {
                        //using (LogGroup logGroup2 = LogGroup.StartDebug("Checking base type: " + nextType.FullName))
                        //{
                            string key = Reactions.GetReactionsKey(action, nextType.Name);

                            //LogWriter.Debug("Key: " + key);

                            // If a reaction exists for the base type then use it
                            if (Reactions.ReactionExists(key))
                            {
                                if (Reactions.ContainsKey(key))
                                    reactionInfos.AddRange(Reactions[key]);

                                //LogWriter.Debug("Reactions found: " + reactionInfos.Count.ToString());

                            }
                        //}
                    }
                }

            //}
            return reactionInfos.ToArray();
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Locates the strategy info for performing the specified action with the specified type by looking at the base types of the provided type.
        /// </summary>
        /// <param name="action">The action that is to be performed by the strategy.</param>
        /// <param name="type">The type that is involved in the action.</param>
        /// <returns>The strategy info for the specified scenario.</returns>
        public StrategyInfo LocateFromBaseTypes(string action, Type type)
        {
            StrategyInfo strategyInfo = null;
            //using (LogGroup logGroup = LogGroup.Start("Locating strategy via the base types of the provided type.", NLog.LogLevel.Debug))
            //{
            TypeNavigator navigator = new TypeNavigator(type);

            while (navigator.HasNext && strategyInfo == null)
            {
                Type nextType = navigator.Next();

                if (strategyInfo == null)
                {

                    //			using (LogGroup logGroup2 = LogGroup.Start("Checking base type: " + nextType.FullName, NLog.LogLevel.Debug))
                    //			{
                    string key = StrategyInfo.GetStrategyKey(action, nextType.Name);

                    //				LogWriter.Debug("Key: " + key);

                    // If a strategy exists for the base type then use it
                    if (Strategies.StrategyExists(key))
                    {
                        strategyInfo = Strategies[key];

                        //					LogWriter.Debug("Strategy found: " + strategyInfo.StrategyType);

                    }
                    // TODO: Check if needed. It shouldn't be. The other call to LocateFromInterfaces in LocateFromHeirarchy should be sufficient
                    // Otherwise check the interfaces of that base type
                    //else
                    //{
                    //	strategyInfo = LocateFromInterfaces(action, nextType);
                    //}
                    //			}
                }
            }

            //}
            return strategyInfo;
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Locates the controller info for performing the specified action with the specified type by looking at the base types of the provided type.
        /// </summary>
        /// <param name="action">The action that is to be performed by the controller.</param>
        /// <param name="type">The type that is involved in the action.</param>
        /// <returns>The controller info for the specified scenario.</returns>
        public ControllerInfo LocateFromBaseTypes(string action, Type type)
        {
            ControllerInfo controllerInfo = null;

            // Disabled logging to boost performance
            //using (LogGroup logGroup = LogGroup.Start("Locating via base types the controller for the action '" + action + "' and type '" + type.Name + "'.", NLog.LogLevel.Debug))
            //{
                TypeNavigator navigator = new TypeNavigator(type);

                while (navigator.HasNext && controllerInfo == null)
                {
                    Type nextType = navigator.Next();

                    string key = Controllers.GetControllerKey(action, nextType.Name);

                    // If a controller exists for the base type then use it
                    if (Controllers.ControllerExists(key))
                    {
            //			LogWriter.Debug("Found match with key: " + key);

                        controllerInfo = Controllers[key];

                        break;
                    }
                    // TODO: Check if needed. It shouldn't be. The other call to LocateFromInterfaces in LocateFromHeirarchy should be sufficient
                    // Otherwise check the interfaces of that base type
                    //else
                    //{
                    //	controllerInfo = LocateFromInterfaces(action, nextType);
                    //}
                }
            //}

            return controllerInfo;
        }