C# Automation.PSVariable类代码示例

 protected override void ProcessRecord()
 {
     if (this.Force == 0)
     {
         PSVariable atScope = null;
         if (string.IsNullOrEmpty(base.Scope))
         {
             atScope = base.SessionState.PSVariable.GetAtScope(this.name, "local");
         }
         else
         {
             atScope = base.SessionState.PSVariable.GetAtScope(this.name, base.Scope);
         }
         if (atScope != null)
         {
             SessionStateException replaceParentContainsErrorRecordException = new SessionStateException(this.name, SessionStateCategory.Variable, "VariableAlreadyExists", SessionStateStrings.VariableAlreadyExists, ErrorCategory.ResourceExists, new object[0]);
             base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
             return;
         }
     }
     string newVariableAction = VariableCommandStrings.NewVariableAction;
     string target = StringUtil.Format(VariableCommandStrings.NewVariableTarget, this.Name, this.Value);
     if (base.ShouldProcess(target, newVariableAction))
     {
         PSVariable variable = new PSVariable(this.name, this._value, this.options);
         if (this._visibility.HasValue)
         {
             variable.Visibility = this._visibility.Value;
         }
         if (this.description != null)
         {
             variable.Description = this.description;
         }
         try
         {
             if (string.IsNullOrEmpty(base.Scope))
             {
                 base.SessionState.Internal.NewVariable(variable, (bool) this.Force);
             }
             else
             {
                 base.SessionState.Internal.NewVariableAtScope(variable, base.Scope, (bool) this.Force);
             }
         }
         catch (SessionStateException exception2)
         {
             base.WriteError(new ErrorRecord(exception2.ErrorRecord, exception2));
             return;
         }
         catch (PSArgumentException exception3)
         {
             base.WriteError(new ErrorRecord(exception3.ErrorRecord, exception3));
             return;
         }
         if (this.passThru)
         {
             base.WriteObject(variable);
         }
     }
 }

 internal override void SetSessionStateItem(string name, object value, bool writeItem)
 {
     PSVariable variable = null;
     if (value != null)
     {
         variable = value as PSVariable;
         if (variable == null)
         {
             variable = new PSVariable(name, value);
         }
         else if (!string.Equals(name, variable.Name, StringComparison.OrdinalIgnoreCase))
         {
             variable = new PSVariable(name, variable.Value, variable.Options, variable.Attributes) {
                 Description = variable.Description
             };
         }
     }
     else
     {
         variable = new PSVariable(name, null);
     }
     PSVariable item = base.SessionState.Internal.SetVariable(variable, (bool) base.Force, base.Context.Origin) as PSVariable;
     if (writeItem && (item != null))
     {
         base.WriteItemObject(item, item.Name, false);
     }
 }

        protected override void ProcessRecord()
        {
            // TODO: deal with Force
            // TODO: deal with ShouldProcess

            PSVariable variable = new PSVariable(Name, Value, Option);
            if (Description != null)
            {
                variable.Description = Description;
            }
            //TODO: check if variable already exists and check if force has influence on behavior
            //implement also an overloaded Get method in PSVariableIntrniscs that allow to pass a scope
            try
            {
                //TODO: create a new overloaded method in PSVariableIntrinsics that allows to pass (bool)this.Force
                SessionState.PSVariable.Set(variable);
            }
            catch (Exception ex)
            {
                WriteError(new ErrorRecord(ex, "", ErrorCategory.InvalidOperation, variable));
                return;
            }
            if (PassThru.ToBool())
            {
                WriteObject(variable);
            }
        }

        internal override void SetSessionStateItem(string name, object value, bool writeItem)
        {
            Path path = PathIntrinsics.RemoveDriveName(name);
            name = path.TrimStartSlash();

            PSVariable variable = null;
            if (value != null)
            {
                variable = value as PSVariable;
                if (variable == null)
                {
                    variable = new PSVariable(name, value);
                }
                else if (String.Compare(name, variable.Name, true, System.Globalization.CultureInfo.CurrentCulture) != 0)
                {
                    PSVariable var = new PSVariable(name, variable.Value, variable.Options, variable.Attributes);
                    var.Description = variable.Description;
                    variable = var;
                }
            }
            else
            {
                variable = new PSVariable(name, null);
            }
            // TODO: can be Force'ed
            SessionState.PSVariable.Set(variable);
            PSVariable item = SessionState.PSVariable.Get(variable.Name);
            if (writeItem && (item != null))
            {
                WriteItemObject(item, item.Name, false);
            }
        }

 /// <summary>
 /// Add an new SessionStateVariable entry to this session state object...
 /// </summary>
 /// <param name="entry">The entry to add</param>
 internal void AddSessionStateEntry(SessionStateVariableEntry entry)
 {
     PSVariable v = new PSVariable(entry.Name, entry.Value,
             entry.Options, entry.Attributes, entry.Description);
     v.Visibility = entry.Visibility;
     this.SetVariableAtScope(v, "global", true, CommandOrigin.Internal);
 }

 internal override void SetSessionStateItem(Path name, object value, bool writeItem)
 {
     PSVariable variable = null;
     if (value != null)
     {
         variable = value as PSVariable;
         if (variable == null)
         {
             variable = new PSVariable(name, value);
         }
         else if (String.Compare(name, variable.Name, true, System.Globalization.CultureInfo.CurrentCulture) != 0)
         {
             PSVariable var = new PSVariable(name, variable.Value, variable.Options, variable.Attributes);
             var.Description = variable.Description;
             variable = var;
         }
     }
     else
     {
         variable = new PSVariable(name, null);
     }
     // TODO: can be Force'ed
     PSVariable item = base.SessionState.SessionStateGlobal.SetVariable(variable) as PSVariable;
     if (writeItem && (item != null))
     {
         WriteItemObject(item, item.Name, false);
     }
 }

        public static void Set__variable(this PSVariableProperty source, PSVariable value)
        {
            if (source == null)
                throw new ArgumentNullException("source");

            FieldSetterDelegate__variable.Set(source, value);
        }

        protected override void ProcessRecord()
        {
            // TODO: deal with scope
            // TODO: deal with Force
            // TODO: deal with ShouldProcess

            PSVariable variable = new PSVariable(Name, Value, Option);
            if (Description != null)
            {
                variable.Description = Description;
            }
            try
            {
                SessionState.SessionStateGlobal.NewVariable(variable, (bool)this.Force);
            }
            catch (Exception ex)
            {
                WriteError(new ErrorRecord(ex, "", ErrorCategory.InvalidOperation, variable));
                return;
            }
            if (PassThru.ToBool())
            {
                WriteObject(variable);
            }
        }

 public PSVariableProperty(PSVariable variable) : base((variable != null) ? variable.Name : null, null)
 {
     if (variable == null)
     {
         throw PSTraceSource.NewArgumentException("variable");
     }
     this._variable = variable;
 }

 protected internal void CheckVariableCanBeChanged(PSVariable variable, bool force)
 {
     if ((variable.ItemOptions.HasFlag(ScopedItemOptions.ReadOnly) && !force) ||
         variable.ItemOptions.HasFlag(ScopedItemOptions.Constant))
     {
         throw SessionStateUnauthorizedAccessException.CreateVariableNotWritableError(variable);
     }
 }

 private void CheckVariableCanBeRemoved(PSVariable variable)
 {
     if ((variable.ItemOptions.HasFlag(ScopedItemOptions.ReadOnly) && !Force) ||
         variable.ItemOptions.HasFlag(ScopedItemOptions.Constant))
     {
         throw SessionStateUnauthorizedAccessException.CreateVariableNotRemovableError(variable);
     }
 }

 public void Remove(PSVariable variable)
 {
     //no scope specified when passing an object: we only care about the local scope
     if (variable == null)
     {
         throw new ArgumentNullException("The variable is null.");
     }
     //add the local scope specifier to make sure we don't screw up with other variables
     Remove("local:" + variable.Name);
 }

 private PSVariable ClearValue(PSVariable matchingVariable)
 {
     PSVariable variable = matchingVariable;
     if (base.Scope != null)
     {
         matchingVariable.Value = null;
         return variable;
     }
     base.SessionState.PSVariable.Set(matchingVariable.Name, null);
     return base.SessionState.PSVariable.Get(matchingVariable.Name);
 }

 internal bool TryGetLocalVariable(string name, bool fromNewOrSet, out PSVariable result)
 {
     int index;
     name = VariableAnalysis.GetUnaliasedVariableName(name);
     if (_nameToIndexMap.TryGetValue(name, out index) && (fromNewOrSet || IsValueSet(index)))
     {
         result = new LocalVariable(name, this, index);
         return true;
     }
     result = null;
     return false;
 }

 internal History(System.Management.Automation.ExecutionContext context)
 {
     Collection<Attribute> attributes = new Collection<Attribute> {
         new ValidateRangeAttribute(1, 0x7fff)
     };
     PSVariable variable = new PSVariable("MaximumHistoryCount", 0x1000, ScopedItemOptions.None, attributes) {
         Description = SessionStateStrings.MaxHistoryCountDescription
     };
     context.EngineSessionState.SetVariable(variable, false, CommandOrigin.Internal);
     this._capacity = 0x1000;
     this._buffer = new HistoryInfo[this._capacity];
 }