feat: Add C# 14 MemoryExtensions.Contains support to BingTextSearch

Support detection of MemoryExtensions.Contains patterns in LINQ filters
for C# 14 compatibility. In C# 14, Contains over arrays/collections now
resolves to MemoryExtensions.Contains instead of Enumerable.Contains due
to 'first-class spans' overload resolution changes.

Since Bing Search API does not support OR logic across multiple values,
collection Contains patterns (e.g., array.Contains(page.Property)) throw
clear NotSupportedException explaining the limitation and suggesting
alternatives.

Changes:
- Add System.Diagnostics.CodeAnalysis using for NotNullWhen attribute
- Enhance Contains case to distinguish instance vs static method calls
- Add IsMemoryExtensionsContains helper to detect C# 14 patterns
- Throw NotSupportedException for both Enumerable and MemoryExtensions
  collection Contains patterns with clear actionable error messages
- Add 2 tests: collection Contains exception + String.Contains regression

Implements pattern awareness from PR #13263 by @roji
Addresses feedback on PR #13188 from @roji about C# 14 compatibility

Contributes to #10456 (LINQ filtering migration initiative)
Fixes #12504 compatibility for text search implementations

Author: alzarei

dotnet/src/Plugins/Plugins.UnitTests/Web/Bing/BingTextSearchTests.cs

@@ -871,6 +871,67 @@ public async Task GenericGetSearchResultsAsyncFilterTranslationPreservesBingWebP
         }
     }
 
+    [Fact]
+    public async Task CollectionContainsFilterThrowsNotSupportedExceptionAsync()
+    {
+        // Arrange - Tests both Enumerable.Contains (C# 13-) and MemoryExtensions.Contains (C# 14+)
+        // The same code array.Contains() resolves differently based on C# language version:
+        // - C# 13 and earlier: Enumerable.Contains (LINQ extension method)
+        // - C# 14 and later: MemoryExtensions.Contains (span-based optimization due to "first-class spans")
+        // Our implementation handles both identically since Bing API doesn't support OR logic for either
+        this._messageHandlerStub.AddJsonResponse(File.ReadAllText(WhatIsTheSKResponseJson));
+        ITextSearch<BingWebPage> textSearch = new BingTextSearch(apiKey: "ApiKey", options: new() { HttpClient = this._httpClient });
+        string[] languages = ["en", "fr"];
+
+        // Act & Assert - Verify that collection Contains pattern throws clear exception
+        var searchOptions = new TextSearchOptions<BingWebPage>
+        {
+            Top = 5,
+            Skip = 0,
+            Filter = page => languages.Contains(page.Language!)  // Enumerable.Contains (C# 13-) or MemoryExtensions.Contains (C# 14+)
+        };
+
+        var exception = await Assert.ThrowsAsync<NotSupportedException>(async () =>
+        {
+            await textSearch.SearchAsync("test", searchOptions);
+        });
+
+        // Assert - Verify error message explains the limitation clearly
+        Assert.Contains("Collection Contains filters", exception.Message);
+        Assert.Contains("not supported by Bing Search API", exception.Message);
+        Assert.Contains("OR logic", exception.Message);
+    }
+
+    [Fact]
+    public async Task StringContainsStillWorksWithLINQFiltersAsync()
+    {
+        // Arrange - Verify that String.Contains (instance method) still works
+        // String.Contains is NOT affected by C# 14 "first-class spans" - only arrays are
+        this._messageHandlerStub.AddJsonResponse(File.ReadAllText(WhatIsTheSKResponseJson));
+        ITextSearch<BingWebPage> textSearch = new BingTextSearch(apiKey: "ApiKey", options: new() { HttpClient = this._httpClient });
+
+        // Act - String.Contains should continue to work
+        var searchOptions = new TextSearchOptions<BingWebPage>
+        {
+            Top = 5,
+            Skip = 0,
+            Filter = page => page.Name.Contains("Semantic")  // String.Contains - instance method
+        };
+
+        KernelSearchResults<string> result = await textSearch.SearchAsync("test", searchOptions);
+
+        // Assert - Should succeed without exception
+        Assert.NotNull(result);
+        Assert.NotNull(result.Results);
+        var resultsList = await result.Results.ToListAsync();
+        Assert.NotEmpty(resultsList);
+
+        // Verify the filter was translated correctly to intitle: operator
+        var requestUris = this._messageHandlerStub.RequestUris;
+        Assert.Single(requestUris);
+        Assert.Contains("intitle%3ASemantic", requestUris[0]!.AbsoluteUri);
+    }
+
     #endregion
 
     /// <inheritdoc/>

