C# Automation.ProviderInfo类代码示例

 public PSDriveInfo(string name, ProviderInfo provider, string root, string description, PSCredential credential)
 {
     this.credentials = PSCredential.Empty;
     if (name == null)
     {
         throw PSTraceSource.NewArgumentNullException("name");
     }
     if (provider == null)
     {
         throw PSTraceSource.NewArgumentNullException("provider");
     }
     if (root == null)
     {
         throw PSTraceSource.NewArgumentNullException("root");
     }
     this.name = name;
     this.provider = provider;
     this.root = root;
     this.description = description;
     if (credential != null)
     {
         this.credentials = credential;
     }
     this.currentWorkingDirectory = string.Empty;
     this.Trace();
 }

        /// <summary>
        /// Starts the specified provider. This method is called by the Windows PowerShell runtime to initialize the
        /// provider when the provider is loaded into a session.
        /// </summary>
        /// <param name="providerInfo">
        /// A <see cref="ProviderInfo"/> object that describes the provider to be initialized.
        /// </param>
        /// <returns>A <see cref="ProviderInfo"/> object that contains information about the provider.</returns>
        protected override ProviderInfo Start(ProviderInfo providerInfo)
        {
            // Increase console window size
            this.IncreaseWindowSize(120, 50);

            return base.Start(providerInfo);
        }

        public static void ValidateDirectory(ProviderInfo provider, string directory)
        {
            validateFileSystemPath(provider, directory);

            if (!Directory.Exists(directory))
            {
                Exception exception;

                if (File.Exists(directory))
                {
                    exception = new InvalidOperationException($"{directory} is not a directory.");
                    ExceptionHelper.SetUpException(
                                                   ref exception,
                                                   ERR_NO_DIRECTORY,
                                                   ErrorCategory.InvalidOperation,
                                                   directory);
                }
                else
                {
                    exception =
                        new FileNotFoundException(
                            $"The directory {directory} could not be found.");
                    ExceptionHelper.SetUpException(
                                                   ref exception,
                                                   ERR_NO_DIRECTORY,
                                                   ErrorCategory.InvalidData,
                                                   directory);
                }

                throw exception;
            }
        }

 internal PathInfo(PSDriveInfo drive, ProviderInfo provider, Path path, SessionState sessionState)
 {
     Drive = drive;
     Provider = provider;
     _path = path;
     _sessionState = sessionState;
 }

        protected UniversalProviderInfo(ProviderInfo providerInfo) : base(providerInfo) {
            try {
                PropertySheet = PropertySheet.Parse(@"@import ""pstab.properties"";", "default");
            } catch (Exception) {

                PropertySheet = new PropertySheet();
            }
            
        }

 public PSDriveInfo(string name, ProviderInfo provider, string root, string description, PSCredential credential)
 {
     Name = name;
     Provider = provider;
     Root = root;
     Description = description;
     Credential = credential;
     CurrentLocation = string.Empty;
 }

 public AzureDriveInfo(Rule aliasRule, ProviderInfo providerInfo, PSCredential psCredential = null)
     : base(GetDriveInfo(aliasRule, providerInfo, psCredential))
 {
     Path = new Path {
         Account = aliasRule.HasProperty("key") ? aliasRule["key"].Value : aliasRule.Parameter,
         Container = aliasRule.HasProperty("container") ? aliasRule["container"].Value : "",
         SubPath = aliasRule.HasProperty("root") ? aliasRule["root"].Value.Replace('/', '\\').Replace("\\\\", "\\").Trim('\\') : "",
     };
     Path.Validate();
     Secret = aliasRule.HasProperty("secret") ? aliasRule["secret"].Value : psCredential != null ? psCredential.Password.ToString() : null;
 }

 protected ProviderInfo(ProviderInfo providerInfo)
 {
     _sessionState = providerInfo._sessionState;
     PSSnapIn = providerInfo.PSSnapIn;
     Name = providerInfo.Name;
     Description = providerInfo.Description;
     Home = providerInfo.Home;
     ImplementingType = providerInfo.ImplementingType;
     Capabilities = providerInfo.Capabilities;
     HelpFile = providerInfo.HelpFile;
 }

 private static string GetProviderAssemblyPath(ProviderInfo providerInfo)
 {
     if (providerInfo == null)
     {
         return null;
     }
     if (providerInfo.ImplementingType == null)
     {
         return null;
     }
     return Path.GetDirectoryName(providerInfo.ImplementingType.Assembly.Location);
 }

 public static ILocationResolver GetLocationResolver(ProviderInfo providerInfo) {
     var result = providerInfo as ILocationResolver;
     if (result == null) {
         if (providerInfo.Name == "FileSystem") {
             return new FilesystemLocationProvider(providerInfo);
         }
     }
     if (result == null) {
         throw new ClrPlusException("Unable to create location resolver for {0}".format(providerInfo.Name));
     }
     return result;
 }

 internal DirectoryServiceDriveInfo
 (
     String name,
     ProviderInfo provider,
     String description,
     PSCredential credential,
     DirectoryRootInfo rootInfo
 )
     : base(name, provider, name + ':', description, credential)
 {
     _rootInfo = rootInfo;
 }

 private static void validateFileSystemPath(ProviderInfo provider, string directory)
 {
     if (!isFileSystemPath(provider))
     {
         Exception exception = new ArgumentException("The syntax of the command is incorrect.");
         ExceptionHelper.SetUpException(
                                        ref exception,
                                        ERR_BAD_PROVIDER,
                                        ErrorCategory.InvalidArgument,
                                        directory);
         throw exception;
     }
 }

 protected override ProviderInfo Start(ProviderInfo sitecoreProviderInfo)
 {
     try
     {
         sitecoreProviderInfo.Description = "Sitcore Content Provider";
         providerInfo = sitecoreProviderInfo;
         LogInfo("Executing Start(string providerInfo='{0}')", sitecoreProviderInfo.Name);
         return sitecoreProviderInfo;
     }
     catch (Exception ex)
     {
         LogError(ex, "Error while executing Start(string providerInfo='{0}')", sitecoreProviderInfo.Name);
         throw;
     }
 }

 protected ProviderInfo(ProviderInfo providerInfo)
 {
     this.helpFile = "";
     if (providerInfo == null)
     {
         throw PSTraceSource.NewArgumentNullException("providerInfo");
     }
     this.name = providerInfo.Name;
     this.implementingType = providerInfo.ImplementingType;
     this.capabilities = providerInfo.capabilities;
     this.description = providerInfo.description;
     this.hiddenDrive = providerInfo.hiddenDrive;
     this.home = providerInfo.home;
     this.helpFile = providerInfo.helpFile;
     this.pssnapin = providerInfo.pssnapin;
     this.sessionState = providerInfo.sessionState;
 }

 internal PathInfo(PSDriveInfo drive, ProviderInfo provider, string path, SessionState sessionState)
 {
     if (provider == null)
     {
         throw PSTraceSource.NewArgumentNullException("provider");
     }
     if (path == null)
     {
         throw PSTraceSource.NewArgumentNullException("path");
     }
     if (sessionState == null)
     {
         throw PSTraceSource.NewArgumentNullException("sessionState");
     }
     this.drive = drive;
     this.provider = provider;
     this.path = path;
     this.sessionState = sessionState;
 }