Exemplo n.º 1
0
 protected override void ProcessRecord()
 {
     if (this.PSProvider == null || this.PSProvider != null && (int)this.PSProvider.Length == 0)
     {
         base.WriteObject(base.SessionState.Provider.GetAll(), true);
         return;
     }
     else
     {
         string[] pSProvider = this.PSProvider;
         for (int i = 0; i < (int)pSProvider.Length; i++)
         {
             string str = pSProvider[i];
             PSSnapinQualifiedName instance = PSSnapinQualifiedName.GetInstance(str);
             if (instance == null || !WildcardPattern.ContainsWildcardCharacters(instance.ShortName))
             {
                 try
                 {
                     Collection <ProviderInfo> providerInfos = base.SessionState.Provider.Get(str);
                     base.WriteObject(providerInfos, true);
                 }
                 catch (ProviderNotFoundException providerNotFoundException1)
                 {
                     ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
                     base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
                 }
             }
             else
             {
                 WildcardPattern wildcardPattern = new WildcardPattern(instance.ShortName, WildcardOptions.IgnoreCase);
                 foreach (ProviderInfo all in base.SessionState.Provider.GetAll())
                 {
                     if (!all.IsMatch(wildcardPattern, instance))
                     {
                         continue;
                     }
                     base.WriteObject(all);
                 }
             }
         }
         return;
     }
 }
        /// <summary>
        /// Search for provider help based on a search target.
        /// </summary>
        /// <param name="helpRequest">Help request object.</param>
        /// <param name="searchOnlyContent">
        /// If true, searches for pattern in the help content. Individual
        /// provider can decide which content to search in.
        ///
        /// If false, searches for pattern in the command names.
        /// </param>
        /// <returns></returns>
        internal override IEnumerable <HelpInfo> SearchHelp(HelpRequest helpRequest, bool searchOnlyContent)
        {
            int    countOfHelpInfoObjectsFound = 0;
            string target  = helpRequest.Target;
            string pattern = target;
            // this will be used only when searchOnlyContent == true
            WildcardPattern wildCardPattern = null;

            bool decoratedSearch = !WildcardPattern.ContainsWildcardCharacters(target);

            if (!searchOnlyContent)
            {
                if (decoratedSearch)
                {
                    pattern += "*";
                }
            }
            else
            {
                string searchTarget = helpRequest.Target;
                if (decoratedSearch)
                {
                    searchTarget = "*" + helpRequest.Target + "*";
                }

                wildCardPattern = WildcardPattern.Get(searchTarget, WildcardOptions.Compiled | WildcardOptions.IgnoreCase);
                // search in all providers
                pattern = "*";
            }

            PSSnapinQualifiedName snapinQualifiedNameForPattern =
                PSSnapinQualifiedName.GetInstance(pattern);

            if (snapinQualifiedNameForPattern == null)
            {
                yield break;
            }

            foreach (ProviderInfo providerInfo in _sessionState.Provider.GetAll())
            {
                if (providerInfo.IsMatch(pattern))
                {
                    try
                    {
                        LoadHelpFile(providerInfo);
                    }
                    catch (IOException ioException)
                    {
                        if (!decoratedSearch)
                        {
                            ReportHelpFileError(ioException, providerInfo.Name, providerInfo.HelpFile);
                        }
                    }
                    catch (System.Security.SecurityException securityException)
                    {
                        if (!decoratedSearch)
                        {
                            ReportHelpFileError(securityException, providerInfo.Name, providerInfo.HelpFile);
                        }
                    }
                    catch (XmlException xmlException)
                    {
                        if (!decoratedSearch)
                        {
                            ReportHelpFileError(xmlException, providerInfo.Name, providerInfo.HelpFile);
                        }
                    }

                    HelpInfo helpInfo = GetCache(providerInfo.PSSnapInName + "\\" + providerInfo.Name);

                    if (helpInfo != null)
                    {
                        if (searchOnlyContent)
                        {
                            // ignore help objects that do not have pattern in its help
                            // content.
                            if (!helpInfo.MatchPatternInContent(wildCardPattern))
                            {
                                continue;
                            }
                        }

                        countOfHelpInfoObjectsFound++;
                        yield return(helpInfo);

                        if (countOfHelpInfoObjectsFound >= helpRequest.MaxResults && helpRequest.MaxResults > 0)
                        {
                            yield break;
                        }
                    }
                }
            }
        }
        internal List <PSDriveInfo> GetMatchingDrives(string driveName, string[] providerNames, string scope)
        {
            List <PSDriveInfo> pSDriveInfos = new List <PSDriveInfo>();

            if (providerNames == null || (int)providerNames.Length == 0)
            {
                string[] strArrays = new string[1];
                strArrays[0]  = "*";
                providerNames = strArrays;
            }
            string[] strArrays1 = providerNames;
            for (int i = 0; i < (int)strArrays1.Length; i++)
            {
                string   str      = strArrays1[i];
                object[] objArray = new object[1];
                objArray[0] = str;
                CoreCommandBase.tracer.WriteLine("ProviderName: {0}", objArray);
                bool flag  = string.IsNullOrEmpty(str);
                bool flag1 = WildcardPattern.ContainsWildcardCharacters(str);
                bool flag2 = string.IsNullOrEmpty(driveName);
                bool flag3 = WildcardPattern.ContainsWildcardCharacters(driveName);
                if (!flag && !flag1)
                {
                    base.SessionState.Provider.Get(str);
                }
                if (!flag2 && !flag3)
                {
                    if (!string.IsNullOrEmpty(scope))
                    {
                        base.SessionState.Drive.GetAtScope(driveName, scope);
                    }
                    else
                    {
                        base.SessionState.Drive.Get(driveName);
                    }
                }
                WildcardPattern       wildcardPattern = null;
                PSSnapinQualifiedName instance        = null;
                if (!flag)
                {
                    instance = PSSnapinQualifiedName.GetInstance(str);
                    if (instance == null)
                    {
                        goto Label0;
                    }
                    wildcardPattern = new WildcardPattern(instance.ShortName, WildcardOptions.IgnoreCase);
                }
                WildcardPattern wildcardPattern1 = null;
                if (!flag2)
                {
                    wildcardPattern1 = new WildcardPattern(driveName, WildcardOptions.IgnoreCase);
                }
                foreach (PSDriveInfo allAtScope in base.SessionState.Drive.GetAllAtScope(scope))
                {
                    bool flag4 = flag2;
                    if (!base.SuppressWildcardExpansion)
                    {
                        if (wildcardPattern1.IsMatch(allAtScope.Name))
                        {
                            flag4 = true;
                        }
                    }
                    else
                    {
                        if (string.Equals(allAtScope.Name, driveName, StringComparison.OrdinalIgnoreCase))
                        {
                            flag4 = true;
                        }
                    }
                    if (!flag4 || !flag && !allAtScope.Provider.IsMatch(wildcardPattern, instance))
                    {
                        continue;
                    }
                    pSDriveInfos.Add(allAtScope);
                }
Label0:
                continue;
            }
            pSDriveInfos.Sort();
            return(pSDriveInfos);
        }