C# IServiceProvider.GetType方法代码示例

        /// <summary>
        /// Gets the output window pane corresponding to the package, using the package
        /// <c>GuidAttribute</c> attribute as the pane identifier. The pane title is
        /// determined by the package class <c>DisplayNameAttribute</c> or its namespace
        /// if no display name is provided.
        /// </summary>
        /// <param name="manager">The output window manager.</param>
        /// <param name="package">The owning package.</param>
        /// <returns></returns>
        public static TextWriter GetPane(this IOutputWindowManager manager, IServiceProvider package)
        {
            var title = package.GetType().GetCustomAttributes<DisplayNameAttribute>()
                .Select(d => d.DisplayName)
                .FirstOrDefault() ?? package.GetType().Namespace;

            return GetPane(manager, package, title);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CuteProvider"/> class.
        /// </summary>
        /// <param name="Provider">Provider that will be acting as a back-end for current one</param>
        public CuteProvider(IServiceProvider provider)
            : this()
        {
            if (provider.GetType() == typeof(CuteProvider))
            {
                Original = ((CuteProvider)provider).Original;
                Type = InstanceType.WrappedInput;
            }
            else
            {
                Original = provider;
                Type = InstanceType.BareInput;
            }

            Context = CuteContext.Copy((IPluginExecutionContext)this.Original.GetService(typeof(IPluginExecutionContext)));
        }

        private IServiceLocator InitializeContainer(IServiceProvider services)
        {
            using (tracer.StartActivity(Strings.DevEnvFactory.CreatingComposition))
            {
                // Allow dependencies of VS exported services.
                var composition = services.GetService<SComponentModel, IComponentModel>();

                // Keep track of assemblies we've already added, to avoid duplicate registrations.
                var addedAssemblies = new Dictionary<string, Assembly>();

                // Register built-in components from Clide assembly.
                var clideAssembly = Assembly.GetExecutingAssembly();
                addedAssemblies.Add(clideAssembly.Location.ToLowerInvariant(), clideAssembly);

                // Register hosting package assembly.
                var servicesAssembly = services.GetType().Assembly;
                addedAssemblies[servicesAssembly.Location.ToLowerInvariant()] = servicesAssembly;

                var installPath = GetInstallPath(services);

                var packageManifestFile = Path.Combine(installPath, "extension.vsixmanifest");
                if (File.Exists(packageManifestFile))
                {
                    tracer.Info(Strings.DevEnvFactory.ExtensionManifestFound(packageManifestFile));
                    var manifestDoc = XDocument.Load(packageManifestFile);

                    ThrowIfClideIsMefComponent(manifestDoc);
                    // NOTE: we don't warn anymore in this case, since a single package may have
                    // a mix of plain VS exports as well as clide components.
                    // Since we use CommonComposition, only the types with the ComponentAttribute
                    // will be made available in the Clide container, not the others, and no
                    // duplicates would be registered.
                    //WarnIfClideComponentIsAlsoMefComponent(packageManifestFile, manifestDoc);

                    foreach (string clideComponent in GetClideComponents(manifestDoc))
                    {
                        var assemblyFile = Path.Combine(installPath, clideComponent);
                        tracer.Info(Strings.DevEnvFactory.ClideComponentDeclared(clideComponent, assemblyFile));

                        if (clideComponent == ClideAssembly)
                        {
                            tracer.Warn(Strings.DevEnvFactory.ClideNotNecessaryAsComponent(clideComponent));
                            continue;
                        }

                        if (!File.Exists(assemblyFile))
                            throw new InvalidOperationException(Strings.DevEnvFactory.ClideComponentNotFound(packageManifestFile, clideComponent, assemblyFile));

                        var componentAssembly = Assembly.LoadFrom(assemblyFile);
                        if (!addedAssemblies.ContainsKey(componentAssembly.Location.ToLowerInvariant()))
                            addedAssemblies.Add(componentAssembly.Location.ToLowerInvariant(), componentAssembly);
                    }
                }
                else
                {
                    tracer.Info(Strings.DevEnvFactory.ExtensionManifestNotFound(packageManifestFile));
                }

                var catalog = new ComponentCatalog(addedAssemblies.Values.ToArray());
                var container = new CompositionContainer(catalog,
                    composition.DefaultExportProvider,
                    new ServicesExportProvider(services));

                // Make the service locator itself available as an export.
                var serviceLocator = new ServicesAccessor(services, new Lazy<IServiceLocator>(() => serviceLocators[services]));
                container.ComposeParts(serviceLocator);

                return new ExportsServiceLocator(container);
            }
        }

 private string GetInstallPath(IServiceProvider services)
 {
     return Path.GetDirectoryName(services.GetType().Assembly.ManifestModule.FullyQualifiedName);
 }

 public static void SetServiceLocator(IServiceProvider serviceLocator)
 {
     Logger.LogEvent(string.Format("Setting instance of {0} as a service locator", serviceLocator.GetType().Name), null, ImportanceLevels.gUnimportant);
     _current = serviceLocator;
     Logger.LogEvent(string.Format("Instance of {0} set as a service locator", serviceLocator.GetType().Name), null, ImportanceLevels.gUnimportant);
 }

        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {

            if (provider == null || provider.GetType().FullName != "System.Windows.Forms.PropertyGridInternal.PropertyDescriptorGridEntry")
                return null;

            // First off, does this point to an enum?
            //bool isEnum = 
            // What type are we creating
            //Type creatingType = provider.GetType().GetProperty("PropertyType").GetValue(provider, null) as Type;
            Type creatingType = context.PropertyDescriptor.PropertyType;
            object[] propertyAttributes = context.Instance.GetType().GetProperty(context.PropertyDescriptor.Name).GetCustomAttributes(typeof(PropertyAttribute), true);

            // Get the ListBox control
            object lb = CreateControl(creatingType, propertyAttributes, value);

            // Create a service
            Type serviceType = lb.GetType().Assembly.GetType("System.Windows.Forms.Design.IWindowsFormsEditorService");
            object service = provider.GetService(serviceType);
            

            // Drop down the control
            serviceType.GetMethod("DropDownControl").Invoke(service, new object[] { lb });

            if (lb.GetType().GetProperty("SelectedItem") != null && lb.GetType().GetProperty("SelectedItem").GetValue(lb, null) == null)
                value = null;
            else if (lb.GetType().GetProperty("SelectedItem") != null && lb.GetType().GetProperty("SelectedItem").GetValue(lb, null).ToString() == "Create new Instance")
                value = creatingType.Assembly.CreateInstance(creatingType.FullName);
            else if (lb.GetType().GetProperty("SelectedItem") != null) // We don't know what type they want.. yet
            {
                object selectedItem = lb.GetType().GetProperty("SelectedItem").GetValue(lb, null);
                if (selectedItem is string)
                    value = null;
                else
                    value = (selectedItem as CreateTypeReference).Type.Assembly.CreateInstance((selectedItem as CreateTypeReference).Type.FullName);
            }
            else if (lb.GetType().GetProperty("Text") != null && lb.GetType().GetProperty("Text").GetValue(lb, null).ToString().Length > 0) // Textual
            {
                object tmp = lb.GetType().GetProperty("Text").GetValue(lb, null);
                // Look for the ctor
                foreach (MethodInfo mi in creatingType.GetMethods(BindingFlags.Public | BindingFlags.Static))
                    if (mi.Name == "op_Implicit" && mi.GetParameters()[0].ParameterType == typeof(System.String)) // Use a text box!
                    {
                        value = mi.Invoke(null, new object[] { tmp });
                        break;
                    }
            }

            serviceType.GetMethod("CloseDropDown").Invoke(service, null);

            return value;
        }

        /// <summary>
        /// Displays a list of available values for the specified component than sets the value.
        /// </summary>
        /// <param name="context">An ITypeDescriptorContext that can be used to gain additional context information.</param>
        /// <param name="provider">A service provider object through which editing services may be obtained.</param>
        /// <param name="value">An instance of the value being edited.</param>
        /// <returns>The new value of the object. If the value of the object hasn't changed, this method should return the same object it was passed.</returns>
        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            if (provider != null)
            {
                // This service is in charge of popping our ListBox.
                var service1 = ((IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService)));

                if (service1 != null)
                {
                    // This is an internal Microsoft class representing the PropertyGrid entry for our component.
                    if (provider.GetType().FullName == "System.Windows.Forms.PropertyGridInternal.PropertyDescriptorGridEntry")
                    {
                        var list = new PropertiesList(context);
                        // Drop the list control.
                        service1.DropDownControl(list);

                        if (list.SelectedIndices.Count == 1)
                        {
                            value = list.SelectedItem.ToString();
                        }
                        // Close the list control after selection.
                        service1.CloseDropDown();
                    }
                }
            }

            return value;
        }