private static void WarnAboutUnsupportedActionPreferences(
            Cmdlet cmdlet,
            ActionPreference effectiveActionPreference,
            string nameOfCommandLineParameter,
            Func<string> inquireMessageGetter,
            Func<string> stopMessageGetter)
        {
            string message;
            switch (effectiveActionPreference)
            {
                case ActionPreference.Stop:
                    message = stopMessageGetter();
                    break;

                case ActionPreference.Inquire:
                    message = inquireMessageGetter();
                    break;

                default:
                    return; // we can handle everything that is not Stop or Inquire
            }

            bool actionPreferenceComesFromCommandLineParameter = cmdlet.MyInvocation.BoundParameters.ContainsKey(nameOfCommandLineParameter);
            if (actionPreferenceComesFromCommandLineParameter)
            {
                Exception exception = new ArgumentException(message);
                ErrorRecord errorRecord = new ErrorRecord(exception, "ActionPreferenceNotSupportedByCimCmdletAdapter", ErrorCategory.NotImplemented, null);
                cmdlet.ThrowTerminatingError(errorRecord);
            }
        }

 internal CmdletParameterBinderController(Cmdlet cmdlet, CommandMetadata commandMetadata, ParameterBinderBase parameterBinder)
     : base(cmdlet.MyInvocation, cmdlet.Context, parameterBinder)
 {
     this._warningSet = new HashSet<string>();
     this._useDefaultParameterBinding = true;
     this._delayBindScriptBlocks = new Dictionary<MergedCompiledCommandParameter, DelayedScriptBlockArgument>();
     this._defaultParameterValues = new Dictionary<string, CommandParameterInternal>(StringComparer.OrdinalIgnoreCase);
     if (cmdlet == null)
     {
         throw PSTraceSource.NewArgumentNullException("cmdlet");
     }
     if (commandMetadata == null)
     {
         throw PSTraceSource.NewArgumentNullException("commandMetadata");
     }
     this.Command = cmdlet;
     this._commandRuntime = (MshCommandRuntime)cmdlet.CommandRuntime;
     this._commandMetadata = commandMetadata;
     if (commandMetadata.ImplementsDynamicParameters)
     {
         base.UnboundParameters = base.BindableParameters.ReplaceMetadata(commandMetadata.StaticCommandParameterMetadata);
         base.BindableParameters.GenerateParameterSetMappingFromMetadata(commandMetadata.DefaultParameterSetName);
     }
     else
     {
         base._bindableParameters = commandMetadata.StaticCommandParameterMetadata;
         base.UnboundParameters = new List<MergedCompiledCommandParameter>(base._bindableParameters.BindableParameters.Values);
     }
 }

 public void Write(Cmdlet cmd, string response)
 {
     foreach (var writer in Writers)
     {
         writer.Write(cmd, response);
     }
 }

 internal CmdletProviderContext(CmdletProviderContext contextToCopyFrom)
 {
     this.credentials = PSCredential.Empty;
     this._origin = CommandOrigin.Internal;
     this.accumulatedObjects = new Collection<PSObject>();
     this.accumulatedErrorObjects = new Collection<ErrorRecord>();
     this.stopReferrals = new Collection<CmdletProviderContext>();
     if (contextToCopyFrom == null)
     {
         throw PSTraceSource.NewArgumentNullException("contextToCopyFrom");
     }
     this.executionContext = contextToCopyFrom.ExecutionContext;
     this.command = contextToCopyFrom.command;
     if (contextToCopyFrom.Credential != null)
     {
         this.credentials = contextToCopyFrom.Credential;
     }
     this.drive = contextToCopyFrom.Drive;
     this.force = (bool) contextToCopyFrom.Force;
     this.CopyFilters(contextToCopyFrom);
     this.suppressWildcardExpansion = contextToCopyFrom.SuppressWildcardExpansion;
     this.dynamicParameters = contextToCopyFrom.DynamicParameters;
     this._origin = contextToCopyFrom._origin;
     this.stopping = contextToCopyFrom.Stopping;
     contextToCopyFrom.StopReferrals.Add(this);
     this.copiedContext = contextToCopyFrom;
 }

        /// <summary>
        /// Process the exception that was thrown and write the error details.
        /// </summary>
        /// <param name="cmdlet">The cmdlet for which to write the error output.</param>
        /// <param name="clientRequestId">The unique id for this request.</param>
        /// <param name="exception">The exception that was thrown.</param>
        public static void WriteErrorDetails(
            Cmdlet cmdlet,
            string clientRequestId,
            Exception exception)
        {
            string requestId;
            ErrorRecord errorRecord = RetrieveExceptionDetails(exception, out requestId);

            // Write the request Id as a warning
            if (requestId != null)
            {
                // requestId was availiable from the server response, write that as warning to the
                // console.
                cmdlet.WriteWarning(string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.ExceptionRequestId,
                    requestId));
            }
            else
            {
                // requestId was not availiable from the server response, write the client Ids that
                // was sent.
                cmdlet.WriteWarning(string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.ExceptionClientSessionId,
                    SqlDatabaseCmdletBase.clientSessionId));
                cmdlet.WriteWarning(string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.ExceptionClientRequestId,
                    clientRequestId));
            }

            // Write the actual errorRecord containing the exception details
            cmdlet.WriteError(errorRecord);
        }

 private string BuildMessage(Cmdlet cmdlet, string baseName, string resourceId, params object[] args)
 {
     if (cmdlet == null)
     {
         throw PSTraceSource.NewArgumentNullException("cmdlet");
     }
     if (string.IsNullOrEmpty(baseName))
     {
         throw PSTraceSource.NewArgumentNullException("baseName");
     }
     if (string.IsNullOrEmpty(resourceId))
     {
         throw PSTraceSource.NewArgumentNullException("resourceId");
     }
     string template = "";
     try
     {
         template = cmdlet.GetResourceString(baseName, resourceId);
     }
     catch (MissingManifestResourceException exception)
     {
         this._textLookupError = exception;
         return "";
     }
     catch (ArgumentException exception2)
     {
         this._textLookupError = exception2;
         return "";
     }
     return this.BuildMessage(template, baseName, resourceId, args);
 }

        public void Write(Cmdlet cmd, string response)
        {
            var doc = new XmlDocument();
            doc.LoadXml(response);

            cmd.WriteObject(doc.DocumentElement);
        }

 /// <summary>
 /// Constructs the parameter binder with the specified type metadata. The binder is only valid
 /// for a single instance of a bindable object and only for the duration of a command.
 /// </summary>
 /// 
 /// <param name="target">
 /// The target object that the parameter values will be bound to.
 /// </param>
 /// 
 /// <param name="command">
 /// An instance of the command so that attributes can access the context.
 /// </param>
 /// 
 /// <param name="commandLineParameters">
 /// The dictionary to use to record the parameters set by this object...
 /// </param>
 /// 
 internal ReflectionParameterBinder(
     object target,
     Cmdlet command,
     CommandLineParameters commandLineParameters)
     : base(target, command.MyInvocation, command.Context, command)
 {
     this.CommandLineParameters = commandLineParameters;
 }

 /// <summary>
 /// Internal Constructor
 /// </summary>
 /// <param name="childJob">Job associated with this operation</param>
 /// <param name="wmiObject">object associated with this operation</param>
 /// <param name="computerName"> computer on which the operation is invoked </param>
 /// <param name="results"> sink to get wmi objects </param>
 internal WmiAsyncCmdletHelper(PSWmiChildJob childJob, Cmdlet wmiObject, string computerName, ManagementOperationObserver results)
 {
     _wmiObject = wmiObject;
     _computerName = computerName;
     _results = results;
     this.State = WmiState.NotStarted;
     _job = childJob;
 }

 internal static Encoding Convert(Cmdlet cmdlet, string encoding)
 {
     if (string.IsNullOrEmpty(encoding)
         || (string.Equals(encoding, "unknown", StringComparison.OrdinalIgnoreCase)
             || string.Equals(encoding, "string", StringComparison.OrdinalIgnoreCase))
         || string.Equals(encoding, "unicode", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.Unicode;
     }
     if (string.Equals(encoding, "bigendianunicode", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.BigEndianUnicode;
     }
     if (string.Equals(encoding, "ascii", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.ASCII;
     }
     if (string.Equals(encoding, "utf8", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.UTF8;
     }
     if (string.Equals(encoding, "utf7", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.UTF7;
     }
     if (string.Equals(encoding, "utf32", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.UTF32;
     }
     if (string.Equals(encoding, "default", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.Default;
     }
     if (string.Equals(encoding, "oem", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.GetEncoding((int) NativeMethods.GetOEMCP());
     }
     var str = string.Join(
         ", ",
         "unknown",
         "string",
         "unicode",
         "bigendianunicode",
         "ascii",
         "utf8",
         "utf7",
         "utf32",
         "default",
         "oem");
     var message = StringUtil.Format(PathUtilStrings.OutFile_WriteToFileEncodingUnknown, encoding, str);
     cmdlet.ThrowTerminatingError(
         new ErrorRecord(
             ExceptionUtils.NewArgumentException("Encoding"),
             "WriteToFileEncodingUnknown",
             ErrorCategory.InvalidArgument,
             null) {ErrorDetails = new ErrorDetails(message)});
     return null;
 }

 internal ChildItemCmdletProviderIntrinsics(Cmdlet cmdlet)
 {
     if (cmdlet == null)
     {
         throw PSTraceSource.NewArgumentNullException("cmdlet");
     }
     this.cmdlet = cmdlet;
     this.sessionState = cmdlet.Context.EngineSessionState;
 }

        public CmdletLogger(Cmdlet cmdlet)
        {
            _cmdlet = cmdlet;

            _name = (from attr in _cmdlet.GetType().GetCustomAttributes(true)
                     let cmdletattr = attr as CmdletAttribute
                     where null != cmdletattr
                     select cmdletattr.NounName + "-" + cmdletattr.VerbName).FirstOrDefault()
                     ?? "Unknown Cmdlet";
        }

        } // CmdletProviderIntrinsics private


        /// <summary>
        /// Constructs a facade over the "real" session state API
        /// </summary>
        ///
        /// <param name="cmdlet">
        /// An instance of the cmdlet.
        /// </param>
        ///
        /// <exception cref="ArgumentNullException">
        /// If <paramref name="cmdlet"/> is null.
        /// </exception>
        /// 
        internal ContentCmdletProviderIntrinsics(Cmdlet cmdlet)
        {
            if (cmdlet == null)
            {
                throw PSTraceSource.NewArgumentNullException("cmdlet");
            }

            _cmdlet = cmdlet;
            _sessionState = cmdlet.Context.EngineSessionState;
        } // ContentCmdletProviderIntrinsics internal

 /// <summary>
 /// First phase of cmdlet lifecycle: "Binding Parameters that Take Command-Line Input"
 /// </summary>
 public override void Prepare()
 {
     Cmdlet cmdlet = (Cmdlet)Activator.CreateInstance(_cmdletInfo.ImplementingType);
     cmdlet.CommandInfo = _cmdletInfo;
     cmdlet.ExecutionContext = base.ExecutionContext;
     cmdlet.CommandRuntime = CommandRuntime;
     Command = cmdlet;
     MergeParameters();
     _argumentBinder = new CmdletParameterBinder(_cmdletInfo, Command);
     _argumentBinder.BindCommandLineParameters(Parameters);
 }

 internal static Encoding Convert(Cmdlet cmdlet, string encoding)
 {
     if ((encoding == null) || (encoding.Length == 0))
     {
         return Encoding.Unicode;
     }
     if (string.Equals(encoding, "unknown", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.Unicode;
     }
     if (string.Equals(encoding, "string", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.Unicode;
     }
     if (string.Equals(encoding, "unicode", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.Unicode;
     }
     if (string.Equals(encoding, "bigendianunicode", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.BigEndianUnicode;
     }
     if (string.Equals(encoding, "ascii", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.ASCII;
     }
     if (string.Equals(encoding, "utf8", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.UTF8;
     }
     if (string.Equals(encoding, "utf7", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.UTF7;
     }
     if (string.Equals(encoding, "utf32", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.UTF32;
     }
     if (string.Equals(encoding, "default", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.Default;
     }
     if (string.Equals(encoding, "oem", StringComparison.OrdinalIgnoreCase))
     {
         return Encoding.GetEncoding((int) NativeMethods.GetOEMCP());
     }
     string str = string.Join(", ", new string[] { "unknown", "string", "unicode", "bigendianunicode", "ascii", "utf8", "utf7", "utf32", "default", "oem" });
     string message = StringUtil.Format(PathUtilsStrings.OutFile_WriteToFileEncodingUnknown, encoding, str);
     ErrorRecord errorRecord = new ErrorRecord(PSTraceSource.NewArgumentException("Encoding"), "WriteToFileEncodingUnknown", ErrorCategory.InvalidArgument, null) {
         ErrorDetails = new ErrorDetails(message)
     };
     cmdlet.ThrowTerminatingError(errorRecord);
     return null;
 }

        public IScriptCSSession GetOrCreate( string name, Cmdlet cmdlet )
        {
            var session = Get(name);
            if (null == session)
            {
                session = ScriptCSSession.Create(cmdlet);
                _map.Add( name, session );
            }

            return session;
        }

 internal void AddChildJobAndPotentiallyBlock(Cmdlet cmdlet, StartableJob childJob, ChildJobFlags flags)
 {
     using (CancellationTokenSource source = new CancellationTokenSource())
     {
         if (childJob == null)
         {
             throw new ArgumentNullException("childJob");
         }
         this.AddChildJobWithoutBlocking(childJob, flags, new Action(source.Cancel));
         this.ForwardAllResultsToCmdlet(cmdlet, new CancellationToken?(source.Token));
     }
 }

 public CmdletParameterBinder(CmdletInfo cmdletInfo, Cmdlet cmdlet)
 {
     _cmdletInfo = cmdletInfo;
     _cmdlet = cmdlet;
     _defaultValues = new Dictionary<MemberInfo, object>();
     _boundParameters = new Collection<MemberInfo>();
     _candidateParameterSets = new Collection<CommandParameterSetInfo>();
     _commandLineValuesBackup = new Dictionary<MemberInfo, object>();
     _activeSet = null;
     _defaultSet = null;
     _hasDefaultSet = true;
 }

 internal ProviderIntrinsics(Cmdlet cmdlet)
 {
     if (cmdlet == null)
     {
         throw PSTraceSource.NewArgumentNullException("cmdlet");
     }
     this.cmdlet = cmdlet;
     this.item = new ItemCmdletProviderIntrinsics(cmdlet);
     this.childItem = new ChildItemCmdletProviderIntrinsics(cmdlet);
     this.content = new ContentCmdletProviderIntrinsics(cmdlet);
     this.property = new PropertyCmdletProviderIntrinsics(cmdlet);
     this.securityDescriptor = new SecurityDescriptorCmdletProviderIntrinsics(cmdlet);
 }

        internal ProviderIntrinsics(Cmdlet cmdlet)
        {
            if (cmdlet == null)
            {
                throw new NullReferenceException("Cmdlet can't be null.");
            }

            _cmdlet = cmdlet;
            ChildItem = new ChildItemCmdletProviderIntrinsics(_cmdlet);
            Content = new ContentCmdletProviderIntrinsics(_cmdlet);
            Item = new ItemCmdletProviderIntrinsics(_cmdlet);
            Property = new PropertyCmdletProviderIntrinsics(_cmdlet);
            SecurityDescriptor = new SecurityDescriptorCmdletProviderIntrinsics(_cmdlet);
        }