dotnet/src/Plugins/Plugins.Web/Bing/BingTextSearch.cs

@@ -184,8 +184,34 @@ private static void ProcessExpression(Expression expression, TextSearchFilter fi
                 break;
 
             case MethodCallExpression methodExpr when methodExpr.Method.Name == "Contains":
-                // Handle Contains: page => page.Name.Contains("Microsoft")
-                ProcessContainsExpression(methodExpr, filter);
+                // Distinguish between instance method (String.Contains) and static method (Enumerable/MemoryExtensions.Contains)
+                if (methodExpr.Object is MemberExpression)
+                {
+                    // Instance method: page.Name.Contains("value") - SUPPORTED
+                    ProcessContainsExpression(methodExpr, filter);
+                }
+                else if (methodExpr.Object == null)
+                {
+                    // Static method: could be Enumerable.Contains (C# 13-) or MemoryExtensions.Contains (C# 14+)
+                    // Bing API doesn't support OR logic, so collection Contains patterns are not supported
+                    if (methodExpr.Method.DeclaringType == typeof(Enumerable) ||
+                        (methodExpr.Method.DeclaringType == typeof(MemoryExtensions) && IsMemoryExtensionsContains(methodExpr)))
+                    {
+                        throw new NotSupportedException(
+                            "Collection Contains filters (e.g., array.Contains(page.Property)) are not supported by Bing Search API. " +
+                            "Bing's advanced search operators do not support OR logic across multiple values. " +
+                            "Supported pattern: Property.Contains(\"value\") for string properties like Name, Snippet, or Url. " +
+                            "For multiple value matching, consider alternative approaches or use a different search provider.");
+                    }
+
+                    throw new NotSupportedException(
+                        $"Contains() method from {methodExpr.Method.DeclaringType?.Name} is not supported.");
+                }
+                else
+                {
+                    throw new NotSupportedException(
+                        "Contains() must be called on a property (e.g., page.Name.Contains(\"value\")).");
+                }
                 break;
 
             default:
@@ -315,6 +341,24 @@ private static void ProcessContainsExpression(MethodCallExpression methodExpr, T
         }
     }
 
+    /// <summary>
+    /// Determines if a MethodCallExpression is a MemoryExtensions.Contains call (C# 14 "first-class spans" feature).
+    /// </summary>
+    /// <param name="methodExpr">The method call expression to check.</param>
+    /// <returns>True if this is a MemoryExtensions.Contains call with supported parameters; otherwise false.</returns>
+    private static bool IsMemoryExtensionsContains(MethodCallExpression methodExpr)
+    {
+        // MemoryExtensions.Contains has 2-3 parameters:
+        // - Contains<T>(ReadOnlySpan<T> span, T value)
+        // - Contains<T>(ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer)
+        // We only support when comparer is null or omitted
+        return methodExpr.Method.Name == nameof(MemoryExtensions.Contains) &&
+               methodExpr.Arguments.Count >= 2 &&
+               methodExpr.Arguments.Count <= 3 &&
+               (methodExpr.Arguments.Count == 2 ||
+                (methodExpr.Arguments.Count == 3 && methodExpr.Arguments[2] is ConstantExpression { Value: null }));
+    }
+
     /// <summary>
     /// Maps BingWebPage property names to Bing API filter field names for equality operations.
     /// </summary>