Refactor - convert to auto-property

Mostly using R# to automatically refactor, with some manual
fixups where it wouldn't work automatically (e.g. xml comments
on fields) or some it seemed to miss.

Some minor code reformatting was also done on properties near
other stuff I was manually inspecting.

Author: PowerShellTeam

src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/cim/MethodInvocationJobBase.cs

@@ -26,11 +26,10 @@ internal MethodInvocationJobBase(CimJobContext jobContext, bool passThru, string
             Dbg.Assert(methodSubject != null, "Caller should verify methodSubject != null");
 
             _passThru = passThru;
-            _methodSubject = methodSubject;
+            MethodSubject = methodSubject;
             _methodInvocationInfo = methodInvocationInfo;
         }
 
-        private readonly string _methodSubject;
         private readonly bool _passThru;
         private readonly MethodInvocationInfo _methodInvocationInfo;
 
@@ -108,10 +107,7 @@ internal IEnumerable<MethodParameter> GetMethodOutputParameters()
             return outParameters;
         }
 
-        internal string MethodSubject
-        {
-            get { return _methodSubject; }
-        }
+        internal string MethodSubject { get; }
 
         internal bool ShouldProcess()
         {

src/Microsoft.PowerShell.Commands.Management/cimSupport/cmdletization/cim/clientSideQuery.cs

@@ -332,10 +332,10 @@ internal abstract class PropertyValueFilter
         {
             protected PropertyValueFilter(string propertyName, object expectedPropertyValue, BehaviorOnNoMatch behaviorOnNoMatch)
             {
-                _propertyName = propertyName;
+                PropertyName = propertyName;
                 _behaviorOnNoMatch = behaviorOnNoMatch;
-                _originalExpectedPropertyValue = expectedPropertyValue;
-                _cimTypedExpectedPropertyValue = CimValueConverter.ConvertFromDotNetToCim(expectedPropertyValue);
+                OriginalExpectedPropertyValue = expectedPropertyValue;
+                CimTypedExpectedPropertyValue = CimValueConverter.ConvertFromDotNetToCim(expectedPropertyValue);
             }
 
             public BehaviorOnNoMatch BehaviorOnNoMatch
@@ -352,17 +352,13 @@ public BehaviorOnNoMatch BehaviorOnNoMatch
             protected abstract BehaviorOnNoMatch GetDefaultBehaviorWhenNoMatchesFound(object cimTypedExpectedPropertyValue);
             private BehaviorOnNoMatch _behaviorOnNoMatch;
 
-            public string PropertyName { get { return _propertyName; } }
-            private readonly string _propertyName;
+            public string PropertyName { get; }
 
-            public object CimTypedExpectedPropertyValue { get { return _cimTypedExpectedPropertyValue; } }
-            private readonly object _cimTypedExpectedPropertyValue;
+            public object CimTypedExpectedPropertyValue { get; }
 
-            public object OriginalExpectedPropertyValue { get { return _originalExpectedPropertyValue; } }
-            private readonly object _originalExpectedPropertyValue;
+            public object OriginalExpectedPropertyValue { get; }
 
-            public bool HadMatch { get { return _hadMatch; } }
-            private bool _hadMatch;
+            public bool HadMatch { get; private set; }
 
             public bool IsMatch(CimInstance o)
             {
@@ -371,27 +367,27 @@ public bool IsMatch(CimInstance o)
                     return false;
                 }
 
-                CimProperty propertyInfo = o.CimInstanceProperties[_propertyName];
+                CimProperty propertyInfo = o.CimInstanceProperties[PropertyName];
                 if (propertyInfo == null)
                 {
                     return false;
                 }
                 object actualPropertyValue = propertyInfo.Value;
 
-                if (_cimTypedExpectedPropertyValue == null)
+                if (CimTypedExpectedPropertyValue == null)
                 {
-                    _hadMatch = _hadMatch || (actualPropertyValue == null);
+                    HadMatch = HadMatch || (actualPropertyValue == null);
                     return actualPropertyValue == null;
                 }
 
                 CimValueConverter.AssertIntrinsicCimValue(actualPropertyValue);
-                CimValueConverter.AssertIntrinsicCimValue(_cimTypedExpectedPropertyValue);
+                CimValueConverter.AssertIntrinsicCimValue(CimTypedExpectedPropertyValue);
 
-                actualPropertyValue = ConvertActualValueToExpectedType(actualPropertyValue, _cimTypedExpectedPropertyValue);
-                Dbg.Assert(IsSameType(actualPropertyValue, _cimTypedExpectedPropertyValue), "Types of actual vs expected property value should always match");
+                actualPropertyValue = ConvertActualValueToExpectedType(actualPropertyValue, CimTypedExpectedPropertyValue);
+                Dbg.Assert(IsSameType(actualPropertyValue, CimTypedExpectedPropertyValue), "Types of actual vs expected property value should always match");
 
                 bool isMatch = this.IsMatchingValue(actualPropertyValue);
-                _hadMatch = _hadMatch || isMatch;
+                HadMatch = HadMatch || isMatch;
                 return isMatch;
             }
 
@@ -409,7 +405,7 @@ private object ConvertActualValueToExpectedType(object actualPropertyValue, obje
                     var errorMessage = string.Format(
                         CultureInfo.InvariantCulture,
                         CmdletizationResources.CimJob_MismatchedTypeOfPropertyReturnedByQuery,
-                        _propertyName,
+                        PropertyName,
                         actualPropertyValue.GetType().FullName,
                         expectedPropertyValue.GetType().FullName);
                     throw CimJobException.CreateWithoutJobContext(

src/Microsoft.PowerShell.Commands.Management/commands/management/CombinePathCommand.cs

@@ -24,77 +24,25 @@ public class JoinPathCommand : CoreCommandWithCredentialsBase
         /// </summary>
         [Parameter(Position = 0, Mandatory = true, ValueFromPipeline = true, ValueFromPipelineByPropertyName = true)]
         [Alias("PSPath")]
-        public string[] Path
-        {
-            get
-            {
-                return _paths;
-            } // get
-
-            set
-            {
-                _paths = value;
-            } // set
-        } // Path
+        public string[] Path { get; set; }
 
         /// <summary>
         /// Gets or sets the childPath parameter to the command
         /// </summary>
         [Parameter(Position = 1, Mandatory = true, ValueFromPipelineByPropertyName = true)]
         [AllowNull]
         [AllowEmptyString]
-        public string ChildPath
-        {
-            get
-            {
-                return _childPath;
-            } // get
-
-            set
-            {
-                _childPath = value;
-            } // set
-        } // childPath
+        public string ChildPath { get; set; } = String.Empty;
 
         /// <summary>
         /// Determines if the path should be resolved after being joined
         /// </summary>
         /// <value></value>
         [Parameter]
-        public SwitchParameter Resolve
-        {
-            get
-            {
-                return _resolve;
-            } // get
-
-            set
-            {
-                _resolve = value;
-            } //set
-        } // Resolve
+        public SwitchParameter Resolve { get; set; }
 
         #endregion Parameters
 
-        #region parameter data
-
-        /// <summary>
-        /// The path to resolve
-        /// </summary>
-        private string[] _paths;
-
-        /// <summary>
-        /// The child part of the path to be joined with the Path paramter
-        /// </summary>
-        private string _childPath = String.Empty;
-
-        /// <summary>
-        /// Determines if the path should be resolved after being joined.
-        /// </summary>
-        private bool _resolve;
-
-        #endregion parameter data
-
         #region Command code
 
         /// <summary>
@@ -104,7 +52,7 @@ public SwitchParameter Resolve
         protected override void ProcessRecord()
         {
             Dbg.Diagnostics.Assert(
-                _paths != null,
+                Path != null,
                 "Since Path is a mandatory parameter, paths should never be null");
 
             foreach (string path in Path)