/// <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); }
/// <summary> /// Locates the controller info for performing the specified action with the specified type by looking at the interfaces 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 LocateFromInterfaces(string action, Type type) { ControllerInfo controllerInfo = null; // Disabled logging to boost performance //using (LogGroup logGroup = LogGroup.Start("Locating via interfaces the controller for the action '" + action + "' and type '" + type.Name + "'.", NLog.LogLevel.Debug)) //{ Type[] interfaceTypes = type.GetInterfaces(); // Loop backwards through the interface types for (int i = interfaceTypes.Length - 1; i >= 0; i--) { Type interfaceType = interfaceTypes[i]; string key = Controllers.GetControllerKey(action, interfaceType.Name); if (Controllers.ControllerExists(key)) { // LogWriter.Debug("Found match with key: " + key); controllerInfo = Controllers[key]; break; } } //} return(controllerInfo); }
/// <summary> /// Loads the controller from the specified path. /// </summary> /// <param name="controllerPath">The full path to the controller to load.</param> /// <returns>The controller deserialized from the specified file path.</returns> public ControllerInfo LoadFromFile(string controllerPath) { ControllerInfo info = null; // Disabled logging to boost performance //using (LogGroup logGroup = LogGroup.Start("Loading the controller from the specified path.", NLog.LogLevel.Debug)) //{ if (!File.Exists(controllerPath)) { throw new ArgumentException("The specified file does not exist."); } // LogWriter.Debug("Path: " + controllerPath); using (StreamReader reader = new StreamReader(File.OpenRead(controllerPath))) { XmlSerializer serializer = new XmlSerializer(typeof(ControllerInfo)); info = (ControllerInfo)serializer.Deserialize(reader); reader.Close(); } //} return(info); }
/// <summary> /// Loads all the controllers found in the controllers directory. /// </summary> /// <param name="includeDisabled"></param> /// <returns>An array of the the controllers found in the directory.</returns> public ControllerInfo[] LoadInfoFromDirectory(bool includeDisabled) { // Logging disabled to boost performance //using (LogGroup logGroup = LogGroup.StartDebug("Loading the controllers from the XML file.")) //{ if (Controllers == null) { List <ControllerInfo> validControllers = new List <ControllerInfo>(); ControllerInfo[] controllers = new ControllerInfo[] {}; using (StreamReader reader = new StreamReader(File.OpenRead(FileNamer.ControllersInfoFilePath))) { XmlSerializer serializer = new XmlSerializer(typeof(ControllerInfo[])); controllers = (ControllerInfo[])serializer.Deserialize(reader); } foreach (ControllerInfo controller in controllers) { if (controller.Enabled || includeDisabled) { validControllers.Add(controller); } } Controllers = validControllers.ToArray(); } //} return(Controllers); }
/// <summary> /// Disposes the controllers found by the scanner. /// </summary> public void Dispose() { using (LogGroup logGroup = LogGroup.Start("Disposing the controllers.", NLog.LogLevel.Debug)) { ControllerInfo[] controllers = new ControllerInfo[] {}; Dispose(ControllerState.Controllers.ToArray()); } }
/// <summary> /// Creates a new instance of the controller with a Controller attribute matching the specified type name and action. /// </summary> /// <param name="action">The action that the new controller will be performing.</param> /// <param name="typeName">The name of the type involved in the action.</param> /// <returns>A controller that is suitable to perform the specified action with the specified type.</returns> public IController NewController(string action, string typeName) { IController controller = null; ControllerInfo info = ControllerState.Controllers[action, typeName]; return(controller); }
/// <summary> /// Creates a new instance of the controller with a Controller attribute matching the specified type name and action. /// </summary> /// <param name="controllerInfo">The controller info object that specified the controller to create.</param> /// <returns>A controller that is suitable to perform the specified action with the specified type.</returns> public IController CreateController(ControllerInfo controllerInfo) { IController controller = null; using (LogGroup logGroup = LogGroup.StartDebug("Creating a new controller based on the provided info.")) { if (controllerInfo == null) { throw new ArgumentNullException("controllerInfo"); } Type controllerType = Type.GetType(controllerInfo.ControllerType); if (controllerType == null) { throw new Exception("Can't get type '" + controllerInfo.ControllerType); } Type entityType = null; if (EntityState.IsType(controllerInfo.TypeName)) { entityType = EntityState.GetType(controllerInfo.TypeName); } LogWriter.Debug("Controller type: " + controllerType.FullName); LogWriter.Debug("Entity type: " + (entityType != null ? entityType.FullName : String.Empty)); if (entityType != null && controllerType.IsGenericTypeDefinition) { LogWriter.Debug("Is generic type definition."); Type gType = controllerType.MakeGenericType(new Type[] { entityType }); controller = (IController)Activator.CreateInstance(gType); } else { LogWriter.Debug("Is not generic type definition."); controller = (IController)Activator.CreateInstance(controllerType); } if (controller == null) { throw new ArgumentException("Unable to create instance of controller: " + entityType.ToString(), "controllerInfo"); } LogWriter.Debug("Controller created."); } return(controller); }
/// <summary> /// Creates the file name for the serialized info for the provided controller. /// </summary> /// <param name="controller">The controller to create the file name for.</param> /// <returns>The full file name for the serialized info for the provided controller.</returns> public virtual string CreateInfoFileName(ControllerInfo controller) { if (controller == null) { throw new ArgumentNullException("controller"); } if (controller.Action == null) { throw new ArgumentNullException("controller.Action", "No action has been set to the Action property."); } string name = controller.TypeName + "-" + controller.Action + ".controller"; return(name); }
/// <summary> /// Locates the controller info for performing the specified action with the specified type. /// </summary> /// <param name="action">The action that is to be performed by the controller.</param> /// <param name="typeName">The short type name of the entity that is involved in the action.</param> /// <returns>The controller info for the specified scenario.</returns> public ControllerInfo Locate(string action, string typeName) { // Create the controller info variable to hold the return value ControllerInfo controllerInfo = null; // Disabled logging to boost performance //using (LogGroup logGroup = LogGroup.Start("Locating a controller for the action '" + action + "' and the type '" + typeName + "'.", NLog.LogLevel.Debug)) //{ // Get the specified type Type type = null; type = Entities.EntityState.GetType(typeName); if (type == null) { throw new ArgumentException("No type found with the name '" + typeName + "'."); } // Create a direct controller key for the specified type string key = Controllers.GetControllerKey(action, typeName); // LogWriter.Debug("Direct key: " + key); // Check the direct key to see if a controller exists if (Controllers.ControllerExists(key)) { // LogWriter.Debug("Direct key matches."); controllerInfo = Controllers[key]; } // If not then navigate up the heirarchy looking for a matching controller else if (type != null) // Only use heirarchy if an actual type was provided. { // LogWriter.Debug("Direct key doesn't match. Locating through heirarchy."); controllerInfo = LocateFromHeirarchy(action, type); } // if (controllerInfo == null) // LogWriter.Debug("No controller found."); // else // { // LogWriter.Debug("Controller type found: " + controllerInfo.ControllerType); // LogWriter.Debug("Controller key: " + controllerInfo.Key); // } //} return(controllerInfo); }
/// <summary> /// Finds all the controllers in the available assemblies. /// </summary> /// <param name="includeTestControllers"></param> /// <returns>An array of info about the controllers found.</returns> public override ControllerInfo[] FindControllers(bool includeTestControllers) { List <ControllerInfo> controllers = new List <ControllerInfo>(); //using (LogGroup logGroup = LogGroup.Start("Finding controllers by scanning the attributes of the available type.", NLog.LogLevel.Debug)) //{ foreach (string assemblyPath in AssemblyPaths) { Assembly assembly = Assembly.LoadFrom(assemblyPath); if (ContainsControllers(assembly, includeTestControllers)) { try { foreach (Type type in assembly.GetTypes()) { if (IsController(type)) { //LogWriter.Debug("Found controller type: " + type.ToString()); ControllerInfo controllerInfo = new ControllerInfo(type); if (controllerInfo.TypeName != null && controllerInfo.TypeName != String.Empty && controllerInfo.Action != null && controllerInfo.Action != String.Empty) { //LogWriter.Debug("Found match."); controllers.Add(controllerInfo); } } } } catch (Exception ex) { LogWriter.Error("Error occurred while trying to scan for controllers."); LogWriter.Error(ex); } } } //} return(controllers.ToArray()); }
/// <summary> /// Locates the controller info for performing the specified action with the specified type by looking at the base types and interfaces 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 LocateFromHeirarchy(string action, Type type) { ControllerInfo controllerInfo = null; // Disabled logging to boost performance //using (LogGroup logGroup = LogGroup.Start("Locating via heirarchy the controller for the action '" + action + "' and type '" + type.Name + "'.", NLog.LogLevel.Debug)) //{ controllerInfo = LocateFromInterfaces(action, type); if (controllerInfo == null) { // LogWriter.Debug("Can't locate through interfaces. Trying base types."); controllerInfo = LocateFromBaseTypes(action, type); } //} return(controllerInfo); }
/// <summary> /// Initializes the controllers and loads all controllers to state. /// </summary> /// <param name="includeTestControllers"></param> public void Initialize(bool includeTestControllers) { using (LogGroup logGroup = LogGroup.StartDebug("Initializing the web controllers.")) { if (StateAccess.IsInitialized) { if (!ControllerState.IsInitialized) { ControllerInfo[] controllers = new ControllerInfo[] {}; if (IsCached) { LogWriter.Debug("Is cached. Loading from XML."); controllers = LoadControllers(); } else { LogWriter.Debug("Is not cached. Scanning from type attributes."); controllers = FindControllers(includeTestControllers); Saver.SaveInfoToFile(controllers); } Initialize(controllers); } else { LogWriter.Debug("Already initialized."); } } else { LogWriter.Debug("State is not initialized. Skipping."); } } }