MEF : A sophisticated CompositionProvider

Today, I am going to share a sophisticated composition provider which can be used in any enterprise application with MEF, and will handle all complication involved with different object creations.

Lets start with a definition of ICompositionProvider interface, it defines contract for a composition provider. A sophisticated composition provider should atleast following combination of methods and events.

 public interface ICompositionProvider
    {
        IEnumerable<Lazy<T>> GetExports<T>(string contractName);
        IEnumerable<Lazy<T>> GetExports<T>();
        IEnumerable<Lazy<T,TMetadata>> GetExports<T,TMetadata>();
        IEnumerable<Lazy<T>> GetExports<T>(string contractName, bool enableWildCards);
        IEnumerable<T> GetExportedValues<T>();
        IEnumerable<T> GetExportedValues<T>(string contractName);
        IEnumerable<T> GetExportedValues<T>(string contractName, bool enableWildCards);
        IEnumerable<T> GetEntitledExportedValues<T>(string contractName, bool enableWildCards);
        Lazy<T> GetExport<T>(string contractName);
        Lazy<T> GetExport<T>();
        void SatisfyImports(object attributedPart);
        void Compose(object attributedPart);
        event EventHandler FullyComposed;
        event EventHandler CompositionFailed;
    }

Lets look at a CompositionProvider class, CompositionProvider class implementation looks like

 public class CompositionProvider : ICompositionProvider
    {
        #region Private constants
 
        private const string CLASS_NAME = "CompositionProvider.";
        private const int MAX_TICKS = 100;
 
        private const string ENTITLEMENT_ASSEMBLY_NAME =
            "EntitlementModule.dll";
 
        private const string INFRASTRUCTURE_ASSEMBLY_NAME =
            "Infrastructure.dll";
 
 
        private const string AUTHENTICATION_ASSEMBLY_NAME =
            "AuthenticationModule.dll";
 
        private const string FAILED_COMPOSITION_MESSAGE = "Failed to compose part {0}";
 
        #endregion
 
        #region Variables
 
        public static CompositionProvider _Singleton;
        private readonly AggregateCatalog _aggergate = new AggregateCatalog();
        internal CompositionContainer Container { get; private set; }
 
        public event EventHandler FullyComposed;
        public event EventHandler CompositionFailed;
 
        #endregion
 
        #region Static Properies
        /// <summary>
        /// It indicates current instance.
        /// </summary>
        internal static CompositionProvider Singleton
        {
            get { return _Singleton; }
        }
 
        #endregion
 
        #region Static Constructor
        /// <summary>
        /// Its a static constructor for CompositionProvider class.
        /// </summary>
        static CompositionProvider()
        {
            try
            {
                _Singleton = new CompositionProvider();
            }
            catch (Exception e)
            {
                ErrorHandler.HandleError(e, ErrorTypes.CriticalError);
            }
        }
 
        #endregion
 
        #region Constructor
 
        /// <summary>
        /// Its a constructor for CompositionProvider class.
        /// </summary>
        public CompositionProvider()
        {
            
            _aggergate.Catalogs.Add(new AssemblyCatalog(typeof(CompositionProvider).Assembly));
            Container = new CompositionContainer(_aggergate);
            Compose(this);
            
        }
 
        #endregion
 
        #region Methods
 
        public static void Start()
        {
        }
 
        /// <summary>
        /// It returns a lazy collection of passed type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public IEnumerable<T> GetExportedValues<T>()
        {
            IEnumerable<T> value = GetExportedValues<T>(null, true);
            return value;
        }
 
        /// <summary>
        /// It returns a collection of passed contract name.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="contractName"></param>
        /// <returns></returns>
        public IEnumerable<T> GetExportedValues<T>(string contractName)
        {
            IEnumerable<T> value = GetExportedValues<T>(contractName, false);
            return value;
        }
 
        /// <summary>
        /// It returns a collection of passed contract name with wild cards.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="contractName"></param>
        /// <param name="enableWildCards"></param>
        /// <returns></returns>
        public IEnumerable<T> GetExportedValues<T>(string contractName, bool enableWildCards)
        {
 
            var value = new List<T>();
            try
            {
                if (contractName == null)
                {
                    value = Container.GetExportedValues<T>().ToList();
                }
                else
                {
                    if (enableWildCards)
                    {
                        Container.GetExportedValues<T>(contractName).ToList().ForEach(e => value.Add(e));
                        Container.GetExportedValues<T>(SystemConstants.SYSTEM_WILDCARD).ToList().ForEach(
                            e => value.Add(e));
                    }
                    else
                    {
                        value = Container.GetExportedValues<T>(contractName).ToList();
                    }
                }
            }
            catch (ImportCardinalityMismatchException importCardinalityMismatchException)
            {
                ErrorHandler.HandleError(importCardinalityMismatchException,
                                                              ErrorTypes.CriticalError);
            }
            catch (CompositionException compositionException)
            {
                ErrorHandler.HandleError(compositionException, ErrorTypes.CriticalError);
            }

             return value;
        }
 
        /// <summary>
        /// It returns a collection of passed contract name with wildcards.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="contractName"></param>
        /// <param name="enableWildCards"></param>
        /// <returns></returns>
        public IEnumerable<Lazy<T>> GetExports<T>(string contractName, bool enableWildCards)
        {
            FrontEndTracing.Singleton.LogEntry(CLASS_NAME + " GetExports<T>(string contractName, bool enableWildCards)");
 
            List<Lazy<T>> value = default(List<Lazy<T>>);
            try
            {
                if (contractName == null)
                {
                    value = Container.GetExports<T>().ToList();
                }
                else
                {
                    if (enableWildCards)
                    {
                        Container.GetExports<T>(contractName).ToList().ForEach(e => value.Add(e));
                        Container.GetExports<T>(SystemConstants.SYSTEM_WILDCARD).ToList().ForEach(e => value.Add(e));
                    }
                    else
                    {
                        value = Container.GetExports<T>(contractName).ToList();
                    }
                }
            }
            catch (ImportCardinalityMismatchException e)
            {
                ErrorHandler.HandleError(e, ErrorTypes.CriticalError);
            }
 
            return value;
        }
 
        /// <summary>
        /// this will work with the entitlements provider to return a list of values for the type provided 
        /// using an entitlement attribute check for each value returned
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="contractName"></param>
        /// <param name="enableWildCards"></param>
        /// <returns></returns>
        public IEnumerable<T> GetEntitledExportedValues<T>(string contractName, bool enableWildCards)
        {
            var itemsToReturn = new List<T>();
            if (EntitlementProvider == null)
            {
                throw new NullReferenceException("The EntitlementsProvider is null so this can't work");
            }

             List<T> items = GetExportedValues<T>(contractName, enableWildCards).ToList();
 
            IEnumerable<Type> types = items.Select(v => v.GetType());
            foreach (T item in items)
            {
                object[] attributes = item.GetType().GetCustomAttributes(typeof (RequiresEntitlementAttribute), true);
                IEnumerable<RequiresEntitlementAttribute> requiresEntitlementAttributes =
                    attributes.Select(a => a as RequiresEntitlementAttribute);
                itemsToReturn.Add(item);
            }
 
            return itemsToReturn;
        }
 
        /// <summary>
        /// It returns lazy collection of passed contract name.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="contractName"></param>
        /// <returns></returns>
        public IEnumerable<Lazy<T>> GetExports<T>(string contractName)
        {
            IEnumerable<Lazy<T>> value = GetExports<T>(contractName, false);
            return value;
        }
 
        /// <summary>
        /// It returns a object of passed type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public IEnumerable<Lazy<T>> GetExports<T>()
        {
            IEnumerable<Lazy<T>> value = GetExports<T>(null, true);
            return value;
        }
 
        /// <summary>
        /// It returns a object of passed contract name.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="contractName"></param>
        /// <returns></returns>
        public Lazy<T> GetExport<T>(string contractName)
        {
            Lazy<T> value = default(Lazy<T>);
            try
            {
                value = Container.GetExport<T>(contractName);
            }
            catch (ImportCardinalityMismatchException e)
            {
                ErrorHandler.HandleError(e, ErrorTypes.CriticalError);
            }
 
            return value;
        }
 
        /// <summary>
        /// It returns an object of passed type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public Lazy<T> GetExport<T>()
        {
            Lazy<T> value = default(Lazy<T>);
            try
            {
                value = Container.GetExport<T>();
            }
            catch (ImportCardinalityMismatchException e)
            {
                ErrorHandler.HandleError(e, ErrorTypes.CriticalError);
            }
            
 
            return value;
        }
 
        public IEnumerable<Lazy<T,TMetadata>> GetExports<T,TMetadata>()
        {
            return this.Container.GetExports<T, TMetadata>();
        } 
 
        /// <summary>
        /// It composes passed object.
        /// </summary>
        /// <param name="attributedPart"></param>
        public void Compose(object attributedPart)
        {

 
            if (attributedPart != null)
            {
                try
                {
                    var batch = new CompositionBatch();
                    batch.AddPart(attributedPart);
                    Container.Compose(batch);
                }
                catch (CompositionException compositionException)
                {
                   ErrorHandelr.HandeError(compositionException);
                }
            }

        }
 
        /// <summary>
        /// This method is called when imports are satisfied.
        /// </summary>
        /// <param name="attributedPart"></param>
        public void SatisfyImports(object attributedPart)
        {
            if (attributedPart != null)
            {
                try
                {
                    var batch = new CompositionBatch();
                    batch.AddPart(attributedPart);
                    Container.SatisfyImportsOnce(batch);
                }
                catch (CompositionException compositionException)
                {
                    ErrorHandler.HandleError(compositionException, ErrorTypes.CriticalError);
                }
            }
        }
 
        /// <summary>
        /// It authenticate current user.
        /// </summary>
        public void Authenticate()
        {
            Assembly infraAssm = Assembly.LoadFrom(Constants.CompositionPath + INFRASTRUCTURE_ASSEMBLY_NAME);
            if (infraAssm != null)
            {
                _aggergate.Catalogs.Add(new AssemblyCatalog(infraAssm));
            }
 
            Assembly authAssm = Assembly.LoadFrom(Constants.CompositionPath + AUTHENTICATION_ASSEMBLY_NAME);
 
            if (authAssm != null)
            {
                _aggergate.Catalogs.Add(new AssemblyCatalog(authAssm));
                LoginManager.LoginCompleted += OnLoginCompleted;
                LoginManager.Login();
            }
            else
            {
                MessageBox.Show("Can't find the Authentication Module");
                SendFail();
            }

        }
 
        /// <summary>
        /// It sends fail method for logging.
        /// </summary>
        private void SendFail()
        {
             if (CompositionFailed != null)
            {
                CompositionFailed(this, EventArgs.Empty);
            }
        }
 
        public void OnLoginCompleted(object sender, LoginCompletedEventArgs e)
        {
            if (e.Message == "Cancel")
            {
                SendFail();
            }
            else if (e.ClientInformation.IsAuthenticated)
            {
                Current.SetClientContext(e.ClientInformation);
                Entitle();
            }

        }
 
 
        /// <summary>
        /// It calls entitlement provider for required keys.
        /// </summary>
        public void Entitle()
        {

            Assembly entitleAssm = Assembly.LoadFrom(Constants.CompositionPath + ENTITLEMENT_ASSEMBLY_NAME);
 
            if (entitleAssm != null)
            {
                _aggergate.Catalogs.Add(new AssemblyCatalog(entitleAssm));
                EntitlementProvider.EntitlementsLoaded += OnEntitlementsLoaded;
                EntitlementProvider.GetEntitlements();
                if (XamlUtility.IsInDesignMode()) return;
            }
            else
            {
                MessageBox.Show("Can't find the Entitlements Module");
                SendFail();
            }

        }
 
        /// <summary>
        /// Its called when entitlements are satisfied.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        internal void OnEntitlementsLoaded(object sender, EventArgs e)
        {
            //this._HasEntitlements = true;
            List<Assembly> assemblies = AppDomain.CurrentDomain.GetAssemblies().ToList();
            _aggergate.Catalogs.Clear();
            var directoryDlls = new DirectoryCatalog(Constants.CompositionPath, "*.dll");
            var directoryExes = new DirectoryCatalog(Constants.CompositionPath, "*.exe");
            foreach (string loadedFile in directoryDlls.LoadedFiles)
            {
                Assembly assm = Assembly.LoadFrom(loadedFile);
 
                assemblies.Remove(assm);
                _aggergate.Catalogs.Add(new AssemblyCatalog(assm));
            }
 
            foreach (string loadedFile in directoryExes.LoadedFiles)
            {
                Assembly assm = Assembly.LoadFrom(loadedFile);
 
                assemblies.Remove(assm);
                _aggergate.Catalogs.Add(new AssemblyCatalog(assm));
            }
 
            assemblies.ForEach(a => _aggergate.Catalogs.Add(new AssemblyCatalog(a)));
            if (FullyComposed == null)
            {
                SendFail();
                return;
            }
 
            FullyComposed(this, EventArgs.Empty);
        }
 
        #endregion
 
    } 

