From 0038b7c991a26db469f836579b41b0c1e4830fe5 Mon Sep 17 00:00:00 2001
From: Matthias Gernand <mgernand@users.noreply.github.com>
Date: Sat, 15 Jun 2024 12:46:46 +0200
Subject: [PATCH] Added ToExpressionString overload for non-generic expression.
 (#49)

---
 .../ExpressionExtensions.cs                   | 22 ++++-
 .../ExpressionExtensionsTests.cs              | 86 +++++++++++++++++++
 2 files changed, 105 insertions(+), 3 deletions(-)

diff --git a/src/Fluxera.Linq.Expressions/ExpressionExtensions.cs b/src/Fluxera.Linq.Expressions/ExpressionExtensions.cs
index 9d6793e..51ced55 100644
--- a/src/Fluxera.Linq.Expressions/ExpressionExtensions.cs
+++ b/src/Fluxera.Linq.Expressions/ExpressionExtensions.cs
@@ -20,11 +20,9 @@ public static class ExpressionExtensions
 		///     See Pete Montgomery's post here:
 		///     http://petemontgomery.wordpress.com/2008/08/07/caching-the-results-of-linq-queries/
 		/// </remarks>
-		/// <typeparam name="T"></typeparam>
-		/// <typeparam name="TResult"></typeparam>
 		/// <param name="expression"></param>
 		/// <returns></returns>
-		public static string ToExpressionString<T, TResult>(this Expression<Func<T, TResult>> expression)
+		public static string ToExpressionString(this Expression expression)
 		{
 			if(expression is null)
 			{
@@ -43,6 +41,24 @@ public static string ToExpressionString<T, TResult>(this Expression<Func<T, TRes
 			return expr.ToString();
 		}
 
+		/// <summary>
+		///     Converts the given <see cref="Expression" /> to a string representation.
+		/// </summary>
+		/// <remarks>
+		///     See Pete Montgomery's post here:
+		///     http://petemontgomery.wordpress.com/2008/08/07/caching-the-results-of-linq-queries/
+		/// </remarks>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="TResult"></typeparam>
+		/// <param name="expression"></param>
+		/// <returns></returns>
+		public static string ToExpressionString<T, TResult>(this Expression<Func<T, TResult>> expression)
+		{
+			Expression expr = expression;
+			
+			return expr?.ToExpressionString();
+		}
+
 		/// <summary>
 		///     Creates a <see cref="Expression" /> that represents a bitwise AND operation.
 		/// </summary>
diff --git a/tests/Fluxera.Linq.Expressions.UnitTests/ExpressionExtensionsTests.cs b/tests/Fluxera.Linq.Expressions.UnitTests/ExpressionExtensionsTests.cs
index 853a7b7..5bef314 100644
--- a/tests/Fluxera.Linq.Expressions.UnitTests/ExpressionExtensionsTests.cs
+++ b/tests/Fluxera.Linq.Expressions.UnitTests/ExpressionExtensionsTests.cs
@@ -90,5 +90,91 @@ public void ShouldCreateExpressionStringForDynamicSelectionExpression()
 			result.Should().NotBeNullOrWhiteSpace();
 			result.Should().Be("x => new DynamicAnonymousType0`1() {Name = x.Name}");
 		}
+
+		[Test]
+		public void ShouldCheckForEmpty_Untyped()
+		{
+			// Arrange
+			Expression<Func<Person, string>> expression = x => x.Name;
+			Expression expr = expression;
+
+			// Act
+			string result = expr.ToExpressionString();
+
+			// Assert
+			result.Should().NotBeNullOrWhiteSpace();
+		}
+
+		[Test]
+		public void ShouldCreateExpressionStringForComplexPropertyExpression_Untyped()
+		{
+			// Arrange
+			Expression<Func<Person, bool>> expression = x => x.Name.StartsWith("O") && x.Name.EndsWith("l");
+			Expression expr = expression;
+
+			// Act
+			string result = expr.ToExpressionString();
+
+			// Assert
+			result.Should().NotBeNullOrWhiteSpace();
+			result.Should().Be("x => (x.Name.StartsWith(\"O\") AndAlso x.Name.EndsWith(\"l\"))");
+		}
+
+		[Test]
+		public void ShouldCreateExpressionStringForSimplePropertyExpression_Untyped()
+		{
+			// Arrange
+			Expression<Func<Person, string>> expression = x => x.Name;
+			Expression expr = expression;
+
+			// Act
+			string result = expr.ToExpressionString();
+
+			// Assert
+			result.Should().NotBeNullOrWhiteSpace();
+			result.Should().Be("x => x.Name");
+		}
+
+		[Test]
+		public void ShouldCreateExpressionStringForSelectionExpression_Untyped()
+		{
+			// Arrange
+			Expression<Func<Person, dynamic>> expression = x => new { x.Name };
+			Expression expr = expression;
+
+			// Act
+			string result = expr.ToExpressionString();
+
+			// Assert
+			result.Should().NotBeNullOrWhiteSpace();
+			result.Should().Be("x => new <>f__AnonymousType0`1(Name = x.Name)");
+		}
+
+		[Test]
+		public void ShouldCreateExpressionStringForDynamicSelectionExpression_Untyped()
+		{
+			// Arrange
+			Type type = DynamicFactory.CreateType(("Name", typeof(string)));
+
+			PropertyInfo property = typeof(Person).GetProperty("Name");
+			PropertyInfo dynamicProperty = type.GetProperty("Name");
+
+			ParameterExpression parameter = Expression.Parameter(typeof(Person), "x");
+			MemberExpression propertyExpression = Expression.MakeMemberAccess(parameter, property);
+			MemberAssignment binding = Expression.Bind(dynamicProperty, propertyExpression);
+
+			NewExpression newExpression = Expression.New(type);
+			MemberInitExpression memberInitExpression = Expression.MemberInit(newExpression, binding);
+
+			Expression<Func<Person, dynamic>> expression = Expression.Lambda<Func<Person, dynamic>>(memberInitExpression, parameter);
+			Expression expr = expression;
+
+			// Act
+			string result = expr.ToExpressionString();
+
+			// Assert
+			result.Should().NotBeNullOrWhiteSpace();
+			result.Should().Be("x => new DynamicAnonymousType0`1() {Name = x.Name}");
+		}
 	}
 }