public CmdletInfo GetCmdletByTypeName(string cmdletTypeName) { if (string.IsNullOrEmpty(cmdletTypeName)) { throw PSTraceSource.NewArgumentNullException("cmdletTypeName"); } Exception exception = null; Type implementingType = LanguagePrimitives.ConvertStringToType(cmdletTypeName, out exception); if (exception != null) { throw exception; } if (implementingType == null) { return(null); } CmdletAttribute attribute = null; foreach (object obj2 in implementingType.GetCustomAttributes(true)) { attribute = obj2 as CmdletAttribute; if (attribute != null) { break; } } if (attribute == null) { throw PSTraceSource.NewNotSupportedException(); } string nounName = attribute.NounName; return(new CmdletInfo(attribute.VerbName + "-" + nounName, implementingType, null, null, this._context)); }
internal void SetRoot(string path) { if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } if (!this.driveBeingCreated) { throw PSTraceSource.NewNotSupportedException(); } this.root = path; }
/// <summary> /// Sets the root of the drive. /// </summary> /// <param name="path"> /// The root path to set for the drive. /// </param> /// <remarks> /// This method can only be called during drive /// creation. A NotSupportedException if this method /// is called outside of drive creation. /// </remarks> /// <exception cref="ArgumentNullException"> /// If <paramref name="path"/> is null. /// </exception> /// <exception cref="NotSupportedException"> /// If this method gets called any other time except /// during drive creation. /// </exception> internal void SetRoot(string path) { if (path == null) { throw PSTraceSource.NewArgumentNullException(nameof(path)); } if (!DriveBeingCreated) { NotSupportedException e = PSTraceSource.NewNotSupportedException(); throw e; } _root = path; }
/// <summary> /// Gets an instance of an ISecurityDescriptorCmdletProvider given the provider ID. /// </summary> /// <param name="providerInstance"> /// An instance of a CmdletProvider. /// </param> /// <returns> /// An instance of a ISecurityDescriptorCmdletProvider for the specified provider ID. /// </returns> /// <throws> /// ArgumentNullException if providerId is null. /// NotSupportedException if the providerId is not for a provider /// that is derived from ISecurityDescriptorCmdletProvider. /// </throws> internal static ISecurityDescriptorCmdletProvider GetPermissionProviderInstance(CmdletProvider providerInstance) { if (providerInstance == null) { throw PSTraceSource.NewArgumentNullException(nameof(providerInstance)); } if (!(providerInstance is ISecurityDescriptorCmdletProvider permissionCmdletProvider)) { throw PSTraceSource.NewNotSupportedException( ProviderBaseSecurity.ISecurityDescriptorCmdletProvider_NotSupported); } return(permissionCmdletProvider); }
public CommandMetadata(CommandInfo commandInfo, bool shouldGenerateCommonParameters) { this._commandName = string.Empty; this._defaultParameterSetName = "__AllParameterSets"; this._positionalBinding = true; this._helpUri = string.Empty; this._remotingCapability = System.Management.Automation.RemotingCapability.PowerShell; this._confirmImpact = System.Management.Automation.ConfirmImpact.Medium; this._otherAttributes = new Collection <Attribute>(); if (commandInfo == null) { throw PSTraceSource.NewArgumentNullException("commandInfo"); } while (commandInfo is AliasInfo) { commandInfo = ((AliasInfo)commandInfo).ResolvedCommand; if (commandInfo == null) { throw PSTraceSource.NewNotSupportedException(); } } CmdletInfo info = commandInfo as CmdletInfo; if (info != null) { this.Init(commandInfo.Name, info.ImplementingType, shouldGenerateCommonParameters); } else { ExternalScriptInfo info2 = commandInfo as ExternalScriptInfo; if (info2 != null) { this.Init(info2.ScriptBlock, info2.Path, shouldGenerateCommonParameters); this._wrappedCommandType = CommandTypes.ExternalScript; } else { FunctionInfo info3 = commandInfo as FunctionInfo; if (info3 == null) { throw PSTraceSource.NewNotSupportedException(); } this.Init(info3.ScriptBlock, info3.Name, shouldGenerateCommonParameters); this._wrappedCommandType = commandInfo.CommandType; } } }
/// <summary> /// Get the cmdlet info using the name of the cmdlet's implementing type. This bypasses /// session state and retrieves the command directly. Note that the help file and snapin/module /// info will both be null on returned object. /// </summary> /// <param name="cmdletTypeName">The type name of the class implementing this cmdlet.</param> /// <returns>CmdletInfo for the cmdlet if found, null otherwise.</returns> public CmdletInfo GetCmdletByTypeName(string cmdletTypeName) { if (string.IsNullOrEmpty(cmdletTypeName)) { throw PSTraceSource.NewArgumentNullException(nameof(cmdletTypeName)); } Exception e = null; Type cmdletType = TypeResolver.ResolveType(cmdletTypeName, out e); if (e != null) { throw e; } if (cmdletType == null) { return(null); } CmdletAttribute ca = null; foreach (var attr in cmdletType.GetCustomAttributes(true)) { ca = attr as CmdletAttribute; if (ca != null) { break; } } if (ca == null) { throw PSTraceSource.NewNotSupportedException(); } string noun = ca.NounName; string verb = ca.VerbName; string cmdletName = verb + "-" + noun; return(new CmdletInfo(cmdletName, cmdletType, null, null, _context)); }
protected override string PropertyToString(PSProperty property) { throw PSTraceSource.NewNotSupportedException(); }
internal CmdletInfo AddCmdletToCache(string name, CmdletInfo cmdlet, CommandOrigin origin, System.Management.Automation.ExecutionContext context) { bool flag = false; try { List <CmdletInfo> list; if (!this.GetCmdlets().TryGetValue(name, out list)) { list = new List <CmdletInfo> { cmdlet }; this.GetCmdlets().Add(name, list); if ((cmdlet.Options & ScopedItemOptions.AllScope) != ScopedItemOptions.None) { this.GetAllScopeCmdlets()[name].Insert(0, cmdlet); } } else { if (!string.IsNullOrEmpty(cmdlet.ModuleName)) { foreach (CmdletInfo info in list) { if (string.Equals(cmdlet.FullName, info.FullName, StringComparison.OrdinalIgnoreCase)) { if (cmdlet.ImplementingType == info.ImplementingType) { return(null); } flag = true; break; } } } else { foreach (CmdletInfo info2 in list) { if (cmdlet.ImplementingType == info2.ImplementingType) { return(null); } flag = true; break; } } if (!flag) { list.Insert(0, cmdlet); } } } catch (ArgumentException) { flag = true; } if (flag) { throw PSTraceSource.NewNotSupportedException("DiscoveryExceptions", "DuplicateCmdletName", new object[] { cmdlet.Name }); } return(this.GetCmdlets()[name][0]); }
public override Pipeline CreateNestedPipeline(string command, bool addToHistory) { throw PSTraceSource.NewNotSupportedException("RemotingErrorIdStrings", PSRemotingErrorId.NestedPipelineNotSupported.ToString(), new object[0]); }
protected override string PropertyType(PSProperty property, bool forDisplay) { throw PSTraceSource.NewNotSupportedException(); }
public override void SuspendJobAsync(bool force, string reason) { throw PSTraceSource.NewNotSupportedException("PowerShellStrings", "ProxyChildJobControlNotSupported", new object[0]); }
protected override void PropertySet(PSProperty property, object setValue, bool convertIfPossible) { throw PSTraceSource.NewNotSupportedException(); }
public override object ConvertTo(object sourceValue, Type destinationType, IFormatProvider formatProvider, bool ignoreCase) { throw PSTraceSource.NewNotSupportedException(); }
protected override bool PropertyIsSettable(PSProperty property) { throw PSTraceSource.NewNotSupportedException(); }
protected override object PropertyGet(PSProperty property) { throw PSTraceSource.NewNotSupportedException(); }
protected override object MethodInvoke(PSMethod method, object[] arguments) { throw PSTraceSource.NewNotSupportedException(); }
protected override Collection <string> MethodDefinitions(PSMethod method) { throw PSTraceSource.NewNotSupportedException(); }
public override void UnblockJobAsync() { throw PSTraceSource.NewNotSupportedException("PowerShellStrings", "ProxyChildJobControlNotSupported", new object[0]); }