select works just need to add null checks.

PoweredSoft.DynamicLinq/Constants.cs

@@ -53,6 +53,12 @@ namespace PoweredSoft.DynamicLinq
         Path
     }
 
+    public enum SelectCollectionHandling
+    {
+        Select,
+        SelectMany
+    }
+
     internal static class Constants
     {
         internal static readonly MethodInfo GroupByMethod = typeof(Queryable).GetMethods().First(t => t.Name == "GroupBy");

PoweredSoft.DynamicLinq/Fluent/Select/SelectBuilder.cs

@@ -11,6 +11,7 @@ namespace PoweredSoft.DynamicLinq.Fluent
         public string Path { get; set; }
         public string PropertyName { get; set; }
         public SelectTypes SelectType { get; set; }
+        public SelectCollectionHandling SelectCollectionHandling { get; set; }
     }
 
     public class SelectBuilder : IQueryBuilder
@@ -133,7 +134,7 @@ namespace PoweredSoft.DynamicLinq.Fluent
             return this;
         }
 
-        public SelectBuilder PathToList(string path, string propertyName = null)
+        public SelectBuilder PathToList(string path, string propertyName = null, SelectCollectionHandling selectCollectionHandling = SelectCollectionHandling.Select)
         {
             if (propertyName == null)
                 propertyName = path.Split('.').LastOrDefault();
@@ -144,7 +145,8 @@ namespace PoweredSoft.DynamicLinq.Fluent
             {
                 Path = path,
                 PropertyName = propertyName,
-                SelectType = SelectTypes.PathToList
+                SelectType = SelectTypes.PathToList,
+                SelectCollectionHandling = selectCollectionHandling
             });
 
             return this;
@@ -155,7 +157,7 @@ namespace PoweredSoft.DynamicLinq.Fluent
             if (Empty)
                 throw new Exception("No select specified, please specify at least one select path");
 
-            var partsTuple = Parts.Select(t => (selectType: t.SelectType, propertyName: t.PropertyName, path: t.Path)).ToList();
+            var partsTuple = Parts.Select(t => (selectType: t.SelectType, propertyName: t.PropertyName, path: t.Path, selectCollectionHandling: t.SelectCollectionHandling)).ToList();
             return QueryableHelpers.Select(Query, partsTuple, DestinationType);
         }
     }

PoweredSoft.DynamicLinq/Helpers/QueryableHelpers.cs

@@ -118,7 +118,7 @@ namespace PoweredSoft.DynamicLinq.Helpers
             return result;
         }
 
-        public static IQueryable Select(IQueryable query, List<(SelectTypes selectType, string propertyName, string path)> parts, Type destinationType = null)
+        public static IQueryable Select(IQueryable query, List<(SelectTypes selectType, string propertyName, string path, SelectCollectionHandling selectCollectionHandling)> parts, Type destinationType = null)
         {
             // create parameter.
             var queryType = query.ElementType;
@@ -129,7 +129,7 @@ namespace PoweredSoft.DynamicLinq.Helpers
             var partExpressions = new List<(Expression expression, string propertyName)>();
             parts.ForEach(part =>
             {
-                var partBodyExpression = CreateSelectExpression(query, parameter, part.selectType, part.path);
+                var partBodyExpression = CreateSelectExpression(query, parameter, part.selectType, part.path, part.selectCollectionHandling);
                 fields.Add((partBodyExpression.Type, part.propertyName));
                 partExpressions.Add((partBodyExpression, part.propertyName));
             });
@@ -146,11 +146,11 @@ namespace PoweredSoft.DynamicLinq.Helpers
             return result;
         }
 