WPF : Determining if user is running same application instance on a terminal server

Please refer to this article in which I showed how we can determine if user is trying to run same application instance, this approach will work on single user Desktop machine, but it will not work when there are multiple users connecting to a terminal server and are trying to run same application. What happens is if a user start application, and then if some other user tries to start same application then it fails saying that application is already running because it doesn't distinguishes 2 users, so in this article I am going to show how we can change the old logic to consider individual user also.

private void Application_Startup(object sender, StartupEventArgs e)
{        

 string processname = Process.GetCurrentProcess().ProcessName + ".exe";

 string currentuserid = GetLoggedInUserName(); //This function should return Loggedin user name, you can put your logic here.
 totaluserapplicationinstance = 0;
 
 System.Management.ManagementObjectSearcher Processes = new System.Management.ManagementObject Searcher("SELECT * FROM Win32_Process Where Name ='" + processname + "'");
               

 foreach (System.Management.ManagementObject process in Processes.Get())
 {
  string[] OwnerInfo = new string[2];
  process.InvokeMethod("GetOwner", (object[])OwnerInfo);
  if (OwnerInfo[0].Equals(currentuserid))
  {
   totaluserapplicationinstance++;
  }
 }
 

 alreadyloggedin = totaluserapplicationinstance > 1;

 if (alreadyloggedin)
 {
  Messagebox.Show("You are already running an instance of same application");
  App.Current.Shutdown();
  return;
 }

}