refactor ArgumentInfo to make immutable, reorganize code

Author: jpdillingham

src/Utility.CommandLine.Arguments/Arguments.cs

@@ -121,6 +121,52 @@ public ArgumentAttribute(char shortName, string longName, string helpText = null
         public char ShortName { get; set; }
     }
 
+    /// <summary>
+    ///     Encapsulates argument names and help text.
+    /// </summary>
+    public class ArgumentInfo
+    {
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="ArgumentInfo"/> class.
+        /// </summary>
+        /// <param name="shortName">The short name of the argument.</param>
+        /// <param name="longName">The long name of the argument.</param>
+        /// <param name="helpText">The help text for the argument.</param>
+        /// <param name="property">The property with which the argument is associated.</param>
+        public ArgumentInfo(char shortName, string longName, string helpText, PropertyInfo property)
+        {
+            ShortName = shortName;
+            LongName = longName;
+            HelpText = helpText;
+            Property = property;
+        }
+
+        /// <summary>
+        ///     Gets the help text for the argument.
+        /// </summary>
+        public string HelpText { get; }
+
+        /// <summary>
+        ///     Gets a value indicating whether the argument backing Type is a collection.
+        /// </summary>
+        public bool IsCollection => Property.PropertyType.IsArray || (Property.PropertyType.IsGenericType && Property.PropertyType.GetGenericTypeDefinition() == typeof(List<>));
+
+        /// <summary>
+        ///     Gets the long name of the argument.
+        /// </summary>
+        public string LongName { get; }
+
+        /// <summary>
+        ///     Gets the property with which the argument is associated.
+        /// </summary>
+        public PropertyInfo Property { get; }
+
+        /// <summary>
+        ///     Gets the short name of the argument.
+        /// </summary>
+        public char ShortName { get; }
+    }
+
     /// <summary>
     ///     Provides static methods used to retrieve the command line arguments and operands with which the application was
     ///     started, as well as a Type to contain them.
@@ -162,21 +208,16 @@ private Arguments(string commandLineString, List<KeyValuePair<string, string>> a
         }
 
         /// <summary>
-        ///     Gets the target Type, if applicable.
+        ///     Gets a dictionary containing the arguments and values specified in the command line arguments with which the
+        ///     application was started.
         /// </summary>
-        public Type TargetType { get; }
+        public Dictionary<string, object> ArgumentDictionary { get; }
 
         /// <summary>
         ///     Gets the list of arguments specified in the command line arguments with which the application was started.
         /// </summary>
         public List<KeyValuePair<string, string>> ArgumentList { get; }
 
-        /// <summary>
-        ///     Gets a dictionary containing the arguments and values specified in the command line arguments with which the
-        ///     application was started.
-        /// </summary>
-        public Dictionary<string, object> ArgumentDictionary { get; }
-
         /// <summary>
         ///     Gets the command line string from which the arguments were parsed.
         /// </summary>
@@ -187,6 +228,11 @@ private Arguments(string commandLineString, List<KeyValuePair<string, string>> a
         /// </summary>
         public List<string> OperandList { get; private set; }
 
+        /// <summary>
+        ///     Gets the target Type, if applicable.
+        /// </summary>
+        public Type TargetType { get; }
+
         /// <summary>
         ///     Gets the argument value corresponding to the specified <paramref name="index"/>.
         /// </summary>
@@ -201,7 +247,8 @@ public object this[int index]
         }
 
         /// <summary>
-        ///     Gets the argument value corresponding to the specified <paramref name="key"/> from the <see cref="ArgumentDictionary"/> property.
+        ///     Gets the argument value corresponding to the specified <paramref name="key"/> from the
+        ///     <see cref="ArgumentDictionary"/> property.
         /// </summary>
         /// <param name="key">The key for which the value is to be retrieved.</param>
         /// <returns>The argument value corresponding to the specified key.</returns>
@@ -213,43 +260,6 @@ public object this[string key]
             }
         }
 
-        private static Dictionary<string, object> GetArgumentDictionary(List<KeyValuePair<string, string>> argumentList, Type targetType = null)
-        {
-            var dict = new ConcurrentDictionary<string, object>();
-            var argumentInfo = targetType == null ? new List<ArgumentInfo>() : GetArgumentInfo(targetType);
-
-            foreach (var arg in argumentList)
-            {
-                var info = argumentInfo.Where(i => i.ShortName.ToString() == arg.Key || i.LongName == arg.Key).SingleOrDefault();
-
-                if (info != default(ArgumentInfo))
-                {
-                    bool added = false;
-
-                    foreach (var k in new[] { info.ShortName.ToString(), info.LongName })
-                    {
-                        if (dict.ContainsKey(k))
-                        {
-                            dict.AddOrUpdate(k, arg.Value, (key, existingValue) => info.IsCollection ? ((List<object>)existingValue).Concat(new[] { arg.Value }).ToList() : (object)arg.Value);
-                            added = true;
-                            break;
-                        }
-                    }
-
-                    if (!added)
-                    {
-                        dict.TryAdd(arg.Key, info.IsCollection ? new List<object>(new[] { arg.Value }) : (object)arg.Value);
-                    }
-                }
-                else
-                {
-                    dict.AddOrUpdate(arg.Key, arg.Value, (key, existingValue) => arg.Value);
-                }
-            }
-
-            return dict.ToDictionary(a => a.Key, a => a.Value);
-        }
-
         /// <summary>
         ///     Retrieves a collection of <see cref="ArgumentInfo"/> gathered from properties in the target <paramref name="type"/>
         ///     marked with the <see cref="ArgumentAttribute"/><see cref="Attribute"/> along with the short and long names and help text.
