//actual constructor work, but hidden to not be used accidently in a stupid way private SessionState(SessionStateGlobal sessionStateGlobal, SessionState parent) { SessionStateGlobal = sessionStateGlobal; var parentAliasScope = parent == null ? null : parent._aliasScope; var parentFunctionScope = parent == null ? null : parent._functionScope; var parentVariableScope = parent == null ? null : parent._variableScope; var parentDriveScope = parent == null ? null : parent._driveScope; var parentModuleScope = parent == null ? null : parent._moduleScope; var parentCmdletScope = parent == null ? null : parent._cmdletScope; _aliasScope = new SessionStateScope <AliasInfo>(this, parentAliasScope, SessionStateCategory.Alias); _functionScope = new SessionStateScope <FunctionInfo>(this, parentFunctionScope, SessionStateCategory.Function); _variableScope = new SessionStateScope <PSVariable>(this, parentVariableScope, SessionStateCategory.Variable); _driveScope = new SessionStateScope <PSDriveInfo>(this, parentDriveScope, SessionStateCategory.Drive); _moduleScope = new SessionStateScope <PSModuleInfo>(this, parentModuleScope, SessionStateCategory.Module); _cmdletScope = new SessionStateScope <CmdletInfo>(this, parentCmdletScope, SessionStateCategory.Cmdlet); IsScriptScope = false; Function = new FunctionIntrinsics(_functionScope); Alias = new AliasIntrinsics(_aliasScope); Drive = new DriveManagementIntrinsics(_driveScope); Path = new PathIntrinsics(this); PSVariable = new PSVariableIntrinsics(_variableScope); LoadedModules = new ModuleIntrinsics(_moduleScope); Cmdlet = new CmdletIntrinsics(_cmdletScope); }
internal static string GetModuleName(string path) { string path1 = path == null ? string.Empty : Path.GetFileName(path); string extension = Path.GetExtension(path1); return(!string.IsNullOrEmpty(extension) && ModuleIntrinsics.IsPowerShellModuleExtension(extension) ? path1.Substring(0, path1.Length - extension.Length) : path1); }
private void InitializeCommon(AutomationEngine engine, PSHost hostInterface) { this._engine = engine; if (!_assemblyEventHandlerSet) { lock (lockObject) { if (!_assemblyEventHandlerSet) { AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(ExecutionContext.PowerShellAssemblyResolveHandler); _assemblyEventHandlerSet = true; } } } this._debugger = new System.Management.Automation.Debugger(this); this.eventManager = new PSLocalEventManager(this); this.transactionManager = new PSTransactionManager(); this.myHostInterface = hostInterface as System.Management.Automation.Internal.Host.InternalHost; if (this.myHostInterface == null) { this.myHostInterface = new System.Management.Automation.Internal.Host.InternalHost(hostInterface, this); } this._assemblyCache = new Dictionary <string, Assembly>(); this._topLevelSessionState = this._engineSessionState = new SessionStateInternal(this); if (this._authorizationManager == null) { this._authorizationManager = new System.Management.Automation.AuthorizationManager(null); } this._modules = new ModuleIntrinsics(this); }
/// <summary> /// Gets the extended search paths for about_topics help. To be able to get about_topics help from unloaded modules, /// we will add $pshome and the folders under PS module paths to the collection of paths to search. /// </summary> /// <returns>A collection of string representing locations.</returns> internal Collection <string> GetExtendedSearchPaths() { Collection <string> searchPaths = GetSearchPaths(); // Add $pshome at the top of the list string defaultShellSearchPath = GetDefaultShellSearchPath(); int index = searchPaths.IndexOf(defaultShellSearchPath); if (index != 0) { if (index > 0) { searchPaths.RemoveAt(index); } searchPaths.Insert(0, defaultShellSearchPath); } // Add the CurrentUser help path. searchPaths.Add(HelpUtils.GetUserHomeHelpSearchPath()); // Add modules that are not loaded. Since using 'get-module -listavailable' is very expensive, // we load all the directories (which are not empty) under the module path. foreach (string psModulePath in ModuleIntrinsics.GetModulePath(false, this.HelpSystem.ExecutionContext)) { if (Directory.Exists(psModulePath)) { try { // Get all the directories under the module path // * and SearchOption.AllDirectories gets all the version directories. string[] directories = Directory.GetDirectories(psModulePath, "*", SearchOption.AllDirectories); var possibleModuleDirectories = directories.Where(static directory => !ModuleUtils.IsPossibleResourceDirectory(directory));
/// <summary> /// Gets the extended search paths for about_topics help. To be able to get about_topics help from unloaded modules, /// we will add $pshome and the folders under PS module paths to the collection of paths to search. /// </summary> /// <returns>A collection of string representing locations.</returns> internal Collection <string> GetExtendedSearchPaths() { Collection <string> searchPaths = GetSearchPaths(); // Add $pshome at the top of the list string defaultShellSearchPath = GetDefaultShellSearchPath(); int index = searchPaths.IndexOf(defaultShellSearchPath); if (index != 0) { if (index > 0) { searchPaths.RemoveAt(index); } searchPaths.Insert(0, defaultShellSearchPath); } // Add the CurrentUser help path. searchPaths.Add(HelpUtils.GetUserHomeHelpSearchPath()); // Add modules that are not loaded. Since using 'get-module -listavailable' is very expensive, // we load all the directories (which are not empty) under the module path. foreach (string psModulePath in ModuleIntrinsics.GetModulePath(false, this.HelpSystem.ExecutionContext)) { if (Directory.Exists(psModulePath)) { try { // Get all the directories under the module path // * and SearchOption.AllDirectories gets all the version directories. string[] directories = Directory.GetDirectories(psModulePath, "*", SearchOption.AllDirectories); var possibleModuleDirectories = directories.Where(directory => !ModuleUtils.IsPossibleResourceDirectory(directory)); foreach (string directory in possibleModuleDirectories) { // Add only directories that are not empty if (Directory.EnumerateFiles(directory).Any()) { if (!searchPaths.Contains(directory)) { searchPaths.Add(directory); } } } } // Absorb any exception related to enumerating directories catch (System.ArgumentException) { } catch (System.IO.IOException) { } catch (System.UnauthorizedAccessException) { } catch (System.Security.SecurityException) { } } } return(searchPaths); }
internal PSModuleInfo CreateModule( string path, ExternalScriptInfo scriptInfo, Token callerToken, SessionState ss, params object[] arguments) { return(this.CreateModuleImplementation(ModuleIntrinsics.GetModuleName(path), path, (object)scriptInfo, callerToken, ss, out ArrayList _, arguments)); }
/// <summary> /// Gets the specified module path from the appropriate Environment entry in the registry. /// </summary> /// <param name="scope"></param> /// <returns>The specified module path. Null if not present.</returns> internal override string GetModulePath(PropertyScope scope) { if (PropertyScope.CurrentUser == scope) { return(ModuleIntrinsics.GetExpandedEnvironmentVariable("PSMODULEPATH", EnvironmentVariableTarget.User)); } else { return(ModuleIntrinsics.GetExpandedEnvironmentVariable("PSMODULEPATH", EnvironmentVariableTarget.Machine)); } }
internal static void SetModulePath() { string environmentVariable1 = ModuleIntrinsics.GetExpandedEnvironmentVariable("PSMODULEPATH", EnvironmentVariableTarget.Process); string environmentVariable2 = ModuleIntrinsics.GetExpandedEnvironmentVariable("PSMODULEPATH", EnvironmentVariableTarget.Machine); string environmentVariable3 = ModuleIntrinsics.GetExpandedEnvironmentVariable("PSMODULEPATH", EnvironmentVariableTarget.User); string str1; if (environmentVariable1 == null) { string str2 = (environmentVariable3 ?? ModuleIntrinsics.GetPersonalModulePath()) + (object)';'; str1 = environmentVariable2 != null ? str2 + environmentVariable2 : str2 + ModuleIntrinsics.GetSystemwideModulePath(); } else if (environmentVariable2 != null) { if (environmentVariable3 == null) { if (!environmentVariable2.Equals(environmentVariable1, StringComparison.OrdinalIgnoreCase)) { return; } str1 = ModuleIntrinsics.GetPersonalModulePath() + (object)';' + environmentVariable2; } else { string str2 = environmentVariable3 + (object)';' + environmentVariable2; if (!str2.Equals(environmentVariable1, StringComparison.OrdinalIgnoreCase) && !environmentVariable2.Equals(environmentVariable1, StringComparison.OrdinalIgnoreCase) && !environmentVariable3.Equals(environmentVariable1, StringComparison.OrdinalIgnoreCase)) { return; } str1 = str2; } } else { if (environmentVariable3 == null || !environmentVariable3.Equals(environmentVariable1, StringComparison.OrdinalIgnoreCase)) { return; } str1 = environmentVariable3 + (object)';' + ModuleIntrinsics.GetSystemwideModulePath(); } Environment.SetEnvironmentVariable("PSMODULEPATH", str1); }
internal PSModuleInfo( string name, string path, ExecutionContext context, SessionState sessionState) { this._context = context; if (path != null) { string resolvedPath = ModuleCmdletBase.GetResolvedPath(path, this._context); this._path = resolvedPath == null ? path : resolvedPath; } this._name = name != null || this._path == null ? name : ModuleIntrinsics.GetModuleName(this._path); this._sessionState = sessionState; if (sessionState == null) { return; } sessionState.Internal.Module = this; }
internal PSModuleInfo(string name, string path, ExecutionContext context, System.Management.Automation.SessionState sessionState) { this._name = string.Empty; this._path = string.Empty; this._description = string.Empty; this._version = new System.Version(0, 0); this._detectedFunctionExports = new List <string>(); this._detectedWorkflowExports = new List <string>(); this._detectedCmdletExports = new List <string>(); this._compiledExports = new List <CmdletInfo>(); this._fileList = new List <string>(); this._moduleList = new Collection <object>(); this._nestedModules = new List <PSModuleInfo>(); this._scripts = new List <string>(); this._requiredAssemblies = new Collection <string>(); this._requiredModules = new List <PSModuleInfo>(); this._requiredModulesSpecification = new List <ModuleSpecification>(); this._detectedAliasExports = new Dictionary <string, string>(); this._exportedFormatFiles = new ReadOnlyCollection <string>(new List <string>()); this._exportedTypeFiles = new ReadOnlyCollection <string>(new List <string>()); if (path != null) { string resolvedPath = ModuleCmdletBase.GetResolvedPath(path, context); this._path = resolvedPath ?? path; } this._sessionState = sessionState; if (sessionState != null) { sessionState.Internal.Module = this; } if (name == null) { this._name = ModuleIntrinsics.GetModuleName(this._path); } else { this._name = name; } }
internal static IEnumerable <string> GetModulePath(ExecutionContext context) { List <string> stringList = new List <string>(); string environmentVariable = Environment.GetEnvironmentVariable("PSMODULEPATH"); if (environmentVariable == null) { ModuleIntrinsics.SetModulePath(); environmentVariable = Environment.GetEnvironmentVariable("PSMODULEPATH"); } if (environmentVariable.Trim().Length == 0) { return((IEnumerable <string>)stringList); } string str1 = environmentVariable; char[] separator = new char[1] { ';' }; foreach (string pattern in str1.Split(separator, StringSplitOptions.RemoveEmptyEntries)) { try { ProviderInfo provider = (ProviderInfo)null; IEnumerable <string> providerPathFromPsPath = (IEnumerable <string>)context.SessionState.Path.GetResolvedProviderPathFromPSPath(WildcardPattern.Escape(pattern), out provider); if (provider.NameEquals(context.ProviderNames.FileSystem)) { foreach (string str2 in providerPathFromPsPath) { stringList.Add(str2); } } } catch (ItemNotFoundException ex) { } } return((IEnumerable <string>)stringList); }
internal static DirectoryInfo CreateModuleDirectory(PSCmdlet cmdlet, string moduleNameOrPath, bool force) { DirectoryInfo targetObject = null; try { string str = ModuleCmdletBase.ResolveRootedFilePath(moduleNameOrPath, cmdlet.Context); if (string.IsNullOrEmpty(str) && moduleNameOrPath.StartsWith(".", StringComparison.OrdinalIgnoreCase)) { str = Path.Combine(cmdlet.CurrentProviderLocation(cmdlet.Context.ProviderNames.FileSystem).ProviderPath, moduleNameOrPath); } if (string.IsNullOrEmpty(str)) { str = Path.Combine(ModuleIntrinsics.GetPersonalModulePath(), moduleNameOrPath); } targetObject = new DirectoryInfo(str); if (targetObject.Exists) { if (!force) { ErrorDetails details = new ErrorDetails(string.Format(CultureInfo.InvariantCulture, PathUtilsStrings.ExportPSSession_ErrorDirectoryExists, new object[] { targetObject.FullName })); ErrorRecord errorRecord = new ErrorRecord(new ArgumentException(details.Message), "ExportProxyCommand_OutputDirectoryExists", ErrorCategory.ResourceExists, targetObject); cmdlet.ThrowTerminatingError(errorRecord); } return(targetObject); } targetObject.Create(); } catch (Exception exception) { CommandProcessorBase.CheckForSevereException(exception); ErrorDetails details2 = new ErrorDetails(string.Format(CultureInfo.InvariantCulture, PathUtilsStrings.ExportPSSession_CannotCreateOutputDirectory, new object[] { moduleNameOrPath, exception.Message })); ErrorRecord record2 = new ErrorRecord(new ArgumentException(details2.Message, exception), "ExportProxyCommand_CannotCreateOutputDirectory", ErrorCategory.ResourceExists, moduleNameOrPath); cmdlet.ThrowTerminatingError(record2); } return(targetObject); }
internal static DirectoryInfo CreateModuleDirectory(PSCmdlet cmdlet, string moduleNameOrPath, bool force) { Dbg.Assert(cmdlet != null, "Caller should verify cmdlet != null"); Dbg.Assert(!string.IsNullOrEmpty(moduleNameOrPath), "Caller should verify !string.IsNullOrEmpty(moduleNameOrPath)"); DirectoryInfo directoryInfo = null; try { string rootedPath = Microsoft.PowerShell.Commands.ModuleCmdletBase.ResolveRootedFilePath(moduleNameOrPath, cmdlet.Context); if (string.IsNullOrEmpty(rootedPath) && moduleNameOrPath.StartsWith('.')) { PathInfo currentPath = cmdlet.CurrentProviderLocation(cmdlet.Context.ProviderNames.FileSystem); rootedPath = Path.Combine(currentPath.ProviderPath, moduleNameOrPath); } if (string.IsNullOrEmpty(rootedPath)) { string personalModuleRoot = ModuleIntrinsics.GetPersonalModulePath(); rootedPath = Path.Combine(personalModuleRoot, moduleNameOrPath); } directoryInfo = new DirectoryInfo(rootedPath); if (directoryInfo.Exists) { if (!force) { string errorMessage = string.Format( CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant PathUtilsStrings.ExportPSSession_ErrorDirectoryExists, directoryInfo.FullName); ErrorDetails details = new ErrorDetails(errorMessage); ErrorRecord errorRecord = new ErrorRecord( new ArgumentException(details.Message), "ExportProxyCommand_OutputDirectoryExists", ErrorCategory.ResourceExists, directoryInfo); cmdlet.ThrowTerminatingError(errorRecord); } } else { directoryInfo.Create(); } } catch (Exception e) { string errorMessage = string.Format( CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant PathUtilsStrings.ExportPSSession_CannotCreateOutputDirectory, moduleNameOrPath, e.Message); ErrorDetails details = new ErrorDetails(errorMessage); ErrorRecord errorRecord = new ErrorRecord( new ArgumentException(details.Message, e), "ExportProxyCommand_CannotCreateOutputDirectory", ErrorCategory.ResourceExists, moduleNameOrPath); cmdlet.ThrowTerminatingError(errorRecord); } return(directoryInfo); }
private Collection <string> FilterToLatestModuleVersion(Collection <string> filesMatched) { Collection <string> matchedFilesToRemove = new Collection <string>(); if (filesMatched.Count > 1) { //Dictionary<<ModuleName,fileName>, <Version, helpFileFullName>> Dictionary <Tuple <string, string>, Tuple <string, Version> > modulesAndVersion = new Dictionary <Tuple <string, string>, Tuple <string, Version> >(); HashSet <string> filesProcessed = new HashSet <string>(); var allPSModulePaths = ModuleIntrinsics.GetModulePath(false, this.HelpSystem.ExecutionContext); foreach (string fileFullName in filesMatched) { // Use the filename as a check if we need to process further. // Single module can have multiple .help.txt files. var fileName = Path.GetFileName(fileFullName); foreach (string psModulePath in allPSModulePaths) { Version moduleVersionFromPath = null; string moduleName = null; GetModuleNameAndVersion(psModulePath, fileFullName, out moduleName, out moduleVersionFromPath); //Skip modules whose root we cannot determine or which do not have versions. if (moduleVersionFromPath != null && moduleName != null) { Tuple <string, Version> moduleVersion = null; Tuple <string, string> key = new Tuple <string, string>(moduleName, fileName); if (modulesAndVersion.TryGetValue(key, out moduleVersion)) { //Consider for further processing only if the help file name is same. if (filesProcessed.Contains(fileName)) { if (moduleVersionFromPath > moduleVersion.Item2) { modulesAndVersion[key] = new Tuple <string, Version>(fileFullName, moduleVersionFromPath); //Remove the old file since we found a newer version. matchedFilesToRemove.Add(moduleVersion.Item1); } else { //Remove the new file as higher version item is already in dictionary. matchedFilesToRemove.Add(fileFullName); } } } else { //Add the module to the dictionary as it was not processes earlier. modulesAndVersion.Add(new Tuple <string, string>(moduleName, fileName), new Tuple <string, Version>(fileFullName, moduleVersionFromPath)); } } } filesProcessed.Add(fileName); } } return(matchedFilesToRemove); }
internal static void ExportModuleMembers( PSCmdlet cmdlet, SessionStateInternal sessionState, List <WildcardPattern> functionPatterns, List <WildcardPattern> cmdletPatterns, List <WildcardPattern> aliasPatterns, List <WildcardPattern> variablePatterns) { sessionState.UseExportList = true; if (functionPatterns != null) { foreach (KeyValuePair <string, FunctionInfo> keyValuePair in (IEnumerable <KeyValuePair <string, FunctionInfo> >)sessionState.ModuleScope.FunctionTable) { if (SessionStateUtilities.MatchesAnyWildcardPattern(keyValuePair.Key, (IEnumerable <WildcardPattern>)functionPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingFunction", (object)keyValuePair.Key); cmdlet.WriteVerbose(text); sessionState.ExportedFunctions.Add(keyValuePair.Value); } } ModuleIntrinsics.SortAndRemoveDuplicates <FunctionInfo>(sessionState.ExportedFunctions, (Converter <FunctionInfo, string>)(ci => ci.Name)); } if (cmdletPatterns != null) { IDictionary <string, List <CmdletInfo> > cmdletCache = (IDictionary <string, List <CmdletInfo> >)sessionState.CmdletCache; if (sessionState.Module.CompiledExports.Count > 0) { CmdletInfo[] array = sessionState.Module.CompiledExports.ToArray(); sessionState.Module.CompiledExports.Clear(); foreach (CmdletInfo cmdletInfo1 in array) { if (SessionStateUtilities.MatchesAnyWildcardPattern(cmdletInfo1.Name, (IEnumerable <WildcardPattern>)cmdletPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingCmdlet", (object)cmdletInfo1.Name); cmdlet.WriteVerbose(text); CmdletInfo cmdletInfo2 = new CmdletInfo(cmdletInfo1.Name, cmdletInfo1.ImplementingType, cmdletInfo1.HelpFile, (PSSnapInInfo)null, cmdletInfo1.Context); cmdletInfo2.SetModule(sessionState.Module); sessionState.Module.CompiledExports.Add(cmdletInfo2); } } } foreach (KeyValuePair <string, List <CmdletInfo> > keyValuePair in (IEnumerable <KeyValuePair <string, List <CmdletInfo> > >)cmdletCache) { if (SessionStateUtilities.MatchesAnyWildcardPattern(keyValuePair.Key, (IEnumerable <WildcardPattern>)cmdletPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingCmdlet", (object)keyValuePair.Key); cmdlet.WriteVerbose(text); CmdletInfo cmdletInfo1 = keyValuePair.Value[0]; CmdletInfo cmdletInfo2 = new CmdletInfo(cmdletInfo1.Name, cmdletInfo1.ImplementingType, cmdletInfo1.HelpFile, (PSSnapInInfo)null, cmdletInfo1.Context); cmdletInfo2.SetModule(sessionState.Module); sessionState.Module.CompiledExports.Add(cmdletInfo2); } } ModuleIntrinsics.SortAndRemoveDuplicates <CmdletInfo>(sessionState.Module.CompiledExports, (Converter <CmdletInfo, string>)(ci => ci.Name)); } if (variablePatterns != null) { foreach (KeyValuePair <string, PSVariable> variable in (IEnumerable <KeyValuePair <string, PSVariable> >)sessionState.ModuleScope.Variables) { if (!variable.Value.IsAllScope && Array.IndexOf <string>(PSModuleInfo.builtinVariables, variable.Key) == -1 && SessionStateUtilities.MatchesAnyWildcardPattern(variable.Key, (IEnumerable <WildcardPattern>)variablePatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingVariable", (object)variable.Key); cmdlet.WriteVerbose(text); sessionState.ExportedVariables.Add(variable.Value); } } ModuleIntrinsics.SortAndRemoveDuplicates <PSVariable>(sessionState.ExportedVariables, (Converter <PSVariable, string>)(v => v.Name)); } if (aliasPatterns == null) { return; } foreach (AliasInfo aliasInfo in sessionState.ModuleScope.AliasTable) { if ((aliasInfo.Options & ScopedItemOptions.AllScope) == ScopedItemOptions.None && SessionStateUtilities.MatchesAnyWildcardPattern(aliasInfo.Name, (IEnumerable <WildcardPattern>)aliasPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingAlias", (object)aliasInfo.Name); cmdlet.WriteVerbose(text); sessionState.ExportedAliases.Add(aliasInfo); } } ModuleIntrinsics.SortAndRemoveDuplicates <AliasInfo>(sessionState.ExportedAliases, (Converter <AliasInfo, string>)(ci => ci.Name)); }
internal ModuleIntrinsics(ExecutionContext context) { this._context = context; ModuleIntrinsics.SetModulePath(); }
internal static DirectoryInfo CreateModuleDirectory(PSCmdlet cmdlet, string moduleNameOrPath, bool force) { Dbg.Assert(cmdlet != null, "Caller should verify cmdlet != null"); Dbg.Assert(!string.IsNullOrEmpty(moduleNameOrPath), "Caller should verify !string.IsNullOrEmpty(moduleNameOrPath)"); DirectoryInfo directoryInfo = null; try { // Even if 'moduleNameOrPath' is a rooted path, 'ResolveRootedFilePath' may return null when the path doesn't exist yet, // or when it contains wildcards but cannot be resolved to a single path. string rootedPath = ModuleCmdletBase.ResolveRootedFilePath(moduleNameOrPath, cmdlet.Context); if (string.IsNullOrEmpty(rootedPath) && moduleNameOrPath.StartsWith('.')) { PathInfo currentPath = cmdlet.CurrentProviderLocation(cmdlet.Context.ProviderNames.FileSystem); rootedPath = Path.Combine(currentPath.ProviderPath, moduleNameOrPath); } if (string.IsNullOrEmpty(rootedPath)) { if (Path.IsPathRooted(moduleNameOrPath)) { rootedPath = moduleNameOrPath; } else { string personalModuleRoot = ModuleIntrinsics.GetPersonalModulePath(); if (string.IsNullOrEmpty(personalModuleRoot)) { cmdlet.ThrowTerminatingError( new ErrorRecord( new ArgumentException(StringUtil.Format(PathUtilsStrings.ExportPSSession_ErrorModuleNameOrPath, moduleNameOrPath)), "ExportPSSession_ErrorModuleNameOrPath", ErrorCategory.InvalidArgument, cmdlet)); } rootedPath = Path.Combine(personalModuleRoot, moduleNameOrPath); } } directoryInfo = new DirectoryInfo(rootedPath); if (directoryInfo.Exists) { if (!force) { string errorMessage = string.Format( CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant PathUtilsStrings.ExportPSSession_ErrorDirectoryExists, directoryInfo.FullName); ErrorDetails details = new ErrorDetails(errorMessage); ErrorRecord errorRecord = new ErrorRecord( new ArgumentException(details.Message), "ExportProxyCommand_OutputDirectoryExists", ErrorCategory.ResourceExists, directoryInfo); cmdlet.ThrowTerminatingError(errorRecord); } } else { directoryInfo.Create(); } } catch (Exception e) { string errorMessage = string.Format( CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant PathUtilsStrings.ExportPSSession_CannotCreateOutputDirectory, moduleNameOrPath, e.Message); ErrorDetails details = new ErrorDetails(errorMessage); ErrorRecord errorRecord = new ErrorRecord( new ArgumentException(details.Message, e), "ExportProxyCommand_CannotCreateOutputDirectory", ErrorCategory.ResourceExists, moduleNameOrPath); cmdlet.ThrowTerminatingError(errorRecord); } return(directoryInfo); }