C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx.Client.Shared/InterfaceInspector.cs

/*  ----------------------------------------------------------------------------
 *  Microsoft Corporation
 *  ----------------------------------------------------------------------------
 *  Microsoft Project Server mpFx (mpFx)
 *  ----------------------------------------------------------------------------
 *  Author: Colby Africa
 *  ----------------------------------------------------------------------------
 *  License: http://code.msdn.microsoft.com/mpFx/Project/License.aspx
 *  ----------------------------------------------------------------------------
 */

using System;
using System.Reflection;

namespace Mcs.Epm.MicrosoftProject.mpFx.Client.Shared
{
    /// <summary>
    /// Implements a interface inspector for determining whether a given interface
    /// is implemented in an assembly
    /// </summary>
    class InterfaceInspector : MarshalByRefObject, IInterfaceInspector
    {
        #region Public Methods

        /// <summary>
        /// Given a path to an assembly and a fully-qualified interface name,
        /// determine whether the interface is implemented.  
        /// NOTE: Only exported types are examined.
        /// </summary>
        /// <param name="filePath">The full path to the assembly</param>
        /// <param name="interfaceName">The fully-qualified name of the interface</param>
        /// <returns>True if the interface is implemented on an exported type, false if not.</returns>
        public bool IsInterfaceImplemented(string filePath, string interfaceName)
        {
            Type[] types = GetExportedTypes(filePath);
            
            foreach (Type type in types)
            {
                Type iAgentInterface = type.GetInterface(interfaceName);
                
                if (iAgentInterface != null)
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Given a path to an assembly and a fully-qualified interface name,
        /// determine whether the interface is implemented and return the fully qualified name of the type
        /// that implements the interface.  NOTE: Only exported types are examined.
        /// </summary>
        /// <param name="filePath">The full path to the assembly</param>
        /// <param name="interfaceName">The fully-qualified name of the interface</param>
        /// <param name="typeName">On success, the fully qualified name of the type that implements the interface.</param>
        /// <returns>True if the interface is implemented on an exported type, false if not.</returns>
        public bool TryGetTypeNameByFileAndInterface(string filePath, string interfaceName, out string typeName)
        {
            typeName = string.Empty;

            Type[] types = GetExportedTypes(filePath);

            foreach (Type type in types)
            {
                Type iAgentInterface = type.GetInterface(interfaceName);

                if (iAgentInterface != null)
                {
                    typeName = type.FullName;
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Given a path to an assembly and a fully-qualified interface name,
        /// determine whether the interface is implemented and return the type
        /// that implements the interface.  NOTE: Only exported types are examined.
        /// </summary>
        /// <param name="filePath">The full path to the assembly</param>
        /// <param name="interfaceName">The fully-qualified name of the interface</param>
        /// <param name="type">On success, the type that implements the interface.</param>
        /// <returns>True if the interface is implemented on an exported type, false if not.</returns>
        public bool TryGetTypeByFileAndInterface(string filePath, string interfaceName, out Type type)
        {
            Type[] types = GetExportedTypes(filePath);

            foreach (Type thisType in types)
            {
                Type iAgentInterface = thisType.GetInterface(interfaceName);

                if (iAgentInterface != null)
                {
                    type = thisType;
                    return true;
                }
            }

            type = null;
            return false;
        }

        /// <summary>
        /// Load an instance of the interface inspector in the specified application domain
        /// </summary>
        /// <returns>An instance of IInterfaceInspector</returns>
        public static IInterfaceInspector Get(AppDomain domain, string inspectorInterfaceName)
        {
            if (domain == null)
            {
                throw new ArgumentNullException("domain");
            }

            if (string.IsNullOrEmpty(inspectorInterfaceName))
            {
                throw new ArgumentNullException(inspectorInterfaceName);
            }

            IInterfaceInspector interfaceInspector = domain.CreateInstanceAndUnwrap(GetExecutingAssemblyFullName(),
                                                                                    inspectorInterfaceName) as IInterfaceInspector;

            if (interfaceInspector == null)
            {
                throw new NullReferenceException("IInterfaceInspector");
            }

            return interfaceInspector;
        }


        /// <summary>
        /// Given a full path to an Agent assembly and the type which implements IAgent,
        /// try to load the Agent type.
        /// </summary>
        /// <param name="filePath">The full path to the Agent assembly</param>
        /// <param name="interfaceName"></param>
        /// <param name="typeName">The full name of the type implementing IAgent</param>
        /// <param name="agentType">On success, contains the Agent type</param>
        /// <returns>True if the Agent type is loaded and IAgent interface is found, false if not.</returns>
        public bool TryGetTypeFromPathInterfaceAndType(string filePath, string interfaceName, string typeName, out Type agentType)
        {
            Assembly agentAssembly = Assembly.LoadFile(filePath);

            agentType = agentAssembly.GetType(typeName);

            return agentType != null && agentType.GetInterface(interfaceName) != null;
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Get an array of exported Types.
        /// </summary>
        /// <param name="filePath">The full path to an assembly</param>
        /// <returns>An array of exported types.</returns>
        private static Type[] GetExportedTypes(string filePath)
        {
            Assembly agentAssembly = Assembly.LoadFrom(filePath);

            return agentAssembly.GetExportedTypes();
        }

        /// <summary>
        /// Get the currently executing assembly's full name.
        /// </summary>
        /// <returns>The full name</returns>
        private static string GetExecutingAssemblyFullName()
        {
            Assembly executingAssembly = Assembly.GetExecutingAssembly();

            if (executingAssembly == null || string.IsNullOrEmpty(executingAssembly.FullName))
            {
                throw new NullReferenceException("executingAssembly");
            }
            return executingAssembly.FullName;
        }


        #endregion
    }
}

---