Fix string.Contains with .NET 2.1 or higher (#3154)

Author: nirinchev

CHANGELOG.md

@@ -35,6 +35,7 @@
 * Avoid calling the setter on UI-bound properties in case the new value of the property is the same as the current one. This avoids some issue with MAUI, that seems to be calling the setter of bound properties unnecessarily when CollectionView/ListView are shown on screen. This is problematic if the object does not belong to the current user's permissions, as it will cause a compensanting write. In some limited cases this could cause an error loop (verified on iOS) when recycling of cells is involved. (Issue [#3128](https://github.com/realm/realm-dotnet/issues/3128))
 * Fixes an issue with where the source generator will not add the namespace for types used in properties' initializers. (Issue [#3135](https://github.com/realm/realm-dotnet/issues/3135))
 * Fixed an issue that would prevent Realm from working correctly in Unity applications that have [Domain Reloading](https://docs.unity3d.com/Manual/DomainReloading.html) turned off. (Issue [#2898](https://github.com/realm/realm-dotnet/issues/2898))
+* Fixed a bug when using `string.Contains` in .NET 2.1 or later where the search string is not a literal. (Issue [#3134](https://github.com/realm/realm-dotnet/issues/3134))
 
 ### Compatibility
 * Realm Studio: 12.0.0 or later.

Realm/Realm/Linq/RealmResultsVisitor.cs

@@ -315,7 +315,12 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
                 }
                 else if (IsStringContainsWithComparison(node.Method, out var index))
                 {
-                    member = node.Arguments[0] as MemberExpression;
+                    if (index > 0)
+                    {
+                        // If index is > 0, we're an extension method where the 0th argument is the property name
+                        member = node.Arguments[0] as MemberExpression;
+                    }
+
                     stringArgumentIndex = index;
                     queryMethod = (q, r, p, v) => q.StringContains(r, p, v, GetComparisonCaseSensitive(node));
                 }

Tests/Realm.Tests/Database/RealmResults/SimpleLINQtests.cs

@@ -686,16 +686,36 @@ public void StringSearch_Contains_CaseSensitivityTests()
             MakeThreePatricks();
 
             // case sensitive
-            var contains_atri = _realm.All<Person>().Where(p => p.FirstName.Contains("atri")).Count();
-            Assert.That(contains_atri, Is.EqualTo(2));
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains("atri")).Count(), Is.EqualTo(2));
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains("atri")).ToArray().Length, Is.EqualTo(2));
 
             // case sensitive
-            var contains_ordinal_atri = _realm.All<Person>().Where(p => p.FirstName.Contains("atri", StringComparison.Ordinal)).Count();
-            Assert.That(contains_ordinal_atri, Is.EqualTo(2));
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains("atri", StringComparison.Ordinal)).Count(), Is.EqualTo(2));
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains("atri", StringComparison.Ordinal)).ToArray().Length, Is.EqualTo(2));
 
             // ignore case
-            var contains_ignorecase_atri = _realm.All<Person>().Where(p => p.FirstName.Contains("atri", StringComparison.OrdinalIgnoreCase)).Count();
-            Assert.That(contains_ignorecase_atri, Is.EqualTo(3));
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains("atri", StringComparison.OrdinalIgnoreCase)).Count(), Is.EqualTo(3));
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains("atri", StringComparison.OrdinalIgnoreCase)).ToArray().Length, Is.EqualTo(3));
+        }
+
+        [Test]
+        public void StringSearch_Contains_NonLiteral_CaseSensitivityTests()
+        {
+            MakeThreePatricks();
+
+            var searchString = "atri";
+
+            // case sensitive
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains(searchString)).Count(), Is.EqualTo(2));
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains(searchString)).ToArray().Length, Is.EqualTo(2));
+
+            // case sensitive
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains(searchString, StringComparison.Ordinal)).Count(), Is.EqualTo(2));
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains(searchString, StringComparison.Ordinal)).ToArray().Length, Is.EqualTo(2));
+
+            // ignore case
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains(searchString, StringComparison.OrdinalIgnoreCase)).Count(), Is.EqualTo(3));
+            Assert.That(_realm.All<Person>().Where(p => p.FirstName.Contains(searchString, StringComparison.OrdinalIgnoreCase)).ToArray().Length, Is.EqualTo(3));
         }
 
         [Test]