Скачать или смотреть How to Create a Not Contains Expression Tree in C#

Learn how to construct a `not contains` expression tree in C# using the Expression API. This simple guide walks you through the process step by step.
---
This video is based on the question https://stackoverflow.com/q/64848813/ asked by the user 'Andrey' ( https://stackoverflow.com/u/8388835/ ) and on the answer https://stackoverflow.com/a/64849183/ provided by the user 'Prolog' ( https://stackoverflow.com/u/8065832/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Expression tree - not contains

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Problem: Not Contains Expression in C#

When working with C# and expression trees, you may find yourself needing to check if one string does not contain another. This is a common requirement, especially when filtering data in queries or handling input validation. While you may be familiar with using the Contains method, creating a negated expression for not contains can be a bit tricky.

In this post, we'll explore how to build a not contains expression tree using C# . If you have successfully implemented the basic Contains method, you're already halfway there! Let’s break down the solution step-by-step.

Setting Up: The Contains Expression

First, let's recall how you would normally write a check for containment in C# :

[[See Video to Reveal this Text or Code Snippet]]

In this example, the Contains method checks if the string "foo" contains the character "o". The logical negation operator (!) is used to negate the result.

Transition to Expression Trees

To construct an equivalent expression tree for the Contains method, you would typically use the Expression class in C# . Here’s how the expression for the Contains method looks:

[[See Video to Reveal this Text or Code Snippet]]

In this line, firstOrDefaultCall is an expression representing the string you are checking, and text is the string you want to search for.

Creating the Not Contains Expression

Now, to achieve a not contains expression, the key step is introducing the Expression.Not() method to negate the result of the Contains method. Here’s how you can do that:

[[See Video to Reveal this Text or Code Snippet]]

Explanation of the Code:

Expression.Call: This constructs a call to the Contains method on the target string.

Expression.Constant: This creates a constant expression for the string you are searching for.

Expression.Not: This negates the result of the Contains method, thereby giving you the desired not contains functionality.

Common Pitfalls to Avoid

While building your expression, it's crucial not to confuse Expression.Not() with Expression.Negate(). The latter is intended for arithmetic negation (like multiplying a number by -1), not for logical operations. For example:

[[See Video to Reveal this Text or Code Snippet]]

Using Expression.Negate() in place of Expression.Not() could lead to unexpected errors or behavior in your application.

Conclusion

Building a not contains expression tree in C# is a straightforward process once you understand the proper usage of expression methods. By leveraging Expression.Call() and Expression.Not(), you can effectively construct the desired logic for filtering data based on string contents.

Quick Recap:

Use Expression.Call() to call the Contains method.

Wrap it with Expression.Not() to negate the result.

Never confuse logical negation with arithmetic negation.

Feel free to apply this approach in your C# projects to enhance your expression tree manipulations and achieve more complex query capabilities!