title: C# Singleton Pattern and MEF
body: <p>I have a question about the Singleton Pattern and MEF. I'm new in implementing MEF Plugins and I haven't found an answer. </p>
  
  <p>Is it possible to provide only one instance of a class through a MEF implemented Plugin?</p>
  
  <p>My old class is something like this:</p>
  
  <pre><code>
    #region Singleton
    /// 
    /// This class provide a generic and thread-safe interface for Singleton classes.
    /// 
    /// The specialized singleton which is derived
    /// from SingletonBase&lt;T&gt;
    public abstract class Base where T : Base
    {
      /* the lock object */
      private static object _lock = new object();
  
      /* the static instance */
      private static T _instance = null;
      /// 
      /// Get the unique instance of .
      /// This property is thread-safe!
      /// 
      public static T Instance
      {
        get
        {
          if (_instance == null)
          {
            lock (_lock)
            {
              if (_instance == null)
              {
                /* Create a object without to use new (where you need a public ctor) */
                object obj = FormatterServices.GetUninitializedObject(typeof(T));
                if (obj != null)  // just 4 safety, but i think obj == null shouldn't be possible
                {
                  /* an extra test of the correct type is redundant,
                   * because we have an uninitialised object of type == typeof(T) */
                  _instance = obj as T;
                  _instance.Init(); // now the singleton will be initialized
                }
              }
            }
          }
          else
          {
            _instance.Refresh();  // has only effect if overridden in sub class
          }
          return _instance;
        }
      }
  
  
      /// 
      /// Called while instantiation of singleton sub-class.
      /// This could be used to set some default stuff in the singleton.
      /// 
      protected virtual void Init()
      { }
  
      /// 
      /// If overridden this will called on every request of the Instance but
      /// the instance was already created. Refresh will not called during
      /// the first instantiation, for this will call Init.
      /// 
      protected virtual void Refresh()
      { }
    }
    #endregion
  
    #region class
    public class xy : Base
    {
      private bool run;
  
      public xy()
      {
        this.run = false;
      }
  
      public bool isRunning()
      {
        return this.run;
      }
  
      public void start()
      {
        // Do some stuff
        this.run = true;
      }
    }
    #endregion
  </code></pre>
  
  <p>Can someone provide me an example?</p>