Data validation for to check required fields are mapped
For readability I'd separate this into steps. Instead of doing your query within the declaration of your for loop, do it first. 

var fieldMappingOptions = collectionHelper.FieldMappingOptions
    .Where(fmo =&gt; 
        fmo.IsRequired 
        &amp;&amp; !fmo.IsCalculated 
        &amp;&amp; !fmo.FieldDefinition.Equals(MMPConstants.FieldDefinitions.FieldValue) 
        &amp;&amp; (implicitParents || anyParentMappings 
        || fmo.ContainerType == collectionHelper.SelectedOption.ContainerType))
    .ToArray();

var fieldMappingOptionsWithoutHelpers = fieldMappingOptions
    .Where(fmo =&gt; !collectionHelper.FieldMappingHelpers
            .Any(fmh =&gt; fmh.SelectedOption.Equals(fmo)));   

foreach(var fieldMappingOption in fieldMappingOptionsWithoutHelpers)


What this achieves is that the reader can break this into multiple steps: First, which fieldMappingOptions you're looking for, and second, what you're going to do with them, instead of trying to read all of that at one time.

Any way you can limit how many things that future developer has to follow at the same time will help him or her to read and understand your code more quickly.

That also means that you can potentially break it apart as needed more easily. For example, if the method gets too long, you could separate the first two lines into their own function that returns IEnumerable&lt;FieldMappingOption&gt;.

Also, every time you break up these steps you're going to have to declare a variable or a function, and every time you do that you get to give it a name. If the names are meaningful then your code becomes more self-documenting. That future developer might also be able to skip over parts they don't care about more quickly while still having some idea what those parts are, based on the names of the methods called.

Even some of the conditions in the Where clause could potentially be functions if that makes it more readable.

Just as an example:

public static void RequiresValue(this FieldMappingOption fieldMappingOption)
{
    return fieldMappingOption.isRequired
      &amp;&amp; !fmo.IsCalculated
      &amp;&amp; !fmo.FieldDefinition.Equals(MMPConstants.FieldDefinitions.FieldValue);
}


Now your Where clause could read:

var fieldMappingOptions = collectionHelper.FieldMappingOptions
    .Where(fmo =&gt; 
        fmo.RequiresValue()
        &amp;&amp; (implicitParents || anyParentMappings 
        || fmo.ContainerType == collectionHelper.SelectedOption.ContainerType))
    .ToArray();


(I have no idea if I got the logic or intent right.)

But that's the gist of my recommendation. Keep LINQ as readable as possible, don't feel like the whole thing has to be in one statement, and keep methods short (15 lines or less.)