@@ -268,13 +278,11 @@ private static Dictionary<string, object> GetArgumentDictionary(List<KeyValuePai
 
                 if (attribute != default(CustomAttributeData))
                 {
-                    retVal.Add(new ArgumentInfo()
-                    {
-                        ShortName = (char)attribute.ConstructorArguments[0].Value,
-                        LongName = (string)attribute.ConstructorArguments[1].Value,
-                        HelpText = (string)attribute.ConstructorArguments[2].Value,
-                        Type = property.PropertyType,
-                    });
+                    retVal.Add(new ArgumentInfo(
+                        shortName: (char)attribute.ConstructorArguments[0].Value,
+                        longName: (string)attribute.ConstructorArguments[1].Value,
+                        helpText: (string)attribute.ConstructorArguments[2].Value,
+                        property: property));
                 }
             }
 
@@ -526,6 +534,43 @@ private static void ClearProperties(Dictionary<string, PropertyInfo> properties)
             }
         }
 
+        private static Dictionary<string, object> GetArgumentDictionary(List<KeyValuePair<string, string>> argumentList, Type targetType = null)
+        {
+            var dict = new ConcurrentDictionary<string, object>();
+            var argumentInfo = targetType == null ? new List<ArgumentInfo>() : GetArgumentInfo(targetType);
+
+            foreach (var arg in argumentList)
+            {
+                var info = argumentInfo.Where(i => i.ShortName.ToString() == arg.Key || i.LongName == arg.Key).SingleOrDefault();
+
+                if (info != default(ArgumentInfo))
+                {
+                    bool added = false;
+
+                    foreach (var k in new[] { info.ShortName.ToString(), info.LongName })
+                    {
+                        if (dict.ContainsKey(k))
+                        {
+                            dict.AddOrUpdate(k, arg.Value, (key, existingValue) => info.IsCollection ? ((List<object>)existingValue).Concat(new[] { arg.Value }).ToList() : (object)arg.Value);
+                            added = true;
+                            break;
+                        }
+                    }
+
+                    if (!added)
+                    {
+                        dict.TryAdd(arg.Key, info.IsCollection ? new List<object>(new[] { arg.Value }) : (object)arg.Value);
+                    }
+                }
+                else
+                {
+                    dict.AddOrUpdate(arg.Key, arg.Value, (key, existingValue) => arg.Value);
+                }
+            }
+
+            return dict.ToDictionary(a => a.Key, a => a.Value);
+        }
+
         private static List<KeyValuePair<string, string>> GetArgumentList(string commandLineString)
         {
             var argumentList = new List<KeyValuePair<string, string>>();
@@ -640,37 +685,6 @@ private static PropertyInfo GetOperandsProperty(Type type)
         }
     }
 
-    /// <summary>
-    ///     Encapsulates argument names and help text.
-    /// </summary>
-    public class ArgumentInfo
-    {
-        /// <summary>
-        ///     Gets or sets the help text for the argument.
-        /// </summary>
-        public string HelpText { get; set; }
-
-        /// <summary>
-        ///     Gets or sets the long name of the argument.
-        /// </summary>
-        public string LongName { get; set; }
-
-        /// <summary>
-        ///     Gets or sets the short name of the argument.
-        /// </summary>
-        public char ShortName { get; set; }
-
-        /// <summary>
-        ///     Gets or sets the backing Type of the argument.
-        /// </summary>
-        public Type Type { get; set; }
-
-        /// <summary>
-        ///     Gets a value indicating whether the argument backing Type is a collection.
-        /// </summary>
-        public bool IsCollection => Type.IsArray || (Type.IsGenericType && Type.GetGenericTypeDefinition() == typeof(List<>));
-    }
-
     /// <summary>
     ///     Indicates that the property is to be used as the target for automatic population of command line operands when invoking
     ///     the <see cref="Arguments.Populate(string, bool, string)"/> method.
@@ -679,4 +693,4 @@ public class ArgumentInfo
     public class OperandsAttribute : Attribute
     {
     }
-}
+}

tests/Utility.CommandLine.Arguments.Tests/ArgumentsTests.cs

@@ -31,6 +31,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using Xunit;
 
 namespace Utility.CommandLine.Tests
@@ -53,19 +54,17 @@ public void Constructor()
     [Collection("ArgumentInfo")]
     public class ArgumentInfoTests
     {
+        private string Test { get; set; }
+
         [Fact]
         public void Constructor()
         {
-            ArgumentInfo test = new ArgumentInfo()
-            {
-                ShortName = 'a',
-                LongName = "aa",
-                HelpText = "help",
-            };
+            ArgumentInfo test = new ArgumentInfo('a', "aa", "help", GetType().GetProperty("Test", BindingFlags.Instance | BindingFlags.NonPublic));
 
             Assert.Equal('a', test.ShortName);
             Assert.Equal("aa", test.LongName);
             Assert.Equal("help", test.HelpText);
+            Assert.Equal("Test", test.Property.Name);
         }
 
     }