C# IController.GetType方法代码示例

        public void Release(IController controller)
        {
            var types = controller.GetType()
                .GetInterfaces()
                .Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IController<,>))
                .Select(i => i.GetGenericArguments())
                .First();

            var controllerAccessor = Kernel.Resolve(
                typeof(ControllerAccessor<,>)
                    .MakeGenericType(
                        types.ElementAt(0),
                        types.ElementAt(1)
                    )
            ) as IControllerAccessor;

            var viewAccessor = Kernel.Resolve(
                typeof(ViewAccessor<>)
                    .MakeGenericType(
                        types.ElementAt(1)
                    )
            ) as IViewAccessor;

            if (controllerAccessor != null && viewAccessor != null)
            {
                var view = controllerAccessor.GetView(controller);
                var viewModel = controllerAccessor.GetViewModel(controller);

                Kernel.ReleaseComponent(view);
                Kernel.ReleaseComponent(viewModel);
            }

            Kernel.ReleaseComponent(controller);
        }

 /// <summary>
 /// Releases the specified controller.
 /// </summary>
 /// <param name="controller">The controller to release.</param>
 public override void ReleaseController(IController controller)
 {
     if (this.IsFromCurrentAssembly(controller.GetType()))
     {
         this.kernel.ReleaseComponent(controller);
     }
     else
     {
         base.ReleaseController(controller);
     }
 }

        private static Type FindResourceStringClassType(IController controller)
        {
            LocalizationAttribute rcdAttribute = Attribute.GetCustomAttribute(controller.GetType(), typeof(LocalizationAttribute)) as LocalizationAttribute;

            if (rcdAttribute != null)
            {
                return rcdAttribute.ResourceClass;
            }
            else
            {
                return typeof(Labels);
            }
        }

        public void ReleaseController(IController controller)
        {
            //get spring context
            IApplicationContext ctx = ContextRegistry.GetContext();
            if (!ctx.ContainsObject(controller.GetType().Name))
            {
                if (defalutf == null)
                {
                    defalutf = new DefaultControllerFactory();
                }

                defalutf.ReleaseController(controller);
            }
        }

 private static string FormatLogText(
     IController controller, 
     string actionName, 
     string parameterName, 
     Type parameterType)
 {
     return
         string.Format(
             LocalizedTexts.InvalidArgumentOnControllerMethodogTextTemplate,
             parameterName,
             parameterType.Name,
             actionName,
             controller.GetType().Name
         );
 }

 /// <summary>
 /// サービスの依存性を注入
 /// </summary>
 /// <param name="controller"></param>
 private void InjectService(IController controller)
 {
     var controllerType = controller.GetType();
     var fields = controllerType.GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
     foreach (var field in fields)
     {
         // 依存性注入対象の属性取得
         var implAttr = field.GetCustomAttributes(typeof(ImplementAttribute), true);
         if (implAttr != null && implAttr.Length > 0)
         {
             var attr = implAttr[0] as ImplementAttribute;
             if (attr.Debug == false || attr.DebugImplementType == null)
             {
                 // 本番環境用インスタンスの生成
                 var impleInstance = Activator.CreateInstance(attr.ImplementType);
                 field.SetValue(controller, impleInstance);
                 if (log.IsInfoEnabled)
                 {
                     log.Info("Staging instance is created.");
                     if (log.IsDebugEnabled)
                     {
                         log.Debug("Create instance type is " + impleInstance.GetType().Name);
                     }
                 }
             }
             else
             {
                 // デバッグ環境用インスタンスの生成
                 var debugInstance = Activator.CreateInstance(attr.DebugImplementType);
                 field.SetValue(controller, debugInstance);
                 if (log.IsInfoEnabled)
                 {
                     log.Info("Debug instance is created.");
                     if (log.IsDebugEnabled)
                     {
                         log.Debug("Create instance type is " + debugInstance.GetType().Name);
                     }
                 }
             }
         }
     }
 }

        /// <summary>
        /// 必须注册Controller
        /// </summary>
        /// <param name="controller">Controller实例</param>
        public void RegisterController(IController controller)
        {
            if (controller != null)
            {
                Type tp = controller.GetType();
                if (tp != null && !Controllers.ContainsKey(tp.FullName) && tp.Name.EndsWith("Controller"))
                {
                    Controllers.Add(tp.FullName, tp);

                    //Add Action
                    MethodInfo[] allMethods = tp.GetMethods(BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public);
                    MethodInfo[] actionMethods = Array.FindAll(allMethods, IsValidActionMethod);
                    if (actionMethods != null && actionMethods.Length > 0)
                    {
                        foreach (var m in actionMethods)
                        {
                            string mname = m.Name.ToLower();
                            if (!Action.ContainsKey(mname))
                            {
                                Action.Add(mname, new List<string>());
                            }
                            if (!Action[mname].Contains(tp.FullName))
                            {
                                Action[mname].Add(tp.FullName);
                            }

                            string val = tp.FullName + "." + mname;
                            var nm = Helper.GetNameDesc(m);
                            if (!ActionList.ContainsKey(val))
                            {
                                ActionList.Add(val, nm == null ? new NameDesc(val) : nm);
                            }
                        }
                    }
                }
            }
        }

        private static Tuple<string, DirectoryInfo> FindFolder(HttpContext context, IController feature, string featureFolder)
        {
            var featureName = Feature.Configuration.Current.NamingConvention(feature.GetType())
                .Value
                .Replace("Controller", "");

            var folderName = featureFolder + "/" + featureName;
            var basePath = new DirectoryInfo(context.Server.MapPath(folderName));

            if (!basePath.Exists)
            {
                var area = GetAreaNameAndNamespace(RouteTable.Routes)
                    .SingleOrDefault(x => feature.GetType().Namespace.StartsWith(x.Item2));

                if (area != null)
                {
                    folderName = "~/Areas/" + area.Item1 + "/Features/" + featureName;
                    basePath = new DirectoryInfo(context.Server.MapPath(folderName));
                }

            }

            return Tuple.Create(folderName, basePath);
        }

		/// <summary>
		/// Selects the action method.
		/// </summary>
		/// <param name="controller">The controller.</param>
		/// <param name="context">The context.</param>
		/// <param name="name">The name.</param>
		/// <param name="actionType">The action type</param>
		/// <returns></returns>
		protected virtual MethodInfo SelectActionMethod(IController controller, IControllerContext context, string name,
		                                                ActionType actionType)
		{
			object action = context.ControllerDescriptor.Actions[name];

			if (actionType == ActionType.Sync)
			{
				MethodInfo methodInfo = action as MethodInfo;

				if (methodInfo != null)
				{
					return methodInfo;
				}

				return controller.GetType().GetMethod(name,
				                                      BindingFlags.Public | BindingFlags.Instance |
				                                      BindingFlags.IgnoreCase);
			}

			AsyncActionPair actionPair = (AsyncActionPair) action;
			
			if (actionPair == null)
			{
				return null;
			}
			
			return actionType == ActionType.AsyncBegin ? actionPair.BeginActionInfo : actionPair.EndActionInfo;
		}

 public virtual bool Match(IController controller){
     return controller.GetType() == ControllerType;
 }

		/// <summary>
		/// Implementors should perform their logic
		/// to release the <see cref="IController"/> instance
		/// and its resources.
		/// </summary>
		/// <param name="controller"></param>
		public virtual void Release(IController controller)
		{
			if (logger.IsDebugEnabled)
			{
				logger.Debug("Controller released: " + controller.GetType());
			}

			controller.Dispose();
		}

 /// <summary>
 /// Gets the action method.
 /// </summary>
 /// <param name="controller">The controller.</param>
 /// <param name="controllerContext">The controller context.</param>
 /// <returns></returns>
 /// <remarks></remarks>
 private MethodInfo getActionMethod(IController controller, IControllerContext controllerContext) {
     //NOTE: метод представленный здесь - быстрый но не охватывает всех случаев, например асинхронных и проч, но охватывает основной и как мне кажется нормальный паттерн
     var action = controller.GetType().GetMethod(controllerContext.Action,
                                                 BindingFlags.Instance | BindingFlags.InvokeMethod |
                                                 BindingFlags.Public | BindingFlags.IgnoreCase);
     return action; //null is not error - it means that controller or action is untipical
 }

 /// <summary>
 /// Getroleses the specified controller.
 /// </summary>
 /// <param name="controller">The controller.</param>
 /// <param name="controllerContext">The controller context.</param>
 /// <returns></returns>
 /// <remarks></remarks>
 private IEnumerable<string> getroles(IController controller, IControllerContext controllerContext) {
     RoleAttribute rolesattribute = null;
     //сначала ищем роли у действия (более глубокий уровень)
     var actionmethod = getActionMethod(controller, controllerContext);
     if (null != actionmethod) {
         rolesattribute =
             actionmethod.GetCustomAttributes(typeof (RoleAttribute), true).OfType<RoleAttribute>().
                 FirstOrDefault();
     }
     // если у действия нет атрибута, ищем у всего контроллера
     if (null == rolesattribute) {
         rolesattribute =
             controller.GetType().GetCustomAttributes(typeof(RoleAttribute), true).OfType<RoleAttribute>().FirstOrDefault();
     }
     //если атрибут найдейн - вернуть список ролей из атрибута
     if(null != rolesattribute) {
         return rolesattribute.Role.split();
     }
     //иначе вернуть пустой список, нет сопоставления ролей
     return new string[]{};
 }

 /// <summary>
 /// Pick up all methods marked with the ResponsiveAttribute
 /// </summary>
 /// <param name="trType"></param>
 /// <param name="controller"></param>
 /// <returns></returns>
 private List<System.Reflection.MethodInfo> GetResponsiveMethods(ResponsiveEnum trType, IController controller)
 {
     List<MethodInfo> responsiveMethods = new List<MethodInfo>();
     MethodInfo[] methods = controller.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Instance);
     foreach(MethodInfo method in methods)
     {
         object[] attributes = method.GetCustomAttributes(typeof(ResponsiveAttribute), true);
         if (attributes.Length != 0)
         {
             ResponsiveAttribute att = (ResponsiveAttribute)attributes[0];
             if (att.RespType == trType)
             {
                 // TODO: Search within method code calls to OnAbortRemoteCall, OnRemoteException, StopTransfer: Cecil?
                 responsiveMethods.Add(method);
             }
         }
     }
     return responsiveMethods;
 }

 private static ProjectBActions GetPageActionId(string key, IController controller, string actionName)
 {
     var value = ProjectBActions.Undefined;
     var methodInfo = controller.GetType()
             .GetMethods()
             .FirstOrDefault(m => m.Name.Equals(actionName, StringComparison.InvariantCultureIgnoreCase));
     if (methodInfo != null) {
         var previousAttribute = methodInfo.GetCustomAttribute(typeof (ActionLogAttribute)) as ActionLogAttribute;
         if (previousAttribute != null) {
             value = previousAttribute.ActionToLog;
         }
     }
     _cachePreviousPageActionIds[key] = value;
     return value;
 }