-        private static Expression CreateSelectExpressionForGrouping(IQueryable query, ParameterExpression parameter, SelectTypes selectType, string path)
+        private static Expression CreateSelectExpressionForGrouping(IQueryable query, ParameterExpression parameter, SelectTypes selectType, string path, SelectCollectionHandling selectCollectionHandling)
         {
             if (selectType == SelectTypes.Key)
             {
-                return ResolvePathForExpression(parameter, path);
+                return ResolvePathForExpression(parameter, path, selectCollectionHandling);
             }
             else if (selectType == SelectTypes.Count)
             {
@@ -193,23 +193,23 @@ namespace PoweredSoft.DynamicLinq.Helpers
             throw new NotSupportedException($"unkown select type {selectType}");
         }
 
-        private static Expression CreateSelectExpression(IQueryable query, ParameterExpression parameter, SelectTypes selectType, string path)
+        private static Expression CreateSelectExpression(IQueryable query, ParameterExpression parameter, SelectTypes selectType, string path, SelectCollectionHandling selectCollectionHandling)
         {
             if (!IsGrouping(query))
-                return CreateSelectExpressionRegular(query, parameter, selectType, path);
+                return CreateSelectExpressionRegular(query, parameter, selectType, path, selectCollectionHandling);
 
-            return CreateSelectExpressionForGrouping(query, parameter, selectType, path);            
+            return CreateSelectExpressionForGrouping(query, parameter, selectType, path, selectCollectionHandling);            
         }
 
-        private static Expression CreateSelectExpressionRegular(IQueryable query, ParameterExpression parameter, SelectTypes selectType, string path)
+        private static Expression CreateSelectExpressionRegular(IQueryable query, ParameterExpression parameter, SelectTypes selectType, string path, SelectCollectionHandling selectCollectionHandling)
         {
             if (selectType == SelectTypes.Path)
             {
-                return ResolvePathForExpression(parameter, path);
+                return ResolvePathForExpression(parameter, path, selectCollectionHandling);
             }
             else if (selectType == SelectTypes.PathToList)
             {
-                var expr = ResolvePathForExpression(parameter, path);
+                var expr = ResolvePathForExpression(parameter, path, selectCollectionHandling);
                 var notGroupedType = expr.Type.GenericTypeArguments.FirstOrDefault();
                 if (notGroupedType == null)
                     throw new Exception($"Path must be a Enumerable<T> but its a {expr.Type}");
@@ -241,20 +241,43 @@ namespace PoweredSoft.DynamicLinq.Helpers
             return result;
         }
 
+        internal static Expression InternalResolvePathExpression(ParameterExpression param, List<string> parts, SelectCollectionHandling selectCollectionHandling)
+        {
+            var isLast = parts.Count == 1;
+            var currentPart = parts.First();
+            var memberExpression = Expression.PropertyOrField(param, currentPart);
+
+
+            if (isLast)
+                return memberExpression;
+
+            if (!IsEnumerable(memberExpression))
+                return InternalResolvePathExpression(param, parts.Skip(1).ToList(), selectCollectionHandling);
+
+            // enumerable.
+            var listGenericArgumentType = memberExpression.Type.GetGenericArguments().First();
+
+            // sub param.
+            var innerParam = Expression.Parameter(listGenericArgumentType);
+            var innerExpression = InternalResolvePathExpression(innerParam, parts.Skip(1).ToList(), selectCollectionHandling);
+            var lambda = Expression.Lambda(innerExpression, innerParam);
+
+            if (selectCollectionHandling == SelectCollectionHandling.Select)
+                return Expression.Call(typeof(Enumerable), "Select", new Type[] { listGenericArgumentType, innerExpression.Type }, memberExpression, lambda);
+
+            return Expression.Call(typeof(Enumerable), "SelectMany", new Type[] { listGenericArgumentType, innerExpression.Type.GenericTypeArguments.First() }, memberExpression, lambda);
+        }
+
         /// <summary>
         /// Returns the right expression for a path supplied.
         /// </summary>
         /// <param name="param">Expression.Parameter(typeOfClassOrInterface)</param>
         /// <param name="path">the path you wish to resolve example Contact.Profile.FirstName</param>
         /// <returns></returns>
-        public static Expression ResolvePathForExpression(ParameterExpression param, string path)
+        public static Expression ResolvePathForExpression(ParameterExpression param, string path, SelectCollectionHandling selectCollectionHandling = SelectCollectionHandling.Select)
         {
-            Expression body = param;
-            foreach (var member in path.Split('.'))
-            {
-                body = Expression.PropertyOrField(body, member);
-            }
-            return body;
+            var parts = path.Split('.').ToList();
+            return InternalResolvePathExpression(param, parts, selectCollectionHandling);
         }
 
         public static ConstantExpression GetConstantSameAsLeftOperator(Expression member, object value)