public SampleDesignerHost(IServiceProvider parentProvider)
 {
     this.serviceContainer = new ServiceContainer(parentProvider);
     this.designerTable = new Hashtable();
     this.sites = new Hashtable(CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);
     this.loadingDesigner = false;
     this.transactionCount = 0;
     this.reloading = false;
     this.serviceContainer.AddService(typeof(IDesignerHost), this);
     this.serviceContainer.AddService(typeof(IContainer), this);
     this.serviceContainer.AddService(typeof(IComponentChangeService), this);
     this.serviceContainer.AddService(typeof(IExtenderProviderService), this);
     this.serviceContainer.AddService(typeof(IDesignerEventService), this);
     CodeDomComponentSerializationService codeDomComponentSerializationService = new CodeDomComponentSerializationService(this.serviceContainer);
     if (codeDomComponentSerializationService != null)
     {
         this.serviceContainer.RemoveService(typeof(ComponentSerializationService), false);
         this.serviceContainer.AddService(typeof(ComponentSerializationService), codeDomComponentSerializationService);
     }
     ServiceCreatorCallback callback = new ServiceCreatorCallback(this.OnCreateService);
     this.serviceContainer.AddService(typeof(IToolboxService), callback);
     this.serviceContainer.AddService(typeof(ISelectionService), callback);
     this.serviceContainer.AddService(typeof(ITypeDescriptorFilterService), callback);
     this.serviceContainer.AddService(typeof(IMenuCommandService), callback);
     this.serviceContainer.AddService(typeof(IDesignerSerializationService), callback);
     ((IExtenderProviderService) this).AddExtenderProvider(new SampleNameExtenderProvider(this));
     ((IExtenderProviderService) this).AddExtenderProvider(new SampleInheritedNameExtenderProvider(this));
 }

        /// <summary>
        /// Adds the specified service to the service container.
        /// </summary>
        /// <param name="serviceType">The type of service to add.</param>
        /// <param name="callback">A callback object that is used to create the service. This allows a service to be declared as available, but delays the creation of the object until the service is requested.</param>
        public void AddService(Type serviceType, ServiceCreatorCallback callback)
        {
            Guard.NotNull(() => serviceType, serviceType);
            Guard.NotNull(() => callback, callback);

            this.services.Add(serviceType, callback);
        }

 internal CommonPackage()
 {
     IServiceContainer container = this as IServiceContainer;
     ServiceCreatorCallback callback = new ServiceCreatorCallback(CreateService);
     //container.AddService(GetLanguageServiceType(), callback, true);
     container.AddService(GetLibraryManagerType(), callback, true);
 }

	public void AddService
				(Type serviceType, ServiceCreatorCallback callback,
				 bool promote)
			{
				// Validate the parameters.
				if(serviceType == null)
				{
					throw new ArgumentNullException("serviceType");
				}
				if(callback == null)
				{
					throw new ArgumentNullException("callback");
				}

				// Promote the service to the parent if necessary.
				if(promote && parentProvider != null)
				{
					IServiceContainer parent;
					parent = (IServiceContainer)(parentProvider.GetService
						(typeof(IServiceContainer)));
					if(parent != null)
					{
						parent.AddService(serviceType, callback, promote);
						return;
					}
				}

				// Add the service to this container.
				table[serviceType] = callback;
			}

        /// <summary>
        /// Default constructor of the package.
        /// The package is not yet sited inside Visual Studio, so this is the place
        /// for any setup that doesn't need the VS environment.
        /// Here we register our service, so that it will be available to any other
        /// packages by the time their Initialize is called.
        /// </summary>
        public PlotterServicePackage()
        {
            Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering constructor for: {0}", this.ToString()));

            var serviceContainer = this as IServiceContainer;
            var serviceCreator = new ServiceCreatorCallback(CreatePlotterService);
            serviceContainer.AddService(typeof(SPlotter2DService), serviceCreator, true);            
        }

        /// <summary>
        /// Default constructor of the package.
        /// Inside this method you can place any initialization code that does not require 
        /// any Visual Studio service because at this point the package object is created but 
        /// not sited yet inside Visual Studio environment. The place to do all the other 
        /// initialization is the Initialize method.
        /// </summary>
        public VsExtAutoShelvePackage()
        {
            Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering constructor for: {0}", this));

            IServiceContainer serviceContainer = this as IServiceContainer;
            ServiceCreatorCallback callback = new ServiceCreatorCallback(CreateService);
            serviceContainer.AddService(typeof(SAutoShelveService), callback, true);
            //serviceContainer.AddService(typeof(SMyLocalService), callback); 
        }

        public void AddService(Type serviceType, ServiceCreatorCallback callback, bool shouldDisposeServiceInstance)
        {
            // Create the description of this service. Note that we don't do any validation
            // of the parameter here because the constructor of ServiceData will do it for us.
            ServiceData service = new ServiceData(serviceType, null, callback, shouldDisposeServiceInstance);

            // Now add the service desctription to the dictionary.
            AddService(service);
        }

 /// <summary>
 /// Default constructor of the package.
 /// Inside this method you can place any initialization code that does not require 
 /// any Visual Studio service, because at this point the package object is created but 
 /// not sited yet inside the Visual Studio environment. The place to do all the other 
 /// initialization is the Initialize method.
 /// </summary>
 public PythonConsolePackage()
 {
     // This package has to proffer the IronPython engine provider as a Visual Studio
     // service. Note that for performance reasons we don't actually create any object here,
     // but instead we register a callback function that will create the object the first
     // time this package will receive a request for the service.
     IServiceContainer container = this as IServiceContainer;
     ServiceCreatorCallback callback = new ServiceCreatorCallback(CreateService);
     container.AddService(typeof(IPythonEngineProvider), callback, true);
 }

 void IPackage.Initialize(IServiceProvider serviceProvider)
 {
     this._serviceProvider = serviceProvider;
     IServiceContainer service = (IServiceContainer) this._serviceProvider.GetService(typeof(IServiceContainer));
     if (service != null)
     {
         ServiceCreatorCallback callback = new ServiceCreatorCallback(this.OnCreateService);
         service.AddService(typeof(IClassViewService), callback);
     }
 }

 /// <summary>
 /// Default constructor of the package.
 /// Inside this method you can place any initialization code that does not require 
 /// any Visual Studio service, because at this point the package object is created but 
 /// not sited yet inside the Visual Studio environment. The place to do all the other 
 /// initialization is the Initialize method.
 /// </summary>
 public PythonConsolePackage()
 {
     Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering constructor for: {0}", this.ToString()));
     // This package has to proffer the IronPython engine provider as a Visual Studio
     // service. Note that for performance reasons we don't actually create any object here,
     // but instead we register a callback function that will create the object the first
     // time this package will receive a request for the service.
     IServiceContainer container = this as IServiceContainer;
     ServiceCreatorCallback callback = new ServiceCreatorCallback(CreateService);
     container.AddService(typeof(IPythonEngineProvider), callback, true);
 }

            public ServiceData(Type serviceType, object instance, ServiceCreatorCallback callback, bool shouldDispose) {
                Utilities.ArgumentNotNull("serviceType", serviceType);

                if ((null == instance) && (null == callback)) {
                    throw new ArgumentNullException("instance");
                }

                this.serviceType = serviceType;
                this.instance = instance;
                this.creator = callback;
                this.shouldDispose = shouldDispose;
            }

        /// <summary>
        /// Default constructor of the package.
        /// Inside this method you can place any initialization code that does not require 
        /// any Visual Studio service because at this point the package object is created but 
        /// not sited yet inside Visual Studio environment. The place to do all the other 
        /// initialization is the Initialize method.
        /// </summary>
        public SharpOnlyPkgPackage()
        {
            Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering constructor for: {0}", this.ToString()));

            // Init service...
            IServiceContainer serviceContainer = this as IServiceContainer;
            ServiceCreatorCallback callback =
               new ServiceCreatorCallback(CreateService);

            serviceContainer.AddService(typeof(MSBuildTaskService), callback, true);
            serviceContainer.AddService(typeof(SharpBuildService), callback, true);
            serviceContainer.AddService(typeof(SharpBuildDeployService), callback, true);
        }

		/// <summary>
		/// Adds the specified service to the service container.
		/// </summary>
		/// <param name="serviceType">The type of service to add.</param>
		/// <param name="callback">A callback object that is used to create the service. This allows a service to be declared as available, but delays the creation of the object until the service is requested.</param>
		public void AddService(Type serviceType, ServiceCreatorCallback callback)
		{
			if (serviceType == null)
				throw new ArgumentNullException("serviceType");
 
			if (callback == null)
				throw new ArgumentNullException("callback");
 
			if (_services.Contains(serviceType))
				throw new ArgumentException("Service already exists.", "serviceType");

			_services[serviceType] = callback;
		}

 public DesignSurface(IServiceProvider parentProvider)
 {
     this._parentProvider = parentProvider;
     this._serviceContainer = new DesignSurfaceServiceContainer(this._parentProvider);
     ServiceCreatorCallback callback = new ServiceCreatorCallback(this.OnCreateService);
     this.ServiceContainer.AddService(typeof(ISelectionService), callback);
     this.ServiceContainer.AddService(typeof(IExtenderProviderService), callback);
     this.ServiceContainer.AddService(typeof(IExtenderListService), callback);
     this.ServiceContainer.AddService(typeof(ITypeDescriptorFilterService), callback);
     this.ServiceContainer.AddService(typeof(IReferenceService), callback);
     this.ServiceContainer.AddService(typeof(DesignSurface), this);
     this._host = new DesignerHost(this);
 }

        public void AddService(string serviceName, ServiceCreatorCallback creatorCallback, bool promote)
        {
            Require.NotNullOrEmptyString("serviceName", serviceName); // $NON-NLS-1

            if (this.servicesByName.ContainsKey(serviceName))
                throw RuntimeFailure.ServiceAlreadyExists("serviceName", serviceName);

            this.servicesByName.Add(serviceName, creatorCallback);

            if (promote) {
                IServiceContainerExtension ice = this.ParentContainer as IServiceContainerExtension;
                if (ice != null)
                    ice.AddService(serviceName, creatorCallback, true);
            }
        }

		public void AddService1 ()
		{
			object service;
			ServiceContainer parent;
			ServiceContainer sc;

			object serviceInstance1 = new ArrayList ();
			object serviceInstance2 = new Hashtable ();
			object callback1 = new ServiceCreatorCallback (
				Svc.ServiceCreator);

			sc = new ServiceContainer ();
			sc.AddService (typeof (ICollection), serviceInstance1);
			sc.AddService (typeof (IEnumerable), serviceInstance2);
			sc.AddService (typeof (Svc), callback1);

			service = sc.GetService (typeof (ICollection));
			Assert.IsNotNull (service, "#A1");
			Assert.AreSame (serviceInstance1, service, "#A2");

			service = sc.GetService (typeof (IEnumerable));
			Assert.IsNotNull (service, "#B1");
			Assert.AreSame (serviceInstance2, service, "#B2");

			service = sc.GetService (typeof (ArrayList));
			Assert.IsNull (service, "#C1");

			service = sc.GetService (typeof (ICloneable));
			Assert.IsNull (service, "#D1");

			Assert.AreEqual (0, Svc.TotalObjectsCreatedByCallback, "#E1");
			service = sc.GetService (typeof (Svc));
			Assert.IsNotNull (service, "#E2");
			Assert.IsTrue (service is Svc, "#E3");
			Assert.AreEqual (1, Svc.TotalObjectsCreatedByCallback, "#E4");
			Assert.AreSame (service, sc.GetService (typeof (Svc)), "#E5");
			Assert.AreEqual (1, Svc.TotalObjectsCreatedByCallback, "#E6");

			parent = new ServiceContainer ();
			sc = new ServiceContainer (parent);

			sc.AddService (typeof (ICollection), serviceInstance1);

			Assert.AreSame (serviceInstance1, sc.GetService (typeof (ICollection)), "#F1");
			Assert.IsNull (parent.GetService (typeof (ICollection)), "#F2");
		}

            public void AddService( Type serviceType, ServiceCreatorCallback callback, bool promote )
            {
                if ( promote && parentContainer != null )
                {
                    parentContainer.AddService( serviceType, callback, promote );
                    return;
                }

                lock ( syncRoot )
                {
                    if ( services.ContainsKey( serviceType ) )
                    {
                        var message = DataAnnotationsResources.ServiceAlreadyExists.FormatDefault( serviceType );
                        throw new ArgumentException( message, "serviceType" );
                    }

                    services.Add( serviceType, callback );
                }
            }

        protected override void Initialize()
        {
            base.Initialize();

            //PLEASE NOTE THE FOLLOWING CODE IS ADDED TO MAKE THE SPECIFIC DESIGNER TYPE INTERNAL
            //This is a work around for invoke workflow so that the ActivityHostDesignerType does not become public
            //Please refer to file WorkflowInlining.cs
            Type invokeWorkflowType = Type.GetType(InvokeWorkflowDesigner.InvokeWorkflowRef);
            if (invokeWorkflowType != null)
                TypeDescriptor.AddAttributes(invokeWorkflowType, new DesignerAttribute(typeof(InvokeWorkflowDesigner), typeof(IDesigner)));

            //Add all the services, it is important to make sure that if user pushes the services then we honor
            //those services
            LoaderHost.AddService(typeof(WorkflowDesignerLoader), this);

            ServiceCreatorCallback callback = new ServiceCreatorCallback(OnCreateService);
            if (LoaderHost.GetService(typeof(IWorkflowCompilerOptionsService)) == null)
                LoaderHost.AddService(typeof(IWorkflowCompilerOptionsService), callback);

            if (LoaderHost.GetService(typeof(IIdentifierCreationService)) == null)
                LoaderHost.AddService(typeof(IIdentifierCreationService), callback);

            if (LoaderHost.GetService(typeof(ComponentSerializationService)) == null)
                LoaderHost.AddService(typeof(ComponentSerializationService), callback);

            LoaderHost.RemoveService(typeof(IReferenceService));
            if (LoaderHost.GetService(typeof(IReferenceService)) == null)
                LoaderHost.AddService(typeof(IReferenceService), callback);

            if (LoaderHost.GetService(typeof(IDesignerVerbProviderService)) == null)
                LoaderHost.AddService(typeof(IDesignerVerbProviderService), callback);

            //Add all the extenders, the extenders are responsible to add the extended properties which are not
            //actual properties on activity
            IExtenderProviderService extenderProviderService = GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
            if (extenderProviderService != null)
            {
                foreach (IExtenderProvider extender in ComponentDispenser.Extenders)
                    extenderProviderService.AddExtenderProvider(extender);
            }

            this.customActivityDesignerAdapter = new CustomActivityDesignerAdapter(LoaderHost);
        }

        protected BabelPackage()
        {
            ServiceCreatorCallback callback = new ServiceCreatorCallback(
                delegate(IServiceContainer container, Type serviceType)
                {
                    if (typeof(BlenXLanguageService) == serviceType)
                    {
                        BlenXLanguageService language = new BlenXLanguageService(this);
                        language.SetSite(this);

                        // register for idle time callbacks
                        IOleComponentManager mgr = GetService(typeof(SOleComponentManager)) as IOleComponentManager;
                        if (componentID == 0 && mgr != null)
                        {
                            OLECRINFO[] crinfo = new OLECRINFO[1];
                            crinfo[0].cbSize = (uint)Marshal.SizeOf(typeof(OLECRINFO));
                            crinfo[0].grfcrf = (uint)_OLECRF.olecrfNeedIdleTime |
                                                          (uint)_OLECRF.olecrfNeedPeriodicIdleTime;
                            crinfo[0].grfcadvf = (uint)_OLECADVF.olecadvfModal |
                                                          (uint)_OLECADVF.olecadvfRedrawOff |
                                                          (uint)_OLECADVF.olecadvfWarningsOff;
                            crinfo[0].uIdleTimeInterval = 1000;
                            int hr = mgr.FRegisterComponent(this, crinfo, out componentID);
                        }

                        return language;
                    }
                    else
                    {
                        return null;
                    }
                });

            // proffer the LanguageService
            (this as IServiceContainer).AddService(typeof(BlenXLanguageService), callback, true);
        }

			public void AddService (Type serviceType, ServiceCreatorCallback callback)
			{
				AddService (serviceType, callback, false);
			}