public override bool GenerateDynamicParameters() { var thisIsFirstObject = false; try { if (!IsReentrantLocked) { // we're not locked at this point. Let's turn on the lock. IsReentrantLocked = true; thisIsFirstObject = true; try { // do all the work that we need to during the lock // this includes: // one-time-per-call work // any access to MyInvocation.MyCommand.* // modifying parameter validation sets // if (MyInvocation != null && MyInvocation.MyCommand != null && MyInvocation.MyCommand.Parameters != null) { GetType().AddOrSet(MyInvocation.MyCommand.Parameters, "MyInvocation.MyCommand.Parameters"); } #if DEEP_DEBUG else { if (MyInvocation == null) { Console.WriteLine("»»» Attempt to get parameters MyInvocation == NULL"); } else { if (MyInvocation.MyCommand == null) { Console.WriteLine("»»» Attempt to get parameters MyCommand == NULL"); } else { Console.WriteLine("»»» Attempt to get parameters Parameters == NULL"); } } } #endif // the second time, it will generate all the parameters, including the dynamic ones. // (not that we currently need it, but if you do, you gotta do it here!) // var all_parameters = MyInvocation.MyCommand.Parameters; // ask for the unbound arguments. var unbound = UnboundArguments; if (unbound.ContainsKey("ProviderName") || unbound.ContainsKey("Provider")) { var pName = unbound.ContainsKey("ProviderName")?unbound["ProviderName"]:unbound["Provider"]; if (pName != null) { if (pName.GetType().IsArray) { ProviderName = pName as string[] ?? (((object[])pName).Select(p => p.ToString()).ToArray()); } else { ProviderName = new[] { pName.ToString() }; } // a user specifies -providerName _isUserSpecifyOneProviderName = (ProviderName.Count() == 1); } } // we've now got a copy of the arguments that aren't bound // and we can potentially narrow the provider selection based // on arguments the user specified. if (null == CachedSelectedProviders || IsFailingEarly || IsCanceled) { #if DEEP_DEBUG Console.WriteLine("»»» Cancelled before we got finished doing dynamic parameters"); #endif // this happens if there is a serious failure early in the cmdlet // i.e. - if the SelectedProviders comes back empty (due to agressive filtering) // in this case, we just want to provide a catch-all for remaining arguments so that we can make // output the error that we really want to (that the user specified conditions that filtered them all out) DynamicParameterDictionary.Add("RemainingArguments", new RuntimeDefinedParameter("RemainingArguments", typeof(object), new Collection <Attribute> { new ParameterAttribute() { ValueFromRemainingArguments = true }, })); } // at this point, we're actually calling to have the dynamic parameters generated // that are expected to be used. return(ActualGenerateDynamicParameters(unbound)); } finally { IsReentrantLocked = false; } } // otherwise just call the AGDP because we're in a reentrant call. // and this might be needed if the original call had some strange need // to know what the parameters that it's about to generate would be. // Yeah, you heard me. return(ActualGenerateDynamicParameters(null)); } finally { if (thisIsFirstObject) { // clean up our once-per-call data. GetType().Remove <PackageProvider[]>("CachedSelectedProviders"); GetType().Remove <Dictionary <string, ParameterMetadata> >("MyInvocation.MyCommand.Parameters"); GetType().Remove <DynamicOption[]>("CachedDynamicOptions"); } } // return true; }