+ Added support map IEnumerable<int>/IEnumerable<long>and List<int>

Author: trueromanus

src/FlowCommandLine/FlowPropertyMapper.cs

@@ -7,7 +7,7 @@ public static class FlowPropertyMapper {
 
         public static PropertyInfo? GetPropertyFromParameter ( FlowCommandParameter parameter, IEnumerable<PropertyInfo> properties ) {
             if ( !string.IsNullOrEmpty ( parameter.PropertyName ) ) return properties.FirstOrDefault ( a => a.Name.ToLowerInvariant () == parameter.PropertyName.ToLowerInvariant () );
-            if ( !string.IsNullOrEmpty ( parameter.FullName ) ) return properties.FirstOrDefault ( a => a.Name.ToLowerInvariant () == parameter.FullName.ToLowerInvariant() );
+            if ( !string.IsNullOrEmpty ( parameter.FullName ) ) return properties.FirstOrDefault ( a => a.Name.ToLowerInvariant () == parameter.FullName.ToLowerInvariant () );
             if ( !string.IsNullOrEmpty ( parameter.ShortName ) ) return properties.FirstOrDefault ( a => a.Name.ToLowerInvariant () == parameter.ShortName.ToLowerInvariant () );
 
             return null;
@@ -34,12 +34,44 @@ public static bool SetPropertyValue<T> ( Type type, Dictionary<string, string> v
                         isChanged = true;
                     }
                     break;
+                case Type _ when type == typeof ( IEnumerable<int> ):
+                    if ( values.ContainsKey ( parameterKey ) ) {
+                        property.SetValue ( model, MapIntegerCollections ( values, parameterKey ) );
+                        isChanged = true;
+                    }
+                    break;
+                case Type _ when type == typeof ( List<int> ):
+                    if ( values.ContainsKey ( parameterKey ) ) {
+                        property.SetValue ( model, MapIntegerCollections ( values, parameterKey ) );
+                        isChanged = true;
+                    }
+                    break;
                 case Type _ when type == typeof ( long ):
                     if ( values.ContainsKey ( parameterKey ) && long.TryParse ( values[parameterKey], out var int64value ) ) {
                         property.SetValue ( model, int64value );
                         isChanged = true;
                     }
                     break;
+                case Type _ when type == typeof ( IEnumerable<long> ):
+                    if ( values.ContainsKey ( parameterKey ) ) {
+                        var longValues = values[parameterKey]
+                            .Split ( "," )
+                            .Select (
+                                a => {
+                                    if ( long.TryParse ( values[parameterKey], out var int64value ) ) {
+                                        return (long?) int64value;
+                                    } else {
+                                        return null;
+                                    }
+                                }
+                            )
+                            .Where ( a => a != null )
+                            .ToList ();
+
+                        property.SetValue ( model, longValues );
+                        isChanged = true;
+                    }
+                    break;
                 case Type _ when type == typeof ( double ):
                     if ( values.ContainsKey ( parameterKey ) && double.TryParse ( values[parameterKey], CultureInfo.InvariantCulture, out var doublevalue ) ) {
                         property.SetValue ( model, doublevalue );
@@ -84,6 +116,22 @@ public static bool SetPropertyValue<T> ( Type type, Dictionary<string, string> v
             return isChanged;
         }
 
+        private static List<int> MapIntegerCollections ( Dictionary<string, string> values, string parameterKey ) {
+            return values[parameterKey]
+                                        .Split ( "," )
+                                        .Select (
+                                            a => {
+                                                if ( int.TryParse ( a, out var int32value ) ) {
+                                                    return (int?) int32value;
+                                                } else {
+                                                    return null;
+                                                }
+                                            }
+                                        )
+                                        .Where ( a => a != null )
+                                        .Select ( a => a.Value )
+                                        .ToList ();
+        }
     }
 
 }