public override bool GenerateDynamicParameters() { var packageProvider = SelectProviders(ProviderName).ReEnumerable(); // if more than one provider is selected, this will never work if (packageProvider.Count() != 1) { return(false); } // if the provider is selected, we can get package metadata keys from the provider foreach (var md in packageProvider.First().GetDynamicOptions(OptionCategory.Source, this)) { if (DynamicParameterDictionary.ContainsKey(md.Name)) { // for now, we're just going to mark the existing parameter as also used by the second provider to specify it. (DynamicParameterDictionary[md.Name] as CustomRuntimeDefinedParameter).Options.Add(md); } else { DynamicParameterDictionary.Add(md.Name, new CustomRuntimeDefinedParameter(md)); } } return(true); }
public override bool GenerateDynamicParameters() { // if the provider (or source) is selected, we can get package metadata keys from the provider //var providers = SelectedProviders.ToArray(); if (_reentrancyLock.WaitOne(0)) { // we're in here already. // this happens because we're asking for the parameters below, and it creates a new instance to get them. // we don't want dynamic parameters for that call, so let's get out. return(true); } _reentrancyLock.Set(); try { foreach (var md in SelectedProviders.SelectMany(provider => _optionCategories.SelectMany(category => provider.GetDynamicOptions(category, this)))) { // check if the dynamic parameter is a static parameter first. // this can happen if we make a common dynamic parameter into a proper static one // and a provider didn't know that yet. if (MyInvocation.MyCommand.Parameters.ContainsKey(md.Name)) { // don't add it. continue; } // foreach (var md in _optionCategories.SelectMany(category => providers.SelectMany(provider => provider.GetDynamicOptions(category, this)))) { if (DynamicParameterDictionary.ContainsKey(md.Name)) { // todo: if the dynamic parameters from two providers aren't compatible, then what? // for now, we're just going to mark the existing parameter as also used by the second provider to specify it. (DynamicParameterDictionary[md.Name] as CustomRuntimeDefinedParameter).Options.Add(md); } else { DynamicParameterDictionary.Add(md.Name, new CustomRuntimeDefinedParameter(md)); } } } finally { _reentrancyLock.Reset(); } return(true); }
public override bool GenerateDynamicParameters() { var packageProvider = PackageManagementService.SelectProviders(ProviderName, this).FirstOrDefault(); if (packageProvider == null) { return(false); } // if the provider is selected, we can get package metadata keys from the provider foreach (var md in packageProvider.GetDynamicOptions(OptionCategory.Source, this)) { if (DynamicParameterDictionary.ContainsKey(md.Name)) { // for now, we're just going to mark the existing parameter as also used by the second provider to specify it. (DynamicParameterDictionary[md.Name] as CustomRuntimeDefinedParameter).Options.Add(md); } else { DynamicParameterDictionary.Add(md.Name, new CustomRuntimeDefinedParameter(md)); } } return(true); }
protected bool ActualGenerateDynamicParameters(Dictionary <string, object> unboundArguments) { if (CachedStaticParameters == null) { // we're in the second call, we're just looking to find out what the static parameters actually are. // we're gonna just skip generating the dynamic parameters on this call. return(true); } try { unboundArguments = unboundArguments ?? new Dictionary <string, object>(); // if there are unbound arguments that are owned by a provider, we can narrow the rest of the // arguments to just ones that are connected with that provider var dynamicOptions = CachedDynamicOptions; var keys = unboundArguments.Keys.ToArray(); if (keys.Length > 0) { var acceptableProviders = CachedDynamicOptions.Where(option => keys.ContainsAnyOfIgnoreCase(option.Name)).Select(option => option.ProviderName).Distinct().ToArray(); if (acceptableProviders.Length > 0) { dynamicOptions = dynamicOptions.Where(option => acceptableProviders.Contains(option.ProviderName)).ToArray(); } } // generate the common parameters for our cmdlets (timeout, messagehandler, etc) GenerateCommonDynamicParameters(); // generate parameters that are specific to the cmdlet being implemented. GenerateCmdletSpecificParameters(unboundArguments); var staticParameters = GetType().Get <Dictionary <string, ParameterMetadata> >("MyInvocation.MyCommand.Parameters"); foreach (var md in dynamicOptions) { if (DynamicParameterDictionary.ContainsKey(md.Name)) { // todo: if the dynamic parameters from two providers aren't compatible, then what? // for now, we're just going to mark the existing parameter as also used by the second provider to specify it. var crdp = DynamicParameterDictionary[md.Name] as CustomRuntimeDefinedParameter; if (crdp == null) { // the package provider is trying to overwrite a parameter that is already dynamically defined by the BaseCmdlet. // just ignore it. continue; } if (IsInvocation) { // this is during an actual execution crdp.Options.Add(md); } else { // this is for metadata sake. (get-help, etc) crdp.IncludeInParameterSet(md, IsInvocation, ParameterSets); } } else { // check if the dynamic parameter is a static parameter first. // this can happen if we make a common dynamic parameter into a proper static one // and a provider didn't know that yet. if (staticParameters != null && staticParameters.ContainsKey(md.Name)) { // don't add it. continue; } DynamicParameterDictionary.Add(md.Name, new CustomRuntimeDefinedParameter(md, IsInvocation, ParameterSets)); } } } catch (Exception e) { e.Dump(); } return(true); }
public override bool GenerateDynamicParameters() { if (_reentrancyLock.WaitOne(0)) { // we're in here already. // this happens because we're asking for the parameters below, and it creates a new instance to get them. // we don't want dynamic parameters for that call, so let's get out. return(true); } _reentrancyLock.Set(); // generate the common parameters for our cmdlets (timeout, messagehandler, etc) GenerateCommonDynamicParameters(); var providers = SelectProviders(ProviderName).ReEnumerable(); // if more than one provider is selected, this will never work if (providers.Count() != 1) { return(false); } var provider = providers.First(); try { // if the provider is selected, we can get package metadata keys from the provider foreach (var md in provider.GetDynamicOptions(OptionCategory.Source, this)) { if (MyInvocation.MyCommand.Parameters.ContainsKey(md.Name)) { // don't add it. continue; } if (DynamicParameterDictionary.ContainsKey(md.Name)) { // for now, we're just going to mark the existing parameter as also used by the second provider to specify it. var crdp = DynamicParameterDictionary[md.Name] as CustomRuntimeDefinedParameter; if (crdp == null) { // the provider is trying to overwrite a parameter that is already dynamically defined by the BaseCmdlet. // just ignore it. continue; } if (IsInvocation) { crdp.Options.Add(md); } else { crdp.IncludeInParameterSet(md, IsInvocation, ParameterSets); } } else { DynamicParameterDictionary.Add(md.Name, new CustomRuntimeDefinedParameter(md, IsInvocation, ParameterSets)); } } } finally { _reentrancyLock.Reset(); } return(true); }