<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Remotion.Linq</name>
    </assembly>
    <members>
        <member name="T:JetBrains.Annotations.AssertionConditionAttribute">
            <summary>
            Indicates the condition parameter of the assertion method. 
            The method itself should be marked by <see cref="T:JetBrains.Annotations.AssertionMethodAttribute"/> attribute.
            The mandatory argument of the attribute is the assertion type.
            </summary>
            <seealso cref="T:JetBrains.Annotations.AssertionConditionType"/>
        </member>
        <member name="M:JetBrains.Annotations.AssertionConditionAttribute.#ctor(JetBrains.Annotations.AssertionConditionType)">
            <summary>
            Initializes new instance of AssertionConditionAttribute
            </summary>
            <param name="conditionType">Specifies condition type</param>
        </member>
        <member name="P:JetBrains.Annotations.AssertionConditionAttribute.ConditionType">
            <summary>
            Gets condition type
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.AssertionConditionType">
            <summary>
            Specifies assertion type. If the assertion method argument satisifes the condition, then the execution continues. 
            Otherwise, execution is assumed to be halted
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.AssertionConditionType.IS_TRUE">
            <summary>
            Indicates that the marked parameter should be evaluated to true
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.AssertionConditionType.IS_FALSE">
            <summary>
            Indicates that the marked parameter should be evaluated to false
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.AssertionConditionType.IS_NULL">
            <summary>
            Indicates that the marked parameter should be evaluated to null value
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.AssertionConditionType.IS_NOT_NULL">
            <summary>
            Indicates that the marked parameter should be evaluated to not null value
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.AssertionMethodAttribute">
            <summary>
            Indicates that the marked method is assertion method, i.e. it halts control flow if one of the conditions is satisfied. 
            To set the condition, mark one of the parameters with <see cref="T:JetBrains.Annotations.AssertionConditionAttribute"/> attribute
            </summary>
            <seealso cref="T:JetBrains.Annotations.AssertionConditionAttribute"/>
        </member>
        <member name="T:JetBrains.Annotations.BaseTypeRequiredAttribute">
            <summary>
            When applied to target attribute, specifies a requirement for any type which is marked with 
            target attribute to implement or inherit specific type or types
            </summary>
            <example>
            <code>
            [BaseTypeRequired(typeof(IComponent)] // Specify requirement
            public class ComponentAttribute : Attribute 
            {}
            
            [Component] // ComponentAttribute requires implementing IComponent interface
            public class MyComponent : IComponent
            {}
            </code>
            </example>
        </member>
        <member name="M:JetBrains.Annotations.BaseTypeRequiredAttribute.#ctor(System.Type)">
            <summary>
            Initializes new instance of BaseTypeRequiredAttribute
            </summary>
            <param name="baseType">Specifies which types are required</param>
        </member>
        <member name="P:JetBrains.Annotations.BaseTypeRequiredAttribute.BaseTypes">
            <summary>
            Gets enumerations of specified base types
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.CanBeNullAttribute">
            <summary>
            Indicates that the value of marked element could be <c>null</c> sometimes, so the check for <c>null</c> is necessary before its usage
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.CannotApplyEqualityOperatorAttribute">
            <summary>
            Indicates that the value of marked type (or its derivatives) cannot be compared using '==' or '!=' operators.
            There is only exception to compare with <c>null</c>, it is permitted
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.ContractAnnotationAttribute">
            <summary>
            Describes dependency between method input and output
            </summary>
            <syntax>
            <p>Function definition table syntax:</p>
            <list>
            <item>FDT      ::= FDTRow [;FDTRow]*</item>
            <item>FDTRow   ::= Input =&gt; Output | Output &lt;= Input</item>
            <item>Input    ::= ParameterName: Value [, Input]*</item>
            <item>Output   ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}</item>
            <item>Value    ::= true | false | null | notnull | canbenull</item>
            </list>
            If method has single input parameter, it's name could be omitted. <br/>
            Using "halt" (or "void"/"nothing", which is the same) for method output means that methos doesn't return normally. <br/>
            "canbenull" annotation is only applicable for output parameters. <br/>
            You can use multiple [ContractAnnotation] for each FDT row, or use single attribute with rows separated by semicolon. <br/>
            </syntax>
            <examples>
            <list>
            <item>[ContractAnnotation("=> halt")] public void TerminationMethod()</item>
            <item>[ContractAnnotation("halt &lt;= condition: false")] public void Assert(bool condition, string text) // Regular Assertion method</item>
            <item>[ContractAnnotation("s:null => true")] public bool IsNullOrEmpty(string s) // String.IsNullOrEmpty</item>
            <item>[ContractAnnotation("null => null; notnull => notnull")] public object Transform(object data) // Method which returns null if parameter is null, and not null if parameter is not null</item>
            <item>[ContractAnnotation("s:null=>false; =>true,result:notnull; =>false, result:null")] public bool TryParse(string s, out Person result)</item>
            </list>
            </examples>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.Access">
            <summary>
            Only entity marked with attribute considered used
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.Assign">
            <summary>
            Indicates implicit assignment to a member
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature">
            <summary>
            Indicates implicit instantiation of a type with fixed constructor signature.
            That means any unused constructor parameters won't be reported as such.
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature">
            <summary>
            Indicates implicit instantiation of a type
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.ImplicitUseTargetFlags">
            <summary>
            Specify what is considered used implicitly when marked with <see cref="T:JetBrains.Annotations.MeansImplicitUseAttribute"/> or <see cref="T:JetBrains.Annotations.UsedImplicitlyAttribute"/>
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseTargetFlags.Members">
            <summary>
            Members of entity marked with attribute are considered used
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseTargetFlags.WithMembers">
            <summary>
            Entity marked with attribute and all its members considered used
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.InstantHandleAttribute">
            <summary>
            Tells code analysis engine if the parameter is completely handled when the invoked method is on stack. 
            If the parameter is delegate, indicates that delegate is executed while the method is executed.
            If the parameter is enumerable, indicates that it is enumerated while the method is executed.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.InvokerParameterNameAttribute">
            <summary>
            Indicates that the function argument should be string literal and match one of the parameters of the caller function.
            For example, <see cref="T:System.ArgumentNullException"/> has such parameter.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.LinqTunnelAttribute">
            <summary>
            Indicates that method is *pure* linq method, with postponed enumeration. C# iterator methods (yield ...) are always LinqTunnel.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.LocalizationRequiredAttribute">
            <summary>
            Indicates that marked element should be localized or not.
            </summary>
        </member>
        <member name="M:JetBrains.Annotations.LocalizationRequiredAttribute.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:JetBrains.Annotations.LocalizationRequiredAttribute"/> class with
            <see cref="P:JetBrains.Annotations.LocalizationRequiredAttribute.Required"/> set to <see langword="true"/>.
            </summary>
        </member>
        <member name="M:JetBrains.Annotations.LocalizationRequiredAttribute.#ctor(System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:JetBrains.Annotations.LocalizationRequiredAttribute"/> class.
            </summary>
            <param name="required"><c>true</c> if a element should be localized; otherwise, <c>false</c>.</param>
        </member>
        <member name="M:JetBrains.Annotations.LocalizationRequiredAttribute.Equals(System.Object)">
            <summary>
            Returns whether the value of the given object is equal to the current <see cref="T:JetBrains.Annotations.LocalizationRequiredAttribute"/>.
            </summary>
            <param name="obj">The object to test the value equality of. </param>
            <returns>
            <c>true</c> if the value of the given object is equal to that of the current; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:JetBrains.Annotations.LocalizationRequiredAttribute.GetHashCode">
            <summary>
            Returns the hash code for this instance.
            </summary>
            <returns>A hash code for the current <see cref="T:JetBrains.Annotations.LocalizationRequiredAttribute"/>.</returns>
        </member>
        <member name="P:JetBrains.Annotations.LocalizationRequiredAttribute.Required">
            <summary>
            Gets a value indicating whether a element should be localized.
            <value><c>true</c> if a element should be localized; otherwise, <c>false</c>.</value>
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.MeansImplicitUseAttribute">
            <summary>
            Should be used on attributes and causes ReSharper to not mark symbols marked with such attributes as unused (as well as by other usage inspections)
            </summary>
        </member>
        <member name="P:JetBrains.Annotations.MeansImplicitUseAttribute.TargetFlags">
            <summary>
            Gets value indicating what is meant to be used
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.NoEnumerationAttribute">
            <summary>
            Indicates that IEnumarable, passed as parameter, is not enumerated.
            
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.NotifyPropertyChangedInvocatorAttribute">
            <summary>
            Indicates that the function is used to notify class type property value is changed.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.NotNullAttribute">
            <summary>
            Indicates that the value of marked element could never be <c>null</c>
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.PublicAPIAttribute">
            <summary>
            This attribute is intended to mark publicly available API which should not be removed and so is treated as used.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.PureAttribute">
            <summary>
            Indicates that method doesn't contain observable side effects.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.StringFormatMethodAttribute">
            <summary>
            Indicates that marked method builds string by format pattern and (optional) arguments. 
            Parameter, which contains format string, should be given in constructor.
            The format string should be in <see cref="M:System.String.Format(System.IFormatProvider,System.String,System.Object[])"/> -like form
            </summary>
        </member>
        <member name="M:JetBrains.Annotations.StringFormatMethodAttribute.#ctor(System.String)">
            <summary>
            Initializes new instance of StringFormatMethodAttribute
            </summary>
            <param name="formatParameterName">Specifies which parameter of an annotated method should be treated as format-string</param>
        </member>
        <member name="P:JetBrains.Annotations.StringFormatMethodAttribute.FormatParameterName">
            <summary>
            Gets format parameter name
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.TerminatesProgramAttribute">
            <summary>
            Indicates that the marked method unconditionally terminates control flow execution.
            For example, it could unconditionally throw exception
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.UsedImplicitlyAttribute">
            <summary>
            Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library),
            so this symbol will not be marked as unused (as well as by other usage inspections)
            </summary>
        </member>
        <member name="P:JetBrains.Annotations.UsedImplicitlyAttribute.TargetFlags">
            <summary>
            Gets value indicating what is meant to be used
            </summary>
        </member>
        <member name="T:Remotion.Utilities.ArgumentUtility">
            <summary>
            This utility class provides methods for checking arguments.
            </summary>
            <remarks>
            Some methods of this class return the value of the parameter. In some cases, this is useful because the value will be converted to another 
            type:
            <code><![CDATA[
            void foo (object o) 
            {
              int i = ArgumentUtility.CheckNotNullAndType<int> ("o", o);
            }
            ]]></code>
            In some other cases, the input value is returned unmodified. This makes it easier to use the argument checks in calls to base class constructors
            or property setters:
            <code><![CDATA[
            class MyType : MyBaseType
            {
              public MyType (string name) : base (ArgumentUtility.CheckNotNullOrEmpty ("name", name))
              {
              }
            
              public override Name
              {
                set { base.Name = ArgumentUtility.CheckNotNullOrEmpty ("value", value); }
              }
            }
            ]]></code>
            </remarks>
        </member>
        <member name="M:Remotion.Utilities.ArgumentUtility.CheckNotNullAndType``1(System.String,System.Object)">
            <summary>Returns the value itself if it is not <see langword="null"/> and of the specified value type.</summary>
            <typeparam name="TExpected"> The type that <paramref name="actualValue"/> must have. </typeparam>
            <exception cref="T:System.ArgumentNullException">The <paramref name="actualValue"/> is a <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">The <paramref name="actualValue"/> is an instance of another type.</exception>
        </member>
        <member name="M:Remotion.Utilities.ArgumentUtility.DebugCheckNotNullAndType(System.String,System.Object,System.Type)">
            <summary>Checks of the <paramref name="actualValue"/> is of the <paramref name="expectedType"/>.</summary>
            <exception cref="T:System.ArgumentNullException">The <paramref name="actualValue"/> is a <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">The <paramref name="actualValue"/> is an instance of another type.</exception>
        </member>
        <member name="M:Remotion.Utilities.ArgumentUtility.CheckType``1(System.String,System.Object)">
            <summary>Returns the value itself if it is of the specified type.</summary>
            <typeparam name="TExpected"> The type that <paramref name="actualValue"/> must have. </typeparam>
            <exception cref="T:System.ArgumentException"> 
                <paramref name="actualValue"/> is an instance of another type (which is not a subtype of <typeparamref name="TExpected"/>).</exception>
            <exception cref="T:System.ArgumentNullException"> 
                <paramref name="actualValue"/> is null and <typeparamref name="TExpected"/> cannot be null. </exception>
            <remarks>
              For non-nullable value types, you should use either <see cref="M:Remotion.Utilities.ArgumentUtility.CheckNotNullAndType``1(System.String,System.Object)"/> or pass the type 
              <see cref="T:System.Nullable`1"/> instead.
            </remarks>
        </member>
        <member name="M:Remotion.Utilities.ArgumentUtility.CheckNotNullAndTypeIsAssignableFrom(System.String,System.Type,System.Type)">
            <summary>Checks whether <paramref name="actualType"/> is not <see langword="null"/> and can be assigned to <paramref name="expectedType"/>.</summary>
            <exception cref="T:System.ArgumentNullException">The <paramref name="actualType"/> is <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">The <paramref name="actualType"/> cannot be assigned to <paramref name="expectedType"/>.</exception>
        </member>
        <member name="M:Remotion.Utilities.ArgumentUtility.CheckTypeIsAssignableFrom(System.String,System.Type,System.Type)">
            <summary>Checks whether <paramref name="actualType"/> can be assigned to <paramref name="expectedType"/>.</summary>
            <exception cref="T:System.ArgumentException">The <paramref name="actualType"/> cannot be assigned to <paramref name="expectedType"/>.</exception>
        </member>
        <member name="M:Remotion.Utilities.ArgumentUtility.DebugCheckTypeIsAssignableFrom(System.String,System.Type,System.Type)">
            <summary>Checks whether <paramref name="actualType"/> can be assigned to <paramref name="expectedType"/>.</summary>
            <exception cref="T:System.ArgumentException">The <paramref name="actualType"/> cannot be assigned to <paramref name="expectedType"/>.</exception>
        </member>
        <member name="M:Remotion.Utilities.ArgumentUtility.CheckItemsType``1(System.String,``0,System.Type)">
            <summary>Checks whether all items in <paramref name="collection"/> are of type <paramref name="itemType"/> or a null reference.</summary>
            <exception cref="T:System.ArgumentException"> If at least one element is not of the specified type or a derived type. </exception>
        </member>
        <member name="M:Remotion.Utilities.ArgumentUtility.CheckItemsNotNullAndType``1(System.String,``0,System.Type)">
            <summary>Checks whether all items in <paramref name="collection"/> are of type <paramref name="itemType"/> and not null references.</summary>
            <exception cref="T:System.ArgumentException"> If at least one element is not of the specified type or a derived type. </exception>
            <exception cref="T:System.ArgumentNullException"> If at least one element is a null reference. </exception>
        </member>
        <member name="T:Remotion.Utilities.Assertion">
            <summary>
            Provides methods that throw an <see cref="T:System.InvalidOperationException"/> if an assertion fails.
            </summary>
            <remarks>
              <para>
              This class contains methods that are conditional to the DEBUG and TRACE attributes (<see cref="M:Remotion.Utilities.Assertion.DebugAssert(System.Boolean)"/> and <see cref="M:Remotion.Utilities.Assertion.TraceAssert(System.Boolean)"/>). 
              </para><para>
              Note that assertion expressions passed to these methods are not evaluated (read: executed) if the respective symbol are not defined during
              compilation, nor are the methods called. This increases performance for production builds, but make sure that your assertion expressions do
              not cause any side effects! See <see cref="T:System.Diagnostics.ConditionalAttribute"/> or <see cref="T:System.Diagnostics.Debug"/> and <see cref="T:System.Diagnostics.Trace"/> the for more information 
              about conditional compilation.
              </para><para>
              Assertions are no replacement for checking input parameters of public methods (see <see cref="T:Remotion.Utilities.ArgumentUtility"/>).  
              </para>
            </remarks>
        </member>
        <member name="M:Remotion.Utilities.NullableTypeUtility.IsNullableType(System.Type)">
            <summary>
            Determines whether a type is nullable, ie. whether variables of it can be assigned <see langword="null"/>.
            </summary>
            <param name="type">The type to check.</param>
            <returns>
            true if <paramref name="type"/> is nullable; otherwise, false.
            </returns>
            <remarks>
            A type is nullable if it is a reference type or a nullable value type. This method returns false only for non-nullable value types.
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Clauses.AdditionalFromClause">
            <summary>
            Represents a data source in a query that adds new data items in addition to those provided by the <see cref="T:Remotion.Linq.Clauses.MainFromClause"/>.
            </summary>
            <example>
            In C#, the second "from" clause in the following sample corresponds to an <see cref="T:Remotion.Linq.Clauses.AdditionalFromClause"/>:
            <ode>
            var query = from s in Students
                        from f in s.Friends
                        select f;
            </ode>
            </example>
        </member>
        <member name="T:Remotion.Linq.Clauses.FromClauseBase">
            <summary>
            Base class for <see cref="T:Remotion.Linq.Clauses.AdditionalFromClause"/> and <see cref="T:Remotion.Linq.Clauses.MainFromClause"/>.
            </summary>
            <seealso cref="T:Remotion.Linq.Clauses.IFromClause"/>
        </member>
        <member name="T:Remotion.Linq.Clauses.IFromClause">
            <summary>
            Common interface for from clauses (<see cref="T:Remotion.Linq.Clauses.AdditionalFromClause"/> and <see cref="T:Remotion.Linq.Clauses.MainFromClause"/>). From clauses define query sources that
            provide data items to the query which are filtered, ordered, projected, or otherwise processed by the following clauses.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.IClause">
            <summary>
            Represents a clause within the <see cref="T:Remotion.Linq.QueryModel"/>. Implemented by <see cref="T:Remotion.Linq.Clauses.MainFromClause"/>, <see cref="T:Remotion.Linq.Clauses.SelectClause"/>, 
            <see cref="T:Remotion.Linq.Clauses.IBodyClause"/>, and <see cref="T:Remotion.Linq.Clauses.JoinClause"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.IClause.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this clause and its child objects via the given <paramref name="transformation"/> delegate.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression"/> within this 
            clause, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="T:Remotion.Linq.Clauses.IQuerySource">
            <summary>
            Represents a clause or result operator that generates items which are streamed to the following clauses or operators.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Clauses.IQuerySource.ItemName">
            <summary>
            Gets the name of the items generated by this <see cref="T:Remotion.Linq.Clauses.IQuerySource"/>.
            </summary>
            <remarks>
            Item names are inferred when a query expression is parsed, and they usually correspond to the variable names present in that expression. 
            However, note that names are not necessarily unique within a <see cref="T:Remotion.Linq.QueryModel"/>. Use names only for readability and debugging, not for 
            uniquely identifying <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> objects. To match an <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> with its references, use the 
            <see cref="P:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource"/> property rather than the <see cref="P:Remotion.Linq.Clauses.IQuerySource.ItemName"/>.
            </remarks>
        </member>
        <member name="P:Remotion.Linq.Clauses.IQuerySource.ItemType">
            <summary>
            Gets the type of the items generated by this <see cref="T:Remotion.Linq.Clauses.IQuerySource"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.IFromClause.CopyFromSource(Remotion.Linq.Clauses.IFromClause)">
            <summary>
            Copies the <paramref name="source"/>'s attributes, i.e. the <see cref="P:Remotion.Linq.Clauses.IQuerySource.ItemName"/>, <see cref="P:Remotion.Linq.Clauses.IQuerySource.ItemType"/>, and
            <see cref="P:Remotion.Linq.Clauses.IFromClause.FromExpression"/>.
            </summary>
            <param name="source"></param>
        </member>
        <member name="P:Remotion.Linq.Clauses.IFromClause.FromExpression">
            <summary>
            The expression generating the data items for this from clause.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.FromClauseBase.#ctor(System.String,System.Type,System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.FromClauseBase"/> class.
            </summary>
            <param name="itemName">A name describing the items generated by the from clause.</param>
            <param name="itemType">The type of the items generated by the from clause.</param>
            <param name="fromExpression">The <see cref="T:System.Linq.Expressions.Expression"/> generating data items for this from clause.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.FromClauseBase.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this clause and its child objects via the given <paramref name="transformation"/> delegate.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression"/> within this
            clause, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="P:Remotion.Linq.Clauses.FromClauseBase.ItemName">
            <summary>
            Gets or sets a name describing the items generated by this from clause.
            </summary>
            <remarks>
            Item names are inferred when a query expression is parsed, and they usually correspond to the variable names present in that expression. 
            However, note that names are not necessarily unique within a <see cref="T:Remotion.Linq.QueryModel"/>. Use names only for readability and debugging, not for 
            uniquely identifying <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> objects. To match an <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> with its references, use the 
            <see cref="P:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource"/> property rather than the <see cref="P:Remotion.Linq.Clauses.FromClauseBase.ItemName"/>.
            </remarks>
        </member>
        <member name="P:Remotion.Linq.Clauses.FromClauseBase.ItemType">
            <summary>
            Gets or sets the type of the items generated by this from clause.
            </summary>
            <note type="warning">
            Changing the <see cref="P:Remotion.Linq.Clauses.FromClauseBase.ItemType"/> of a <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> can make all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> objects that
            point to that <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> invalid, so the property setter should be used with care.
            </note>
        </member>
        <member name="P:Remotion.Linq.Clauses.FromClauseBase.FromExpression">
            <summary>
            The expression generating the data items for this from clause.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.IBodyClause">
            <summary>
            Represents a clause in a <see cref="T:Remotion.Linq.QueryModel"/>'s <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> collection. Body clauses take the items generated by 
            the <see cref="P:Remotion.Linq.QueryModel.MainFromClause"/>, filtering (<see cref="T:Remotion.Linq.Clauses.WhereClause"/>), ordering (<see cref="T:Remotion.Linq.Clauses.OrderByClause"/>), augmenting 
            (<see cref="T:Remotion.Linq.Clauses.AdditionalFromClause"/>), or otherwise processing them before they are passed to the <see cref="P:Remotion.Linq.QueryModel.SelectClause"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.IBodyClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,System.Int32)">
            <summary>
            Accepts the specified visitor by calling one of its Visit... methods.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
            <param name="index">The index of this clause in the <paramref name="queryModel"/>'s <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> collection.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.IBodyClause.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this clause, registering its clone with the <paramref name="cloneContext"/> if it is a query source clause.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns>A clone of this clause.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.AdditionalFromClause.#ctor(System.String,System.Type,System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.AdditionalFromClause"/> class.
            </summary>
            <param name="itemName">A name describing the items generated by the from clause.</param>
            <param name="itemType">The type of the items generated by the from clause.</param>
            <param name="fromExpression">The <see cref="T:System.Linq.Expressions.Expression"/> generating the items of this from clause.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.AdditionalFromClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,System.Int32)">
            <summary>
            Accepts the specified visitor by calling its <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitAdditionalFromClause(Remotion.Linq.Clauses.AdditionalFromClause,Remotion.Linq.QueryModel,System.Int32)"/> method.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
            <param name="index">The index of this clause in the <paramref name="queryModel"/>'s <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> collection.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.AdditionalFromClause.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this clause, registering its clone with the <paramref name="cloneContext"/>.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns>A clone of this clause.</returns>
        </member>
        <member name="T:Remotion.Linq.Clauses.CloneContext">
            <summary>
            Aggregates all objects needed in the process of cloning a <see cref="T:Remotion.Linq.QueryModel"/> and its clauses.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Clauses.CloneContext.QuerySourceMapping">
            <summary>
            Gets the clause mapping used during the cloning process. This is used to adjust the <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> instances
            of clauses to point to clauses in the cloned <see cref="T:Remotion.Linq.QueryModel"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.Expressions.IPartialEvaluationExceptionExpressionVisitor">
            <summary>
            This interface should be implemented by visitors that handle the <see cref="T:Remotion.Linq.Clauses.Expressions.PartialEvaluationExceptionExpression"/> instances.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.Expressions.IVBSpecificExpressionVisitor">
            <summary>
            This interface should be implemented by visitors that handle VB-specific expressions.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.Expressions.PartialEvaluationExceptionExpression">
            <summary>
            Wraps an exception whose partial evaluation caused an exception.
            </summary>
            <remarks>
            <para>
            When <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.PartialEvaluatingExpressionVisitor"/> encounters an exception while evaluating an independent expression subtree, it
            will wrap the subtree within a <see cref="T:Remotion.Linq.Clauses.Expressions.PartialEvaluationExceptionExpression"/>. The wrapper contains both the <see cref="P:Remotion.Linq.Clauses.Expressions.PartialEvaluationExceptionExpression.Exception"/> 
            instance and the <see cref="P:Remotion.Linq.Clauses.Expressions.PartialEvaluationExceptionExpression.EvaluatedExpression"/> that caused the exception.
            </para>
            <para>
            To explicitly support this expression type, implement  <see cref="T:Remotion.Linq.Clauses.Expressions.IPartialEvaluationExceptionExpressionVisitor"/>.
            To ignore this wrapper and only handle the inner <see cref="P:Remotion.Linq.Clauses.Expressions.PartialEvaluationExceptionExpression.EvaluatedExpression"/>, call the <see cref="M:Remotion.Linq.Clauses.Expressions.PartialEvaluationExceptionExpression.Reduce"/> method and visit the result.
            </para>
            <para>
            Subclasses of <see cref="T:Remotion.Linq.Parsing.ThrowingExpressionVisitor"/> that do not implement <see cref="T:Remotion.Linq.Clauses.Expressions.IPartialEvaluationExceptionExpressionVisitor"/> will, 
            by default, automatically reduce this expression type to the <see cref="P:Remotion.Linq.Clauses.Expressions.PartialEvaluationExceptionExpression.EvaluatedExpression"/> in the 
            <see cref="M:Remotion.Linq.Parsing.ThrowingExpressionVisitor.VisitExtension(System.Linq.Expressions.Expression)"/> method.
            </para>
            <para>
            Subclasses of <see cref="T:Remotion.Linq.Parsing.RelinqExpressionVisitor"/> that do not implement <see cref="T:Remotion.Linq.Clauses.Expressions.IPartialEvaluationExceptionExpressionVisitor"/> will, 
            by default, ignore this expression and visit its child expressions via the <see cref="M:System.Linq.Expressions.ExpressionVisitor.VisitExtension(System.Linq.Expressions.Expression)"/> and 
            <see cref="M:Remotion.Linq.Clauses.Expressions.PartialEvaluationExceptionExpression.VisitChildren(System.Linq.Expressions.ExpressionVisitor)"/> methods.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression">
            <summary>
            Represents an expression tree node that points to a query source represented by a <see cref="T:Remotion.Linq.Clauses.FromClauseBase"/>. These expressions should always
            point back, to a clause defined prior to the clause holding a <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/>. Otherwise, exceptions might be 
            thrown at runtime.
            </summary>
            <remarks>
            This particular expression overrides <see cref="M:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.Equals(System.Object)"/>, i.e. it can be compared to another <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> based
            on the <see cref="P:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource"/>.
            </remarks>
        </member>
        <member name="M:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.Equals(System.Object)">
            <summary>
            Determines whether the specified <see cref="T:System.Object"/> is equal to the current <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> by 
            comparing the <see cref="P:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource"/> properties for reference equality.
            </summary>
            <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/>.</param>
            <returns>
            <see langword="true"/> if the specified <see cref="T:System.Object"/> is a <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> that points to the 
            same <see cref="P:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource"/>; otherwise, false.
            </returns>
        </member>
        <member name="P:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource">
            <summary>
            Gets the query source referenced by this expression.
            </summary>
            <value>The referenced query source.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.Expressions.SubQueryExpression">
            <summary>
            Represents an <see cref="T:System.Linq.Expressions.Expression"/> that holds a subquery. The subquery is held by <see cref="P:Remotion.Linq.Clauses.Expressions.SubQueryExpression.QueryModel"/> in its parsed form.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.Expressions.VBStringComparisonExpression">
            <summary>
            Represents a VB-specific comparison expression.
            </summary>
            <remarks>
            <para>
            To explicitly support this expression type, implement <see cref="T:Remotion.Linq.Clauses.Expressions.IVBSpecificExpressionVisitor"/>.
            To treat this expression as if it were an ordinary <see cref="T:System.Linq.Expressions.BinaryExpression"/>, call its <see cref="M:Remotion.Linq.Clauses.Expressions.VBStringComparisonExpression.Reduce"/> method and visit the result.
            </para>
            <para>
            Subclasses of <see cref="T:Remotion.Linq.Parsing.ThrowingExpressionVisitor"/> that do not implement <see cref="T:Remotion.Linq.Clauses.Expressions.IVBSpecificExpressionVisitor"/> will, by default, 
            automatically reduce this expression type to <see cref="T:System.Linq.Expressions.BinaryExpression"/> in the <see cref="M:Remotion.Linq.Parsing.ThrowingExpressionVisitor.VisitExtension(System.Linq.Expressions.Expression)"/> method.
            </para>
            <para>
            Subclasses of <see cref="T:Remotion.Linq.Parsing.RelinqExpressionVisitor"/> that do not implement <see cref="T:Remotion.Linq.Clauses.Expressions.IVBSpecificExpressionVisitor"/> will, by default, 
            ignore this expression and visit its child expressions via the <see cref="M:System.Linq.Expressions.ExpressionVisitor.VisitExtension(System.Linq.Expressions.Expression)"/> and 
            <see cref="M:Remotion.Linq.Clauses.Expressions.VBStringComparisonExpression.VisitChildren(System.Linq.Expressions.ExpressionVisitor)"/> methods.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Clauses.ExpressionVisitors.AccessorFindingExpressionVisitor">
            <summary>
            Constructs a <see cref="T:System.Linq.Expressions.LambdaExpression"/> that is able to extract a specific simple expression from a complex <see cref="T:System.Linq.Expressions.NewExpression"/>
            or <see cref="T:System.Linq.Expressions.MemberInitExpression"/>.
            </summary>
            <example>
            <para>
            For example, consider the task of determining the value of a specific query source [s] from an input value corresponding to a complex 
            expression. This <see cref="T:Remotion.Linq.Clauses.ExpressionVisitors.AccessorFindingExpressionVisitor"/> will return a <see cref="T:System.Linq.Expressions.LambdaExpression"/> able to perform this task.
            </para>
            <para>
            <list type="bullet">
            <item>If the complex expression is [s], it will simply return input =&gt; input.</item>
            <item>If the complex expression is new { a = [s], b = "..." }, it will return input =&gt; input.a.</item>
            <item>If the complex expression is new { a = new { b = [s], c = "..." }, d = "..." }, it will return input =&gt; input.a.b.</item>
            </list>
            </para>
            </example>
        </member>
        <member name="T:Remotion.Linq.Parsing.RelinqExpressionVisitor">
            <summary>
            Provides a base class for expression visitors used with re-linq, adding support for <see cref="T:Remotion.Linq.Clauses.Expressions.SubQueryExpression"/> and <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.RelinqExpressionVisitor.AdjustArgumentsForNewExpression(System.Collections.Generic.IList{System.Linq.Expressions.Expression},System.Collections.Generic.IList{System.Reflection.MemberInfo})">
            <summary>
            Adjusts the arguments for a <see cref="T:System.Linq.Expressions.NewExpression"/> so that they match the given members.
            </summary>
            <param name="arguments">The arguments to adjust.</param>
            <param name="members">The members defining the required argument types.</param>
            <returns>
            A sequence of expressions that are equivalent to <paramref name="arguments"/>, but converted to the associated member's
            result type if needed.
            </returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.ExpressionVisitors.AccessorFindingExpressionVisitor.FindAccessorLambda(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.ParameterExpression)">
            <summary>
            Constructs a <see cref="T:System.Linq.Expressions.LambdaExpression"/> that is able to extract a specific simple <paramref name="searchedExpression"/> from a 
            complex <paramref name="fullExpression"/>.
            </summary>
            <param name="searchedExpression">The expression an accessor to which should be created.</param>
            <param name="fullExpression">The full expression containing the <paramref name="searchedExpression"/>.</param>
            <param name="inputParameter">The input parameter to be used by the resulting lambda. Its type must match the type of <paramref name="fullExpression"/>.</param>
            <remarks>The <see cref="T:Remotion.Linq.Clauses.ExpressionVisitors.AccessorFindingExpressionVisitor"/> compares the <paramref name="searchedExpression"/> via reference equality,
            which means that exactly the same expression reference must be contained by <paramref name="fullExpression"/> for the visitor to return the
            expected result. In addition, the visitor can only provide accessors for expressions nested in <see cref="T:System.Linq.Expressions.NewExpression"/> or 
            <see cref="T:System.Linq.Expressions.MemberInitExpression"/>.</remarks>
            <returns>A <see cref="T:System.Linq.Expressions.LambdaExpression"/> acting as an accessor for the <paramref name="searchedExpression"/> when an input matching 
            <paramref name="fullExpression"/> is given.
            </returns>
        </member>
        <member name="T:Remotion.Linq.Clauses.ExpressionVisitors.ReferenceReplacingExpressionVisitor">
            <summary>
            Takes an expression and replaces all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> instances, as defined by a given <see cref="T:Remotion.Linq.Clauses.QuerySourceMapping"/>.
            This is used whenever references to query sources should be replaced by a transformation.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.ExpressionVisitors.ReferenceReplacingExpressionVisitor.ReplaceClauseReferences(System.Linq.Expressions.Expression,Remotion.Linq.Clauses.QuerySourceMapping,System.Boolean)">
            <summary>
            Takes an expression and replaces all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> instances, as defined by a given 
            <paramref name="querySourceMapping"/>.
            </summary>
            <param name="expression">The expression to be scanned for references.</param>
            <param name="querySourceMapping">The clause mapping to be used for replacing <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> instances.</param>
            <param name="throwOnUnmappedReferences">If <see langword="true"/>, the visitor will throw an exception when 
            <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> not mapped in the <paramref name="querySourceMapping"/> is encountered. If <see langword="false"/>,
            the visitor will ignore such expressions.</param>
            <returns>An expression with its <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> instances replaced as defined by the 
            <paramref name="querySourceMapping"/>.</returns>
        </member>
        <member name="T:Remotion.Linq.Clauses.ExpressionVisitors.ReverseResolvingExpressionVisitor">
            <summary>
            Performs a reverse <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> operation, i.e. creates a <see cref="T:System.Linq.Expressions.LambdaExpression"/> from a given resolved expression, 
            substituting all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> objects by getting the referenced objects from the lambda's input parameter.
            </summary>
            <example>
            Given the following input:
            <list type="bullet">
            <item>ItemExpression: <c>new AnonymousType ( a = [s1], b = [s2] )</c></item>
            <item>ResolvedExpression: <c>[s1].ID + [s2].ID</c></item>
            </list> 
            The visitor generates the following <see cref="T:System.Linq.Expressions.LambdaExpression"/>: <c>input =&gt; input.a.ID + input.b.ID</c>
            The lambda's input parameter has the same type as the ItemExpression.
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ExpressionVisitors.ReverseResolvingExpressionVisitor.ReverseResolve(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
            <summary>
            Performs a reverse <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> operation, i.e. creates a <see cref="T:System.Linq.Expressions.LambdaExpression"/> from a given resolved expression, 
            substituting all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> objects by getting the referenced objects from the lambda's input parameter.
            </summary>
            <param name="itemExpression">The item expression representing the items passed to the generated <see cref="T:System.Linq.Expressions.LambdaExpression"/> via its input 
            parameter.</param>
            <param name="resolvedExpression">The resolved expression for which to generate a reverse resolved <see cref="T:System.Linq.Expressions.LambdaExpression"/>.</param>
            <returns>A <see cref="T:System.Linq.Expressions.LambdaExpression"/> from the given resolved expression, substituting all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> 
            objects by getting the referenced objects from the lambda's input parameter. The generated <see cref="T:System.Linq.Expressions.LambdaExpression"/> has exactly one 
            parameter which is of the type defined by <paramref name="itemExpression"/>.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.ExpressionVisitors.ReverseResolvingExpressionVisitor.ReverseResolveLambda(System.Linq.Expressions.Expression,System.Linq.Expressions.LambdaExpression,System.Int32)">
            <summary>
            Performs a reverse <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> operation on a <see cref="T:System.Linq.Expressions.LambdaExpression"/>, i.e. creates a new 
            <see cref="T:System.Linq.Expressions.LambdaExpression"/> with an additional parameter from a given resolved <see cref="T:System.Linq.Expressions.LambdaExpression"/>, 
            substituting all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> objects by getting the referenced objects from the new input parameter.
            </summary>
            <param name="itemExpression">The item expression representing the items passed to the generated <see cref="T:System.Linq.Expressions.LambdaExpression"/> via its new
            input parameter.</param>
            <param name="resolvedExpression">The resolved <see cref="T:System.Linq.Expressions.LambdaExpression"/> for which to generate a reverse resolved <see cref="T:System.Linq.Expressions.LambdaExpression"/>.</param>
            <param name="parameterInsertionPosition">The position at which to insert the new parameter.</param>
            <returns>A <see cref="T:System.Linq.Expressions.LambdaExpression"/> similar to the given resolved expression, substituting all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> 
            objects by getting the referenced objects from an additional input parameter. The new input parameter is of the type defined by 
            <paramref name="itemExpression"/>.</returns>
        </member>
        <member name="T:Remotion.Linq.Clauses.GroupJoinClause">
            <summary>
            Represents the join part of a query, adding new data items and joining them with data items from previous clauses. In contrast to 
            <see cref="T:Remotion.Linq.Clauses.JoinClause"/>, the <see cref="T:Remotion.Linq.Clauses.GroupJoinClause"/> does not provide access to the individual items of the joined query source.
            Instead, it provides access to all joined items for each item coming from the previous clauses, thus grouping them together. The semantics
            of this join is so that for all input items, a joined sequence is returned. That sequence can be empty if no joined items are available.
            </summary>
            <example>
            In C#, the "into" clause in the following sample corresponds to a <see cref="T:Remotion.Linq.Clauses.GroupJoinClause"/>. The "join" part before that is encapsulated
            as a <see cref="T:Remotion.Linq.Clauses.JoinClause"/> held in <see cref="P:Remotion.Linq.Clauses.GroupJoinClause.JoinClause"/>. The <see cref="P:Remotion.Linq.Clauses.GroupJoinClause.JoinClause"/> adds a new query source to the query 
            ("addresses"), but the item type of that query source is <see cref="T:System.Collections.Generic.IEnumerable`1"/>, not "Address". Therefore, it can be
            used in the <see cref="P:Remotion.Linq.Clauses.FromClauseBase.FromExpression"/> of an <see cref="T:Remotion.Linq.Clauses.AdditionalFromClause"/> to extract the single items.
            <code>
            var query = from s in Students
                        join a in Addresses on s.AdressID equals a.ID into addresses
                        from a in addresses
                        select new { s, a };
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.GroupJoinClause.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this clause and its child objects via the given <paramref name="transformation"/> delegate.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression"/> within this
            clause, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.GroupJoinClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,System.Int32)">
            <summary>
            Accepts the specified visitor by calling its <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitGroupJoinClause(Remotion.Linq.Clauses.GroupJoinClause,Remotion.Linq.QueryModel,System.Int32)"/> method.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
            <param name="index">The index of this clause in the <paramref name="queryModel"/>'s <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> collection.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.GroupJoinClause.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this clause, registering its clone with the <paramref name="cloneContext"/>.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns>A clone of this clause.</returns>
        </member>
        <member name="P:Remotion.Linq.Clauses.GroupJoinClause.ItemName">
            <summary>
            Gets or sets a name describing the items generated by this <see cref="T:Remotion.Linq.Clauses.GroupJoinClause"/>.
            </summary>
            <remarks>
            Item names are inferred when a query expression is parsed, and they usually correspond to the variable names present in that expression. 
            However, note that names are not necessarily unique within a <see cref="T:Remotion.Linq.QueryModel"/>. Use names only for readability and debugging, not for 
            uniquely identifying <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> objects. To match an <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> with its references, use the 
            <see cref="P:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource"/> property rather than the <see cref="P:Remotion.Linq.Clauses.GroupJoinClause.ItemName"/>.
            </remarks>
        </member>
        <member name="P:Remotion.Linq.Clauses.GroupJoinClause.ItemType">
            <summary>
            Gets or sets the type of the items generated by this <see cref="T:Remotion.Linq.Clauses.GroupJoinClause"/>. This must implement <see cref="T:System.Collections.Generic.IEnumerable`1"/>.
            </summary>
            <note type="warning">
            Changing the <see cref="P:Remotion.Linq.Clauses.GroupJoinClause.ItemType"/> of a <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> can make all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> objects that
            point to that <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> invalid, so the property setter should be used with care.
            </note>
        </member>
        <member name="P:Remotion.Linq.Clauses.GroupJoinClause.JoinClause">
            <summary>
            Gets or sets the inner join clause of this <see cref="T:Remotion.Linq.Clauses.GroupJoinClause"/>. The <see cref="P:Remotion.Linq.Clauses.GroupJoinClause.JoinClause"/> represents the actual join operation
            performed by this clause; its results are then grouped by this clause before streaming them to subsequent clauses. 
            <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> objects outside the <see cref="T:Remotion.Linq.Clauses.GroupJoinClause"/> must not point to <see cref="P:Remotion.Linq.Clauses.GroupJoinClause.JoinClause"/> 
            because the items generated by it are only available in grouped form from outside this clause.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.JoinClause">
            <summary>
            Represents the join part of a query, adding new data items and joining them with data items from previous clauses. This can either
            be part of <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> or of <see cref="T:Remotion.Linq.Clauses.GroupJoinClause"/>. The semantics of the <see cref="T:Remotion.Linq.Clauses.JoinClause"/>
            is that of an inner join, i.e. only combinations where both an input item and a joined item exist are returned.
            </summary>
            <example>
            In C#, the "join" clause in the following sample corresponds to a <see cref="T:Remotion.Linq.Clauses.JoinClause"/>. The <see cref="T:Remotion.Linq.Clauses.JoinClause"/> adds a new
            query source to the query, selecting addresses (called "a") from the source "Addresses". It associates addresses and students by
            comparing the students' "AddressID" properties with the addresses' "ID" properties. "a" corresponds to <see cref="P:Remotion.Linq.Clauses.JoinClause.ItemName"/> and 
            <see cref="P:Remotion.Linq.Clauses.JoinClause.ItemType"/>, "Addresses" is <see cref="P:Remotion.Linq.Clauses.JoinClause.InnerSequence"/> and the left and right side of the "equals" operator are held by
            <see cref="P:Remotion.Linq.Clauses.JoinClause.OuterKeySelector"/> and <see cref="P:Remotion.Linq.Clauses.JoinClause.InnerKeySelector"/>, respectively:
            <code>
            var query = from s in Students
                        join a in Addresses on s.AdressID equals a.ID
                        select new { s, a };
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.JoinClause.#ctor(System.String,System.Type,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.JoinClause"/> class.
            </summary>
            <param name="itemName">A name describing the items generated by this <see cref="T:Remotion.Linq.Clauses.JoinClause"/>.</param>
            <param name="itemType">The type of the items generated by this <see cref="T:Remotion.Linq.Clauses.JoinClause"/>.</param>
            <param name="innerSequence">The expression that generates the inner sequence, i.e. the items of this <see cref="T:Remotion.Linq.Clauses.JoinClause"/>.</param>
            <param name="outerKeySelector">An expression that selects the left side of the comparison by which source items and inner items are joined.</param>
            <param name="innerKeySelector">An expression that selects the right side of the comparison by which source items and inner items are joined.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.JoinClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,System.Int32)">
            <summary>
            Accepts the specified visitor by calling its <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitJoinClause(Remotion.Linq.Clauses.JoinClause,Remotion.Linq.QueryModel,System.Int32)"/> 
            method.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
            <param name="index">The index of this clause in the <paramref name="queryModel"/>'s <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> collection.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.JoinClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,Remotion.Linq.Clauses.GroupJoinClause)">
            <summary>
            Accepts the specified visitor by calling its <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitJoinClause(Remotion.Linq.Clauses.JoinClause,Remotion.Linq.QueryModel,Remotion.Linq.Clauses.GroupJoinClause)"/> 
            method. This overload is used when visiting a <see cref="T:Remotion.Linq.Clauses.JoinClause"/> that is held by a <see cref="T:Remotion.Linq.Clauses.GroupJoinClause"/>.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
            <param name="groupJoinClause">The <see cref="T:Remotion.Linq.Clauses.GroupJoinClause"/> holding this <see cref="T:Remotion.Linq.Clauses.JoinClause"/> instance.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.JoinClause.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this clause, registering its clone with the <paramref name="cloneContext"/>.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns>A clone of this clause.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.JoinClause.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this clause and its child objects via the given <paramref name="transformation"/> delegate.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression"/> within this
            clause, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="P:Remotion.Linq.Clauses.JoinClause.ItemType">
            <summary>
            Gets or sets the type of the items generated by this <see cref="T:Remotion.Linq.Clauses.JoinClause"/>.
            </summary>
            <note type="warning">
            Changing the <see cref="P:Remotion.Linq.Clauses.JoinClause.ItemType"/> of a <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> can make all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> objects that
            point to that <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> invalid, so the property setter should be used with care.
            </note>
        </member>
        <member name="P:Remotion.Linq.Clauses.JoinClause.ItemName">
            <summary>
            Gets or sets a name describing the items generated by this <see cref="T:Remotion.Linq.Clauses.JoinClause"/>.
            </summary>
            <remarks>
            Item names are inferred when a query expression is parsed, and they usually correspond to the variable names present in that expression. 
            However, note that names are not necessarily unique within a <see cref="T:Remotion.Linq.QueryModel"/>. Use names only for readability and debugging, not for 
            uniquely identifying <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> objects. To match an <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> with its references, use the 
            <see cref="P:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource"/> property rather than the <see cref="P:Remotion.Linq.Clauses.JoinClause.ItemName"/>.
            </remarks>
        </member>
        <member name="P:Remotion.Linq.Clauses.JoinClause.InnerSequence">
            <summary>
            Gets or sets the inner sequence, the expression that generates the inner sequence, i.e. the items of this <see cref="T:Remotion.Linq.Clauses.JoinClause"/>.
            </summary>
            <value>The inner sequence.</value>
        </member>
        <member name="P:Remotion.Linq.Clauses.JoinClause.OuterKeySelector">
            <summary>
            Gets or sets the outer key selector, an expression that selects the right side of the comparison by which source items and inner items are joined.
            </summary>
            <value>The outer key selector.</value>
        </member>
        <member name="P:Remotion.Linq.Clauses.JoinClause.InnerKeySelector">
            <summary>
            Gets or sets the inner key selector, an expression that selects the left side of the comparison by which source items and inner items are joined.
            </summary>
            <value>The inner key selector.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.MainFromClause">
            <summary>
            Represents the main data source in a query, producing data items that are filtered, aggregated, projected, or otherwise processed by
            subsequent clauses.
            </summary>
            <example>
            In C#, the first "from" clause in the following sample corresponds to the <see cref="T:Remotion.Linq.Clauses.MainFromClause"/>:
            <ode>
            var query = from s in Students
                        from f in s.Friends
                        select f;
            </ode>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.MainFromClause.#ctor(System.String,System.Type,System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.MainFromClause"/> class.
            </summary>
            <param name="itemName">A name describing the items generated by the from clause.</param>
            <param name="itemType">The type of the items generated by the from clause.</param>
            <param name="fromExpression">The <see cref="T:System.Linq.Expressions.Expression"/> generating data items for this from clause.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.MainFromClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel)">
            <summary>
            Accepts the specified visitor by calling its <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitMainFromClause(Remotion.Linq.Clauses.MainFromClause,Remotion.Linq.QueryModel)"/> method.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.MainFromClause.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this clause, registering its clone with the <paramref name="cloneContext"/>.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns>A clone of this clause.</returns>
        </member>
        <member name="T:Remotion.Linq.Clauses.OrderByClause">
            <summary>
            Represents the orderby part of a query, ordering data items according to some <see cref="P:Remotion.Linq.Clauses.OrderByClause.Orderings"/>.
            </summary>
            <example>
            In C#, the whole "orderby" clause in the following sample (including two orderings) corresponds to an <see cref="T:Remotion.Linq.Clauses.OrderByClause"/>:
            <ode>
            var query = from s in Students
                        orderby s.Last, s.First
                        select s;
            </ode>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.OrderByClause.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.OrderByClause"/> class.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.OrderByClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,System.Int32)">
            <summary>
            Accepts the specified visitor by calling its <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitOrderByClause(Remotion.Linq.Clauses.OrderByClause,Remotion.Linq.QueryModel,System.Int32)"/> method.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
            <param name="index">The index of this clause in the <paramref name="queryModel"/>'s <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> collection.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.OrderByClause.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this clause and its child objects via the given <paramref name="transformation"/> delegate.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression"/> within this
            clause, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.OrderByClause.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this clause.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns>A clone of this clause.</returns>
        </member>
        <member name="P:Remotion.Linq.Clauses.OrderByClause.Orderings">
            <summary>
            Gets the <see cref="T:Remotion.Linq.Clauses.Ordering"/> instances that define how to sort the items coming from previous clauses. The order of the 
            <see cref="P:Remotion.Linq.Clauses.OrderByClause.Orderings"/> in the collection defines their priorities. For example, { LastName, FirstName } would sort all items by
            LastName, and only those items that have equal LastName values would be sorted by FirstName.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.Ordering">
            <summary>
            Represents a single ordering instruction in an <see cref="T:Remotion.Linq.Clauses.OrderByClause"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.Ordering.#ctor(System.Linq.Expressions.Expression,Remotion.Linq.Clauses.OrderingDirection)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.Ordering"/> class.
            </summary>
            <param name="expression">The expression used to order the data items returned by the query.</param>
            <param name="direction">The <see cref="P:Remotion.Linq.Clauses.Ordering.OrderingDirection"/> to use for sorting.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.Ordering.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,Remotion.Linq.Clauses.OrderByClause,System.Int32)">
            <summary>
            Accepts the specified visitor by calling its <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitOrdering(Remotion.Linq.Clauses.Ordering,Remotion.Linq.QueryModel,Remotion.Linq.Clauses.OrderByClause,System.Int32)"/> method.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
            <param name="orderByClause">The <see cref="T:Remotion.Linq.Clauses.OrderByClause"/> in whose context this item is visited.</param>
            <param name="index">The index of this item in the <paramref name="orderByClause"/>'s <see cref="P:Remotion.Linq.Clauses.OrderByClause.Orderings"/> collection.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.Ordering.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this item.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns>A clone of this item.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.Ordering.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this item via the given <paramref name="transformation"/> delegate.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="P:Remotion.Linq.Clauses.Ordering.Expression"/> within this
            item, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="P:Remotion.Linq.Clauses.Ordering.Expression">
            <summary>
            Gets or sets the expression used to order the data items returned by the query.
            </summary>
            <value>The expression.</value>
        </member>
        <member name="P:Remotion.Linq.Clauses.Ordering.OrderingDirection">
            <summary>
            Gets or sets the direction to use for ordering data items.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.OrderingDirection">
            <summary>
            Specifies the direction used to sort the result items in a query using an <see cref="T:Remotion.Linq.Clauses.OrderByClause"/>.
            </summary>
        </member>
        <member name="F:Remotion.Linq.Clauses.OrderingDirection.Asc">
            <summary>
            Sorts the items in an ascending way, from smallest to largest.
            </summary>
        </member>
        <member name="F:Remotion.Linq.Clauses.OrderingDirection.Desc">
            <summary>
            Sorts the items in an descending way, from largest to smallest.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.QuerySourceMapping">
            <summary>
            Maps <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> instances to <see cref="T:System.Linq.Expressions.Expression"/> instances. This is used by <see cref="M:Remotion.Linq.QueryModel.Clone"/>
            in order to be able to correctly update references to old clauses to point to the new clauses. Via 
            <see cref="T:Remotion.Linq.Clauses.ExpressionVisitors.ReferenceReplacingExpressionVisitor"/>, it can also be used manually.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperatorBase">
            <summary>
            Represents an operation that is executed on the result set of the query, aggregating, filtering, or restricting the number of result items
            before the query result is returned.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Linq.Clauses.StreamedData.IStreamedData)">
            <summary>
            Executes this result operator in memory, on a given input. Executing result operators in memory should only be 
            performed if the target query system does not support the operator.
            </summary>
            <param name="input">The input for the result operator. This must match the type of <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedData"/> expected by the operator.</param>
            <returns>The result of the operator.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperatorBase.GetOutputDataInfo(Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo)">
            <summary>
            Gets information about the data streamed out of this <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/>. This contains the result type a query would have if 
            it ended with this <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/>, and it optionally includes an <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.ItemExpression"/> describing
            the streamed sequence's items.
            </summary>
            <param name="inputInfo">Information about the data produced by the preceding <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/>, or the <see cref="T:Remotion.Linq.Clauses.SelectClause"/>
            of the query if no previous <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/> exists.</param>
            <returns>Gets information about the data streamed out of this <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/>.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperatorBase.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this item, registering its clone with the <paramref name="cloneContext"/> if it is a query source clause.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns>A clone of this item.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperatorBase.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,System.Int32)">
            <summary>
            Accepts the specified visitor by calling its <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitResultOperator(Remotion.Linq.Clauses.ResultOperatorBase,Remotion.Linq.QueryModel,System.Int32)"/> method.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
            <param name="index">The index of this item in the <paramref name="queryModel"/>'s <see cref="P:Remotion.Linq.QueryModel.ResultOperators"/> collection.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperatorBase.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this item via the given <paramref name="transformation"/> delegate. Subclasses must apply the 
            <paramref name="transformation"/> to any expressions they hold. If a subclass does not hold any expressions, it shouldn't do anything
            in the implementation of this method.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression"/> within this
            item, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperatorBase.InvokeExecuteMethod(System.Reflection.MethodInfo,System.Object)">
            <summary>
            Invokes the given <paramref name="method"/> via reflection on the given <paramref name="input"/>.
            </summary>
            <param name="input">The input to invoke the method with.</param>
            <param name="method">The method to be invoked.</param>
            <returns>The result of the invocation</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperatorBase.GetConstantValueFromExpression``1(System.String,System.Linq.Expressions.Expression)">
            <summary>
            Gets the constant value of the given expression, assuming it is a <see cref="T:System.Linq.Expressions.ConstantExpression"/>. If it is
            not, an <see cref="T:System.InvalidOperationException"/> is thrown.
            </summary>
            <typeparam name="T">The expected value type. If the value is not of this type, an <see cref="T:System.InvalidOperationException"/> is thrown.</typeparam>
            <param name="expressionName">A string describing the value; this will be included in the exception message if an exception is thrown.</param>
            <param name="expression">The expression whose value to get.</param>
            <returns>
            The constant value of the given <paramref name="expression"/>.
            </returns>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator">
            <summary>
            Represents aggregating the items returned by a query into a single value with an initial seeding value.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Aggregate" call in the following example corresponds to an <see cref="T:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator"/>.
            <code>
            var result = (from s in Students
                         select s).Aggregate(0, (totalAge, s) =&gt; totalAge + s.Age);
            </code>
            </example>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.ValueFromSequenceResultOperatorBase">
            <summary>
            Represents a <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/> that is executed on a sequence, returning a scalar value or single item as its result.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.#ctor(System.Linq.Expressions.Expression,System.Linq.Expressions.LambdaExpression,System.Linq.Expressions.LambdaExpression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator"/> class.
            </summary>
            <param name="seed">The seed expression.</param>
            <param name="func">The aggregating function. This is a <see cref="T:System.Linq.Expressions.LambdaExpression"/> taking a parameter that represents the value accumulated so 
            far and returns a new accumulated value. This is a resolved expression, i.e. items streaming in from prior clauses and result operators
            are represented as expressions containing <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> nodes.</param>
            <param name="optionalResultSelector">The result selector, can be <see langword="null"/>.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.GetConstantSeed``1">
            <summary>
            Gets the constant value of the <see cref="P:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.Seed"/> property, assuming it is a <see cref="T:System.Linq.Expressions.ConstantExpression"/>. If it is
            not, an <see cref="T:System.InvalidOperationException"/> is thrown.
            </summary>
            <typeparam name="T">The expected seed type. If the item is not of this type, an <see cref="T:System.InvalidOperationException"/> is thrown.</typeparam>
            <returns>The constant value of the <see cref="P:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.Seed"/> property.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.ExecuteInMemory``1(Remotion.Linq.Clauses.StreamedData.StreamedSequence)">
            <inheritdoc cref="M:Remotion.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Linq.Clauses.StreamedData.IStreamedData)"/>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.ExecuteAggregateInMemory``3(Remotion.Linq.Clauses.StreamedData.StreamedSequence)">
            <summary>
            Executes the aggregating operation in memory.
            </summary>
            <typeparam name="TInput">The type of the source items.</typeparam>
            <typeparam name="TAggregate">The type of the aggregated items.</typeparam>
            <typeparam name="TResult">The type of the result items.</typeparam>
            <param name="input">The input sequence.</param>
            <returns>A <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedValue"/> object holding the aggregated value.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.Clone(Remotion.Linq.Clauses.CloneContext)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.GetOutputDataInfo(Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.ToString">
            <inheritdoc />
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.Func">
            <summary>
            Gets or sets the aggregating function. This is a <see cref="T:System.Linq.Expressions.LambdaExpression"/> taking a parameter that represents the value accumulated so 
            far and returns a new accumulated value. This is a resolved expression, i.e. items streaming in from prior clauses and result operators
            are represented as expressions containing <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> nodes.
            </summary>
            <value>The aggregating function.</value>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.Seed">
            <summary>
            Gets or sets the seed of the accumulation. This is an <see cref="T:System.Linq.Expressions.Expression"/> denoting the starting value of the aggregation.
            </summary>
            <value>The seed of the accumulation.</value>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.OptionalResultSelector">
            <summary>
            Gets or sets the result selector. This is a <see cref="T:System.Linq.Expressions.LambdaExpression"/> applied after the aggregation to select the final value.
            Can be <see langword="null"/>.
            </summary>
            <value>The result selector.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.AggregateResultOperator">
            <summary>
            Represents aggregating the items returned by a query into a single value. The first item is used as the seeding value for the aggregating 
            function.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Aggregate" call in the following example corresponds to an <see cref="T:Remotion.Linq.Clauses.ResultOperators.AggregateResultOperator"/>.
            <code>
            var result = (from s in Students
                         select s.Name).Aggregate((allNames, name) =&gt; allNames + " " + name);
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateResultOperator.#ctor(System.Linq.Expressions.LambdaExpression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.AggregateResultOperator"/> class.
            </summary>
            <param name="func">The aggregating function. This is a <see cref="T:System.Linq.Expressions.LambdaExpression"/> taking a parameter that represents the value accumulated so 
            far and returns a new accumulated value. This is a resolved expression, i.e. items streaming in from prior clauses and result operators
            are represented as expressions containing <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> nodes.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateResultOperator.ExecuteInMemory``1(Remotion.Linq.Clauses.StreamedData.StreamedSequence)">
            <inheritdoc cref="M:Remotion.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Linq.Clauses.StreamedData.IStreamedData)"/>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateResultOperator.Clone(Remotion.Linq.Clauses.CloneContext)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateResultOperator.GetOutputDataInfo(Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AggregateResultOperator.ToString">
            <inheritdoc />
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.AggregateResultOperator.Func">
            <summary>
            Gets or sets the aggregating function. This is a <see cref="T:System.Linq.Expressions.LambdaExpression"/> taking a parameter that represents the value accumulated so 
            far and returns a new accumulated value. This is a resolved expression, i.e. items streaming in from prior clauses and result operators
            are represented as expressions containing <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> nodes.
            </summary>
            <value>The aggregating function.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.AllResultOperator">
            <summary>
            Represents a check whether all items returned by a query satisfy a predicate.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "All" call in the following example corresponds to an <see cref="T:Remotion.Linq.Clauses.ResultOperators.AllResultOperator"/>.
            <code>
            var result = (from s in Students
                         select s).All();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AllResultOperator.#ctor(System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.AllResultOperator"/> class.
            </summary>
            <param name="predicate">The predicate to evaluate. This is a resolved version of the body of the <see cref="T:System.Linq.Expressions.LambdaExpression"/> that would be 
            passed to <see cref="M:System.Linq.Queryable.All``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AllResultOperator.ExecuteInMemory``1(Remotion.Linq.Clauses.StreamedData.StreamedSequence)">
            <inheritdoc cref="M:Remotion.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Linq.Clauses.StreamedData.IStreamedData)"/>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AllResultOperator.Clone(Remotion.Linq.Clauses.CloneContext)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AllResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AllResultOperator.GetOutputDataInfo(Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AllResultOperator.ToString">
            <inheritdoc />
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.AllResultOperator.Predicate">
            <summary>
            Gets or sets the predicate to evaluate on all items in the sequence.
            This is a resolved version of the body of the <see cref="T:System.Linq.Expressions.LambdaExpression"/> that would be 
            passed to <see cref="M:System.Linq.Queryable.All``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>.
            </summary>
            <value>The predicate.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.AnyResultOperator">
            <summary>
            Represents a check whether any items are returned by a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <remarks>
            "Any" query methods taking a predicate are represented as into a combination of a <see cref="T:Remotion.Linq.Clauses.WhereClause"/> and an 
            <see cref="T:Remotion.Linq.Clauses.ResultOperators.AnyResultOperator"/>.
            </remarks>
            <example>
            In C#, the "Any" call in the following example corresponds to an <see cref="T:Remotion.Linq.Clauses.ResultOperators.AnyResultOperator"/>.
            <code>
            var result = (from s in Students
                         select s).Any();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AnyResultOperator.ExecuteInMemory``1(Remotion.Linq.Clauses.StreamedData.StreamedSequence)">
            <inheritdoc cref="M:Remotion.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Linq.Clauses.StreamedData.IStreamedData)"/>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AnyResultOperator.Clone(Remotion.Linq.Clauses.CloneContext)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AnyResultOperator.GetOutputDataInfo(Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AnyResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AnyResultOperator.ToString">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.AsQueryableResultOperator">
            <summary>
            Represents the transformation of a sequence to a query data source. 
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "AsQueryable" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.AsQueryableResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).AsQueryable();
            </code>
            </example>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.SequenceTypePreservingResultOperatorBase">
            <summary>
            Represents a <see cref="T:Remotion.Linq.Clauses.ResultOperators.SequenceFromSequenceResultOperatorBase"/> that is executed on a sequence, returning a new sequence with the same
            item type as its result.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.SequenceFromSequenceResultOperatorBase">
            <summary>
            Represents a <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/> that is executed on a sequence, returning a new sequence as its result.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AsQueryableResultOperator.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.AsQueryableResultOperator"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.AsQueryableResultOperator.ISupportedByIQueryModelVistor">
            <summary>
            A marker interface that must be implemented by the <see cref="T:Remotion.Linq.IQueryModelVisitor"/> if the visitor supports the <see cref="T:Remotion.Linq.Clauses.ResultOperators.AsQueryableResultOperator"/>.
            </summary>
            <remarks>
            Note that the interface will become obsolete with v3.0.0. See also RMLNQ-117.
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.AverageResultOperator">
            <summary>
            Represents a calculation of an average value from the items returned by a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Average" call in the following example corresponds to an <see cref="T:Remotion.Linq.Clauses.ResultOperators.AverageResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s.ID).Average();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.AverageResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.CastResultOperator">
            <summary>
            Represents a cast of the items returned by a query to a different type.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, "Cast" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.CastResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s.ID).Cast&lt;int&gt;();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.CastResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.ChoiceResultOperatorBase">
            <summary>
            Represents a <see cref="T:Remotion.Linq.Clauses.ResultOperators.ValueFromSequenceResultOperatorBase"/> that is executed on a sequence, choosing a single item for its result.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.ConcatResultOperator">
            <summary>
            Represents concatenating the items returned by a query with a given set of items, similar to the <see cref="T:Remotion.Linq.Clauses.ResultOperators.UnionResultOperator"/> but
            retaining duplicates (and order). 
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Concat" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.ConcatResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Concat(students2);
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.ConcatResultOperator.GetConstantSource2">
            <summary>
            Gets the value of <see cref="P:Remotion.Linq.Clauses.ResultOperators.ConcatResultOperator.Source2"/>, assuming <see cref="P:Remotion.Linq.Clauses.ResultOperators.ConcatResultOperator.Source2"/> holds a <see cref="T:System.Linq.Expressions.ConstantExpression"/>. If it doesn't,
            an <see cref="T:System.InvalidOperationException"/> is thrown.
            </summary>
            <returns>The constant value of <see cref="P:Remotion.Linq.Clauses.ResultOperators.ConcatResultOperator.Source2"/>.</returns>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.ConcatResultOperator.Source2">
            <summary>
            Gets or sets the second source of this result operator, that is, an enumerable containing the items concatenated with the input sequence.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.ContainsResultOperator">
            <summary>
            Represents a check whether the results returned by a query contain a specific item.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Contains" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.ContainsResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Contains (student);
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.ContainsResultOperator.#ctor(System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.ContainsResultOperator"/> class.
            </summary>
            <param name="item">The item for which to be searched.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.ContainsResultOperator.GetConstantItem``1">
            <summary>
            Gets the constant value of the <see cref="P:Remotion.Linq.Clauses.ResultOperators.ContainsResultOperator.Item"/> property, assuming it is a <see cref="T:System.Linq.Expressions.ConstantExpression"/>. If it is
            not, an <see cref="T:System.InvalidOperationException"/> is thrown.
            </summary>
            <typeparam name="T">The expected item type. If the item is not of this type, an <see cref="T:System.InvalidOperationException"/> is thrown.</typeparam>
            <returns>The constant value of the <see cref="P:Remotion.Linq.Clauses.ResultOperators.ContainsResultOperator.Item"/> property.</returns>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.ContainsResultOperator.Item">
            <summary>
            Gets or sets an expression yielding the item for which to be searched. This must be compatible with (ie., assignable to) the source sequence 
            items.
            </summary>
            <value>The item expression.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.CountResultOperator">
            <summary>
            Represents counting the number of items returned by a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <remarks>
            "Count" query methods taking a predicate are represented as a combination of a <see cref="T:Remotion.Linq.Clauses.WhereClause"/> and a <see cref="T:Remotion.Linq.Clauses.ResultOperators.CountResultOperator"/>.
            </remarks>  /// <example>
            In C#, the "Count" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.CountResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Count();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.CountResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.DefaultIfEmptyResultOperator">
            <summary>
            Represents a guard clause yielding a singleton sequence with a default value if no items are returned by a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Defaultifempty" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.DefaultIfEmptyResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).DefaultIfEmpty ("student");
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.DefaultIfEmptyResultOperator.GetConstantOptionalDefaultValue">
            <summary>
            Gets the constant <see cref="T:System.Object"/> value of the <see cref="P:Remotion.Linq.Clauses.ResultOperators.DefaultIfEmptyResultOperator.OptionalDefaultValue"/> property, assuming it is a <see cref="T:System.Linq.Expressions.ConstantExpression"/>. If it is
            not, an <see cref="T:System.InvalidOperationException"/> is thrown. If it is <see langword="null"/>, <see langword="null"/> is returned.
            </summary>
            <returns>The constant <see cref="T:System.Object"/> value of the <see cref="P:Remotion.Linq.Clauses.ResultOperators.DefaultIfEmptyResultOperator.OptionalDefaultValue"/> property.</returns>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.DefaultIfEmptyResultOperator.OptionalDefaultValue">
            <summary>
            Gets or sets the optional default value.
            </summary>
            <value>The optional default value.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.DistinctResultOperator">
            <summary>
            Represents the removal of duplicate values from the items returned by a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Distinct" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.DistinctResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Distinct();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.DistinctResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.ExceptResultOperator">
            <summary>
            Represents the removal of a given set of items from the result set of a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Except" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.ExceptResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Except(students2);
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.ExceptResultOperator.GetConstantSource2``1">
            <summary>
            Gets the value of <see cref="P:Remotion.Linq.Clauses.ResultOperators.ExceptResultOperator.Source2"/>, assuming <see cref="P:Remotion.Linq.Clauses.ResultOperators.ExceptResultOperator.Source2"/> holds a <see cref="T:System.Linq.Expressions.ConstantExpression"/>. If it doesn't,
            an <see cref="T:System.InvalidOperationException"/> is thrown.
            </summary>
            <returns>The constant value of <see cref="P:Remotion.Linq.Clauses.ResultOperators.ExceptResultOperator.Source2"/>.</returns>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.ExceptResultOperator.Source2">
            <summary>
            Gets or sets the second source of this result operator, that is, an enumerable containing the items removed from the input sequence.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.FirstResultOperator">
            <summary>
            Represents taking only the first of the items returned by a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <remarks>
            "First" query methods taking a predicate are represented as a combination of a <see cref="T:Remotion.Linq.Clauses.WhereClause"/> and a <see cref="T:Remotion.Linq.Clauses.ResultOperators.FirstResultOperator"/>.
            </remarks>
            <example>
            In C#, the "First" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.FirstResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).First();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.FirstResultOperator.#ctor(System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.DistinctResultOperator"/>.
            </summary>
            <param name="returnDefaultWhenEmpty">The flag defines if a default expression should be regarded.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.FirstResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator">
            <summary>
            Represents grouping the items returned by a query according to some key retrieved by a <see cref="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.KeySelector"/>, applying by an 
            <see cref="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.ElementSelector"/> to the grouped items. This is a result operator, operating on the whole result set of the query.
            </summary>
            <example>
            In C#, the "group by" clause in the following sample corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator"/>. "s" (a reference to the query source 
            "s", see <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/>) is the <see cref="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.ElementSelector"/> expression, "s.Country" is the 
            <see cref="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.KeySelector"/> expression:
            <code>
            var query = from s in Students
                        where s.First == "Hugo"
                        group s by s.Country;
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.#ctor(System.String,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator"/> class.
            </summary>
            <param name="itemName">A name associated with the <see cref="T:System.Linq.IGrouping`2"/> items generated by the result operator.</param>
            <param name="keySelector">The selector retrieving the key by which to group items.</param>
            <param name="elementSelector">The selector retrieving the elements to group.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this clause, adjusting all <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> instances held by it as defined by
            <paramref name="cloneContext"/>.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns>A clone of this clause.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this clause and its child objects via the given <paramref name="transformation"/> delegate.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression"/> within this
            clause, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.ItemName">
            <summary>
            Gets or sets the name of the items generated by this <see cref="T:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator"/>.
            </summary>
            <remarks>
            Item names are inferred when a query expression is parsed, and they usually correspond to the variable names present in that expression. 
            However, note that names are not necessarily unique within a <see cref="T:Remotion.Linq.QueryModel"/>. Use names only for readability and debugging, not for 
            uniquely identifying <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> objects. To match an <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> with its references, use the 
            <see cref="P:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource"/> property rather than the <see cref="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.ItemName"/>.
            </remarks>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.ItemType">
            <summary>
            Gets or sets the type of the items generated by this <see cref="T:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator"/>. The item type is an instantiation of 
            <see cref="T:System.Linq.IGrouping`2"/> derived from the types of <see cref="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.KeySelector"/> and <see cref="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.ElementSelector"/>.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.KeySelector">
            <summary>
            Gets or sets the selector retrieving the key by which to group items.
            This is a resolved version of the body of the <see cref="T:System.Linq.Expressions.LambdaExpression"/> that would be 
            passed to <see cref="M:System.Linq.Queryable.GroupBy``3(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.Linq.Expressions.Expression{System.Func{``0,``2}})"/>.
            </summary>
            <value>The key selector.</value>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.GroupResultOperator.ElementSelector">
            <summary>
            Gets or sets the selector retrieving the elements to group.
            This is a resolved version of the body of the <see cref="T:System.Linq.Expressions.LambdaExpression"/> that would be 
            passed to <see cref="M:System.Linq.Queryable.GroupBy``3(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.Linq.Expressions.Expression{System.Func{``0,``2}})"/>.
            </summary>
            <value>The element selector.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.IntersectResultOperator">
            <summary>
            Represents taking the mathematical intersection of a given set of items and the items returned by a query. 
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Intersect" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.IntersectResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Intersect(students2);
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.IntersectResultOperator.GetConstantSource2``1">
            <summary>
            Gets the value of <see cref="P:Remotion.Linq.Clauses.ResultOperators.IntersectResultOperator.Source2"/>, assuming <see cref="P:Remotion.Linq.Clauses.ResultOperators.IntersectResultOperator.Source2"/> holds a <see cref="T:System.Linq.Expressions.ConstantExpression"/>. If it doesn't,
            an <see cref="T:System.InvalidOperationException"/> is thrown.
            </summary>
            <returns>The constant value of <see cref="P:Remotion.Linq.Clauses.ResultOperators.IntersectResultOperator.Source2"/>.</returns>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.IntersectResultOperator.Source2">
            <summary>
            Gets or sets the second source of this result operator, that is, an enumerable containing the items intersected with the input sequence.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.LastResultOperator">
            <summary>
            Represents taking only the last one of the items returned by a query. 
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <remarks>
            "Last" query methods taking a predicate are represented as a combination of a <see cref="T:Remotion.Linq.Clauses.WhereClause"/> and a <see cref="T:Remotion.Linq.Clauses.ResultOperators.LastResultOperator"/>.
            </remarks>
            <example>
            In C#, the "Last" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.LastResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Last();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.LastResultOperator.#ctor(System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.LastResultOperator"/>.
            </summary>
            <param name="returnDefaultWhenEmpty">The flag defines if a default expression should be regarded.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.LastResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.LongCountResultOperator">
            <summary>
            Represents counting the number of items returned by a query as a 64-bit number.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <remarks>
            "LongCount" query methods taking a predicate are represented as a combination of a <see cref="T:Remotion.Linq.Clauses.WhereClause"/> and a 
            <see cref="T:Remotion.Linq.Clauses.ResultOperators.LongCountResultOperator"/>.
            </remarks>
            <example>
            In C#, the "LongCount" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.LongCountResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).LongCount();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.LongCountResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.MaxResultOperator">
            <summary>
            Represents taking only the greatest one of the items returned by a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <remarks>
            The semantics of "greatest" are defined by the query provider. "Max" query methods taking a selector are represented as a combination
            of a <see cref="T:Remotion.Linq.Clauses.SelectClause"/> and a <see cref="T:Remotion.Linq.Clauses.ResultOperators.MaxResultOperator"/>.
            </remarks>
            <example>
            In C#, the "Max" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.MaxResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s.ID).Max();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.MaxResultOperator.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.MaxResultOperator"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.MaxResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.MinResultOperator">
            <summary>
            Represents taking only the smallest one of the items returned by a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <remarks>
            The semantics of "smallest" are defined by the query provider. "Min" query methods taking a selector are represented as a combination
            of a <see cref="T:Remotion.Linq.Clauses.SelectClause"/> and a <see cref="T:Remotion.Linq.Clauses.ResultOperators.MinResultOperator"/>.
            </remarks>
            <example>
            In C#, the "Min" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.MinResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s.ID).Min();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.MinResultOperator.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.MinResultOperator"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.MinResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.OfTypeResultOperator">
            <summary>
            Represents filtering the items returned by a query to only return those items that are of a specific type. 
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "OfType" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.OfTypeResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s.ID).OfType&lt;int&gt;();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.OfTypeResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.ReverseResultOperator">
            <summary>
            Represents reversing the sequence of items returned by of a query. 
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Reverse" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.ReverseResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Reverse();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.ReverseResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.SingleResultOperator">
            <summary>
            Represents taking the single item returned by a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Single" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.SingleResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Single();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.SingleResultOperator.#ctor(System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.SingleResultOperator"/>.
            </summary>
            <param name="returnDefaultWhenEmpty">The flag defines if a default expression should be regarded.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.SingleResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.SkipResultOperator">
            <summary>
            Represents skipping a number of the items returned by a query.
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Skip" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.SkipResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Skip (3);
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.SkipResultOperator.GetConstantCount">
            <summary>
            Gets the constant <see cref="T:System.Int32"/> value of the <see cref="P:Remotion.Linq.Clauses.ResultOperators.SkipResultOperator.Count"/> property, assuming it is a <see cref="T:System.Linq.Expressions.ConstantExpression"/>. If it is
            not, an <see cref="T:System.InvalidOperationException"/> is thrown.
            </summary>
            <returns>The constant <see cref="T:System.Int32"/> value of the <see cref="P:Remotion.Linq.Clauses.ResultOperators.SkipResultOperator.Count"/> property.</returns>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.SumResultOperator">
            <summary>
            Represents calculating the sum of the items returned by a query. 
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Sum" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.SumResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s.ID).Sum();
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.SumResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <inheritdoc />
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.TakeResultOperator">
            <summary>
            Represents taking only a specific number of items returned by a query. 
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Take" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.TakeResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Take(3);
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.TakeResultOperator.#ctor(System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.ResultOperators.TakeResultOperator"/>.
            </summary>
            <param name="count">The number of elements which should be returned.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.TakeResultOperator.GetConstantCount">
            <summary>
            Gets the constant <see cref="T:System.Int32"/> value of the <see cref="P:Remotion.Linq.Clauses.ResultOperators.TakeResultOperator.Count"/> property, assuming it is a <see cref="T:System.Linq.Expressions.ConstantExpression"/>. If it is
            not, an <see cref="T:System.InvalidOperationException"/> is thrown.
            </summary>
            <returns>The constant <see cref="T:System.Int32"/> value of the <see cref="P:Remotion.Linq.Clauses.ResultOperators.TakeResultOperator.Count"/> property.</returns>
        </member>
        <member name="T:Remotion.Linq.Clauses.ResultOperators.UnionResultOperator">
            <summary>
            Represents forming the mathematical union of  a given set of items and the items returned by a query. 
            This is a result operator, operating on the whole result set of a query.
            </summary>
            <example>
            In C#, the "Union" call in the following example corresponds to a <see cref="T:Remotion.Linq.Clauses.ResultOperators.UnionResultOperator"/>.
            <code>
            var query = (from s in Students
                         select s).Union(students2);
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.ResultOperators.UnionResultOperator.GetConstantSource2">
            <summary>
            Gets the value of <see cref="P:Remotion.Linq.Clauses.ResultOperators.UnionResultOperator.Source2"/>, assuming <see cref="P:Remotion.Linq.Clauses.ResultOperators.UnionResultOperator.Source2"/> holds a <see cref="T:System.Linq.Expressions.ConstantExpression"/>. If it doesn't,
            an <see cref="T:System.InvalidOperationException"/> is thrown.
            </summary>
            <returns>The constant value of <see cref="P:Remotion.Linq.Clauses.ResultOperators.UnionResultOperator.Source2"/>.</returns>
        </member>
        <member name="P:Remotion.Linq.Clauses.ResultOperators.UnionResultOperator.Source2">
            <summary>
            Gets or sets the second source of this result operator, that is, an enumerable containing the items united with the input sequence.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.SelectClause">
            <summary>
            Represents the select part of a query, projecting data items according to some <see cref="P:Remotion.Linq.Clauses.SelectClause.Selector"/>.
            </summary>
            <example>
            In C#, the "select" clause in the following sample corresponds to a <see cref="T:Remotion.Linq.Clauses.SelectClause"/>. "s" (a reference to the query source "s", see
            <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/>) is the <see cref="P:Remotion.Linq.Clauses.SelectClause.Selector"/> expression:
            <code>
            var query = from s in Students
                        where s.First == "Hugo"
                        select s;
            </code>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.SelectClause.#ctor(System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.SelectClause"/> class.
            </summary>
            <param name="selector">The selector that projects the data items.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.SelectClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel)">
            <summary>
            Accepts the specified visitor by calling its <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitSelectClause(Remotion.Linq.Clauses.SelectClause,Remotion.Linq.QueryModel)"/> method.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.SelectClause.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this clause.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns>A clone of this clause.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.SelectClause.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this clause and its child objects via the given <paramref name="transformation"/> delegate.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression"/> within this
            clause, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.SelectClause.GetOutputDataInfo">
            <summary>
            Gets an <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo"/> object describing the data streaming out of this <see cref="T:Remotion.Linq.Clauses.SelectClause"/>. If a query ends with
            the <see cref="T:Remotion.Linq.Clauses.SelectClause"/>, this corresponds to the query's output data. If a query has <see cref="P:Remotion.Linq.QueryModel.ResultOperators"/>, the data
            is further modified by those operators. Use <see cref="M:Remotion.Linq.QueryModel.GetOutputDataInfo"/> to obtain the real result type of
            a query model, including the <see cref="P:Remotion.Linq.QueryModel.ResultOperators"/>.
            </summary>
            <returns>Gets a <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo"/> object describing the data streaming out of this <see cref="T:Remotion.Linq.Clauses.SelectClause"/>.</returns>
            <remarks>
            The data streamed from a <see cref="T:Remotion.Linq.Clauses.SelectClause"/> is always of type <see cref="T:System.Linq.IQueryable`1"/> instantiated
            with the type of <see cref="P:Remotion.Linq.Clauses.SelectClause.Selector"/> as its generic parameter. Its <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.ItemExpression"/> corresponds to the
            <see cref="P:Remotion.Linq.Clauses.SelectClause.Selector"/>.
            </remarks>
        </member>
        <member name="P:Remotion.Linq.Clauses.SelectClause.Selector">
            <summary>
            Gets the selector defining what parts of the data items are returned by the query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.StreamedData.IStreamedData">
            <summary>
            Holds the data needed to represent the output or input of a part of a query in memory. This is mainly used for 
            <see cref="M:Remotion.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Linq.Clauses.StreamedData.IStreamedData)"/>. The data held by implementations of this interface can be either a value or a sequence.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Clauses.StreamedData.IStreamedData.DataInfo">
            <summary>
            Gets an object describing the data held by this <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedData"/> instance.
            </summary>
            <value>An <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/> object describing the data held by this <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedData"/> instance.</value>
        </member>
        <member name="P:Remotion.Linq.Clauses.StreamedData.IStreamedData.Value">
            <summary>
            Gets the value held by this <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedData"/> instance.
            </summary>
            <value>The value.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo">
            <summary>
            Describes the data streamed out of a <see cref="T:Remotion.Linq.QueryModel"/> or <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo.ExecuteQueryModel(Remotion.Linq.QueryModel,Remotion.Linq.IQueryExecutor)">
            <summary>
            Executes the specified <see cref="T:Remotion.Linq.QueryModel"/> with the given <see cref="T:Remotion.Linq.IQueryExecutor"/>, calling either 
            <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteScalar``1(Remotion.Linq.QueryModel)"/> or <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteCollection``1(Remotion.Linq.QueryModel)"/>, depending on the type of data streamed
            from this interface.
            </summary>
            <param name="queryModel">The query model to be executed.</param>
            <param name="executor">The executor to use.</param>
            <returns>An <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedData"/> object holding the results of the query execution.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo.AdjustDataType(System.Type)">
            <summary>
            Returns a new <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/> of the same type as this instance, but with a new <see cref="P:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo.DataType"/>.
            </summary>
            <param name="dataType">The type to use for the <see cref="P:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo.DataType"/> property. The type must be compatible with the data described by this 
            <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/>, otherwise an exception is thrown.
            The type may be a generic type definition if the <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/> supports generic types; in this case,
            the type definition is automatically closed with generic parameters to match the data described by this <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/>.</param>
            <returns>A new <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/> of the same type as this instance, but with a new <see cref="P:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo.DataType"/>.</returns>
            <exception cref="T:System.ArgumentException">The <paramref name="dataType"/> is not compatible with the data described by this 
            <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/>.</exception>
        </member>
        <member name="P:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo.DataType">
            <summary>
            Gets the type of the data described by this <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/> instance. For a sequence, this is a type implementing 
            <see cref="T:System.Collections.Generic.IEnumerable`1"/>, where <c>T</c> is instantiated with a concrete type. For a single value, this is the value type.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.StreamedData.StreamedScalarValueInfo">
            <summary>
            Describes a scalar value streamed out of a <see cref="T:Remotion.Linq.QueryModel"/> or <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/>. A scalar value corresponds to a
            value calculated from the result set, as produced by <see cref="T:Remotion.Linq.Clauses.ResultOperators.CountResultOperator"/> or <see cref="T:Remotion.Linq.Clauses.ResultOperators.ContainsResultOperator"/>, for instance.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.StreamedData.StreamedValueInfo">
            <summary>
            Describes a single or scalar value streamed out of a <see cref="T:Remotion.Linq.QueryModel"/> or <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.StreamedData.StreamedValueInfo.ExecuteQueryModel(Remotion.Linq.QueryModel,Remotion.Linq.IQueryExecutor)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Linq.Clauses.StreamedData.StreamedValueInfo.CloneWithNewDataType(System.Type)">
            <summary>
            Returns a new instance of the same <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedValueInfo"/> type with a different <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedValueInfo.DataType"/>.
            </summary>
            <param name="dataType">The new data type.</param>
            <exception cref="T:System.ArgumentException">The <paramref name="dataType"/> cannot be used for the clone.</exception>
            <returns>A new instance of the same <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedValueInfo"/> type with the given <paramref name="dataType"/>.</returns>
        </member>
        <member name="M:Remotion.Linq.Clauses.StreamedData.StreamedValueInfo.AdjustDataType(System.Type)">
            <inheritdoc />
        </member>
        <member name="P:Remotion.Linq.Clauses.StreamedData.StreamedValueInfo.DataType">
            <summary>
            Gets the type of the data described by this <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/> instance. This is the type of the streamed value, or 
            <see cref="T:System.Object"/> if the value is <see langword="null"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.StreamedData.StreamedSequence">
            <summary>
            Holds the data needed to represent the output or input of a part of a query in memory. This is mainly used for 
            <see cref="M:Remotion.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Linq.Clauses.StreamedData.IStreamedData)"/>.  The data consists of a sequence of items.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.StreamedData.StreamedSequence.#ctor(System.Collections.IEnumerable,Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedSequence"/> class, setting the <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequence.Sequence"/> and 
            <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequence.DataInfo"/> properties.
            </summary>
            <param name="sequence">The sequence.</param>
            <param name="streamedSequenceInfo">An instance of <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo"/> describing the sequence.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.StreamedData.StreamedSequence.GetTypedSequence``1">
            <summary>
            Gets the current sequence held by this object as well as an <see cref="T:System.Linq.Expressions.Expression"/> describing the
            sequence's items, throwing an exception if the object does not hold a sequence of items of type <typeparamref name="T"/>.
            </summary>
            <typeparam name="T">The expected item type of the sequence.</typeparam>
            <returns>
            The sequence and an <see cref="T:System.Linq.Expressions.Expression"/> describing its items.
            </returns>
            <exception cref="T:System.InvalidOperationException">Thrown when the item type is not the expected type <typeparamref name="T"/>.</exception>
        </member>
        <member name="P:Remotion.Linq.Clauses.StreamedData.StreamedSequence.Sequence">
            <summary>
            Gets the current sequence for the <see cref="M:Remotion.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Linq.Clauses.StreamedData.IStreamedData)"/> operation. If the object is used as input, this 
            holds the input sequence for the operation. If the object is used as output, this holds the result of the operation.
            </summary>
            <value>The current sequence.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo">
            <summary>
            Describes sequence data streamed out of a <see cref="T:Remotion.Linq.QueryModel"/> or <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/>. Sequence data can be held by an object
            implementing <see cref="T:System.Collections.Generic.IEnumerable`1"/>, and its items are described via a <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.ItemExpression"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.AdjustDataType(System.Type)">
            <summary>
            Returns a new <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo"/> with an adjusted <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.DataType"/>.
            </summary>
            <param name="dataType">The type to use for the <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.DataType"/> property. The type must be convertible from the previous type, otherwise
            an exception is thrown. The type may be a generic type definition; in this case,
            the type definition is automatically closed with the type of the <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.ItemExpression"/>.</param>
            <returns>
            A new <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo"/> with a new <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.DataType"/>.
            </returns>
            <exception cref="T:System.ArgumentException">The <paramref name="dataType"/> is not compatible with the items described by this
            <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo"/>.</exception>
        </member>
        <member name="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.ResultItemType">
            <summary>
            Gets the type of the items returned by the sequence described by this object, as defined by <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.DataType"/>. Note that because 
            <see cref="T:System.Collections.Generic.IEnumerable`1"/> is covariant starting from .NET 4.0, this may be a more abstract type than what's returned by 
            <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.ItemExpression"/>'s <see cref="P:System.Linq.Expressions.Expression.Type"/> property.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.ItemExpression">
            <summary>
            Gets an expression that describes the structure of the items held by the sequence described by this object.
            </summary>
            <value>The expression for the sequence's items.</value>
        </member>
        <member name="P:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo.DataType">
            <summary>
            Gets the type of the data described by this <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedSequenceInfo"/> instance. This is a type implementing
            <see cref="T:System.Collections.Generic.IEnumerable`1"/>, where <c>T</c> is instantiated with a concrete type.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.StreamedData.StreamedSingleValueInfo">
            <summary>
            Describes a single value streamed out of a <see cref="T:Remotion.Linq.QueryModel"/> or <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/>. A single value corresponds to one
            item from the result set, as produced by <see cref="T:Remotion.Linq.Clauses.ResultOperators.FirstResultOperator"/> or <see cref="T:Remotion.Linq.Clauses.ResultOperators.SingleResultOperator"/>, for instance.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Clauses.StreamedData.StreamedValue">
            <summary>
            Holds the data needed to represent the output or input of a part of a query in memory. This is mainly used for 
            <see cref="M:Remotion.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Linq.Clauses.StreamedData.IStreamedData)"/>.  The data is a single, non-sequence value and can only be consumed by result operators 
            working with single values.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Clauses.StreamedData.StreamedValue.#ctor(System.Object,Remotion.Linq.Clauses.StreamedData.StreamedValueInfo)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedValue"/> class, setting the <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedValue.Value"/> and <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedValue.DataInfo"/> properties.
            </summary>
            <param name="value">The value.</param>
            <param name="streamedValueInfo">A <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedValueInfo"/> describing the value.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.StreamedData.StreamedValue.GetTypedValue``1">
            <summary>
            Gets the value held by <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedValue.Value"/>, throwing an exception if the value is not of type <typeparamref name="T"/>.
            </summary>
            <typeparam name="T">The expected type of the value.</typeparam>
            <returns><see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedValue.Value"/>, cast to <typeparamref name="T"/>.</returns>
            <exception cref="T:System.InvalidOperationException">Thrown when <see cref="P:Remotion.Linq.Clauses.StreamedData.StreamedValue.Value"/> if not of the expected type.</exception>
        </member>
        <member name="P:Remotion.Linq.Clauses.StreamedData.StreamedValue.DataInfo">
            <summary>
            Gets an object describing the data held by this <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedValue"/> instance.
            </summary>
            <value>
            An <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedValueInfo"/> object describing the data held by this <see cref="T:Remotion.Linq.Clauses.StreamedData.StreamedValue"/> instance.
            </value>
        </member>
        <member name="P:Remotion.Linq.Clauses.StreamedData.StreamedValue.Value">
            <summary>
            Gets the current value for the <see cref="M:Remotion.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Linq.Clauses.StreamedData.IStreamedData)"/> operation. If the object is used as input, this 
            holds the input value for the operation. If the object is used as output, this holds the result of the operation.
            </summary>
            <value>The current value.</value>
        </member>
        <member name="T:Remotion.Linq.Clauses.WhereClause">
            <summary>
            Represents the where part of a query, filtering data items according to some <see cref="P:Remotion.Linq.Clauses.WhereClause.Predicate"/>.
            </summary>
            <example>
            In C#, the "where" clause in the following sample corresponds to a <see cref="T:Remotion.Linq.Clauses.WhereClause"/>:
            <ode>
            var query = from s in Students
                        where s.First == "Hugo"
                        select s;
            </ode>
            </example>
        </member>
        <member name="M:Remotion.Linq.Clauses.WhereClause.#ctor(System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Clauses.WhereClause"/> class.
            </summary>
            <param name="predicate">The predicate used to filter data items.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.WhereClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,System.Int32)">
            <summary>
            Accepts the specified visitor by calling its <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitWhereClause(Remotion.Linq.Clauses.WhereClause,Remotion.Linq.QueryModel,System.Int32)"/> method.
            </summary>
            <param name="visitor">The visitor to accept.</param>
            <param name="queryModel">The query model in whose context this clause is visited.</param>
            <param name="index">The index of this clause in the <paramref name="queryModel"/>'s <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> collection.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.WhereClause.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this clause and its child objects via the given <paramref name="transformation"/> delegate.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression"/> within this
            clause, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="M:Remotion.Linq.Clauses.WhereClause.Clone(Remotion.Linq.Clauses.CloneContext)">
            <summary>
            Clones this clause.
            </summary>
            <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Linq.Clauses.CloneContext"/>.</param>
            <returns></returns>
        </member>
        <member name="P:Remotion.Linq.Clauses.WhereClause.Predicate">
            <summary>
            Gets the predicate, the expression representing the where condition by which the data items are filtered
            </summary>
        </member>
        <member name="T:Remotion.Linq.Collections.ChangeResistantObservableCollectionEnumerator`1">
            <summary>
            Provides a way to enumerate an <see cref="T:System.Collections.ObjectModel.ObservableCollection`1"/> while items are inserted, removed, or cleared in a consistent fashion.
            </summary>
            <typeparam name="T">The element type of the <see cref="T:System.Collections.ObjectModel.ObservableCollection`1"/>.</typeparam>
            <remarks>
            This class subscribes to the <see cref="E:System.Collections.ObjectModel.ObservableCollection`1.CollectionChanged"/> event exposed by <see cref="T:System.Collections.ObjectModel.ObservableCollection`1"/> 
            and reacts on changes to the collection. If an item is inserted or removed before the current element, the enumerator will continue after 
            the current element without regarding the new or removed item. If the current item is removed, the enumerator will continue with the item that 
            previously followed the current item. If an item is inserted or removed after the current element, the enumerator will simply continue, 
            including the newly inserted item and not including the removed item. If an item is moved or replaced, the enumeration will also continue 
            with the item located at the next position in the sequence.
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Collections.IndexValuePair`1">
            <summary>
            Represents an item enumerated by <see cref="M:Remotion.Linq.Collections.ObservableCollectionExtensions.AsChangeResistantEnumerableWithIndex``1(System.Collections.ObjectModel.ObservableCollection{``0})"/>. This provides access
            to the <see cref="P:Remotion.Linq.Collections.IndexValuePair`1.Index"/> as well as the <see cref="P:Remotion.Linq.Collections.IndexValuePair`1.Value"/> of the enumerated item.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Collections.IndexValuePair`1.Index">
            <summary>
            Gets the index of the current enumerated item. Can only be called while enumerating, afterwards, it will throw an 
            <see cref="T:System.ObjectDisposedException"/>. If an item is inserted into or removed from the collection before the current item, this
            index will change.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Collections.IndexValuePair`1.Value">
            <summary>
            Gets the value of the current enumerated item. Can only be called while enumerating, afterwards, it will throw an 
            <see cref="T:System.ObjectDisposedException"/>.
            </summary>
            <value>The value.</value>
        </member>
        <member name="T:Remotion.Linq.Collections.MultiDictionaryExtensions">
            <summary>
            Defines extension methods that simplify working with a dictionary that has a collection-values item-type.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Collections.ObservableCollectionExtensions">
            <summary>
            Extension methods for <see cref="T:System.Collections.ObjectModel.ObservableCollection`1"/>
            </summary>
        </member>
        <member name="M:Remotion.Linq.Collections.ObservableCollectionExtensions.AsChangeResistantEnumerable``1(System.Collections.ObjectModel.ObservableCollection{``0})">
            <summary>
            Returns an instance of <see cref="T:System.Collections.Generic.IEnumerable`1"/> that represents this collection and can be enumerated even while the collection changes;
            the enumerator will adapt to the changes (see <see cref="T:Remotion.Linq.Collections.ChangeResistantObservableCollectionEnumerator`1"/>).
            </summary>
        </member>
        <member name="M:Remotion.Linq.Collections.ObservableCollectionExtensions.AsChangeResistantEnumerableWithIndex``1(System.Collections.ObjectModel.ObservableCollection{``0})">
            <summary>
            Returns an instance of <see cref="T:System.Collections.Generic.IEnumerable`1"/> that represents this collection and can be enumerated even while the collection changes;
            the enumerator will adapt to the changes (see <see cref="T:Remotion.Linq.Collections.ChangeResistantObservableCollectionEnumerator`1"/>). The enumerable will yield
            instances of type <see cref="T:Remotion.Linq.Collections.IndexValuePair`1"/>, which hold both the index and the value of the current item. If this collection changes
            while enumerating, <see cref="P:Remotion.Linq.Collections.IndexValuePair`1.Index"/> will reflect those changes.
            </summary>
        </member>
        <member name="T:Remotion.Linq.DefaultQueryProvider">
            <summary>
            Represents a default implementation of <see cref="T:Remotion.Linq.QueryProviderBase"/> that is automatically used by <see cref="T:Remotion.Linq.QueryableBase`1"/>
            unless a custom <see cref="T:System.Linq.IQueryProvider"/> is specified. The <see cref="T:Remotion.Linq.DefaultQueryProvider"/> executes queries by parsing them into
            an instance of type <see cref="T:Remotion.Linq.QueryModel"/>, which is then passed to an implementation of <see cref="T:Remotion.Linq.IQueryExecutor"/> to obtain the
            result set.
            </summary>
        </member>
        <member name="T:Remotion.Linq.QueryProviderBase">
            <summary>
            Provides a default implementation of <see cref="T:System.Linq.IQueryProvider"/> that executes queries (subclasses of <see cref="T:Remotion.Linq.QueryableBase`1"/>) by
            first parsing them into a <see cref="T:Remotion.Linq.QueryModel"/> and then passing that to a given implementation of <see cref="T:Remotion.Linq.IQueryExecutor"/>.
            Usually, <see cref="T:Remotion.Linq.DefaultQueryProvider"/> should be used unless <see cref="M:Remotion.Linq.QueryProviderBase.CreateQuery``1(System.Linq.Expressions.Expression)"/> must be manually implemented.
            </summary>
        </member>
        <member name="M:Remotion.Linq.QueryProviderBase.#ctor(Remotion.Linq.Parsing.Structure.IQueryParser,Remotion.Linq.IQueryExecutor)">
            <summary>
            Initializes a new instance of <see cref="T:Remotion.Linq.QueryProviderBase"/> using a custom <see cref="T:Remotion.Linq.Parsing.Structure.IQueryParser"/>. Use this
            constructor to customize how queries are parsed.
            </summary>
            <param name="queryParser">The <see cref="T:Remotion.Linq.Parsing.Structure.IQueryParser"/> used to parse queries. Specify an instance of <see cref="T:Remotion.Linq.Parsing.Structure.QueryParser"/>
              for default behavior.</param>
            <param name="executor">The <see cref="T:Remotion.Linq.IQueryExecutor"/> used to execute queries against a specific query backend.</param>
        </member>
        <member name="M:Remotion.Linq.QueryProviderBase.CreateQuery(System.Linq.Expressions.Expression)">
            <summary>
            Constructs an <see cref="T:System.Linq.IQueryable"/> object that can evaluate the query represented by a specified expression tree. This
            method delegates to <see cref="M:Remotion.Linq.QueryProviderBase.CreateQuery``1(System.Linq.Expressions.Expression)"/>.
            </summary>
            <param name="expression">An expression tree that represents a LINQ query.</param>
            <returns>
            An <see cref="T:System.Linq.IQueryable"/> that can evaluate the query represented by the specified expression tree.
            </returns>
        </member>
        <member name="M:Remotion.Linq.QueryProviderBase.CreateQuery``1(System.Linq.Expressions.Expression)">
            <summary>
            Constructs an <see cref="T:System.Linq.IQueryable`1"/> object that can evaluate the query represented by a specified expression tree. This method is 
            called by the standard query operators defined by the <see cref="T:System.Linq.Queryable"/> class.
            </summary>
            <param name="expression">An expression tree that represents a LINQ query.</param>
            <returns>
            An <see cref="T:System.Linq.IQueryable`1"/> that can evaluate the query represented by the specified expression tree.
            </returns>
        </member>
        <member name="M:Remotion.Linq.QueryProviderBase.Execute(System.Linq.Expressions.Expression)">
            <summary>
            Executes the query defined by the specified expression by parsing it with a 
            <see cref="P:Remotion.Linq.QueryProviderBase.QueryParser"/> and then running it through the <see cref="P:Remotion.Linq.QueryProviderBase.Executor"/>.
            This method is invoked through the <see cref="T:System.Linq.IQueryProvider"/> interface methods, for example by 
            <see cref="M:System.Linq.Queryable.First``1(System.Linq.IQueryable{``0})"/> and 
            <see cref="M:System.Linq.Queryable.Count``1(System.Linq.IQueryable{``0})"/>, and it's also used by <see cref="T:Remotion.Linq.QueryableBase`1"/>
            when the <see cref="T:System.Linq.IQueryable`1"/> is enumerated.
            </summary>
            <remarks>
            Override this method to replace the query execution mechanism by a custom implementation.
            </remarks>
        </member>
        <member name="M:Remotion.Linq.QueryProviderBase.System#Linq#IQueryProvider#Execute``1(System.Linq.Expressions.Expression)">
            <summary>
            Executes the query defined by the specified expression by parsing it with a
            <see cref="P:Remotion.Linq.QueryProviderBase.QueryParser"/> and then running it through the <see cref="P:Remotion.Linq.QueryProviderBase.Executor"/>.
            The result is cast to <typeparamref name="TResult"/>.
            </summary>
            <typeparam name="TResult">The type of the query result.</typeparam>
            <param name="expression">The query expression to be executed.</param>
            <returns>The result of the query cast to <typeparamref name="TResult"/>.</returns>
            <remarks>
            This method is called by the standard query operators that return a single value, such as 
            <see cref="M:System.Linq.Queryable.Count``1(System.Linq.IQueryable{``0})"/> or 
            <see cref="M:System.Linq.Queryable.First``1(System.Linq.IQueryable{``0})"/>.
            In addition, it is called by <see cref="T:Remotion.Linq.QueryableBase`1"/> to execute queries that return sequences.
            </remarks>
        </member>
        <member name="M:Remotion.Linq.QueryProviderBase.System#Linq#IQueryProvider#Execute(System.Linq.Expressions.Expression)">
            <summary>
            Executes the query defined by the specified expression by parsing it with a
            <see cref="P:Remotion.Linq.QueryProviderBase.QueryParser"/> and then running it through the <see cref="P:Remotion.Linq.QueryProviderBase.Executor"/>.
            </summary>
            <param name="expression">The query expression to be executed.</param>
            <returns>The result of the query.</returns>
            <remarks>
            This method is similar to the <see cref="M:System.Linq.IQueryProvider.Execute``1(System.Linq.Expressions.Expression)"/> method, but without the cast to a defined return type.
            </remarks>
        </member>
        <member name="M:Remotion.Linq.QueryProviderBase.GenerateQueryModel(System.Linq.Expressions.Expression)">
            <summary>
            The method generates a <see cref="T:Remotion.Linq.QueryModel"/>.
            </summary>
            <param name="expression">The query as expression chain.</param>
            <returns>a <see cref="T:Remotion.Linq.QueryModel"/></returns>
        </member>
        <member name="P:Remotion.Linq.QueryProviderBase.QueryParser">
            <summary>
            Gets the <see cref="P:Remotion.Linq.QueryProviderBase.QueryParser"/> used by this <see cref="T:Remotion.Linq.QueryProviderBase"/> to parse LINQ queries.
            </summary>
            <value>The query parser.</value>
        </member>
        <member name="P:Remotion.Linq.QueryProviderBase.Executor">
            <summary>
            Gets or sets the implementation of <see cref="T:Remotion.Linq.IQueryExecutor"/> used to execute queries created via <see cref="M:Remotion.Linq.QueryProviderBase.CreateQuery``1(System.Linq.Expressions.Expression)"/>.
            </summary>
            <value>The executor used to execute queries.</value>
        </member>
        <member name="M:Remotion.Linq.DefaultQueryProvider.#ctor(System.Type,Remotion.Linq.Parsing.Structure.IQueryParser,Remotion.Linq.IQueryExecutor)">
            <summary>
            Initializes a new instance of <see cref="T:Remotion.Linq.DefaultQueryProvider"/> using a custom <see cref="T:Remotion.Linq.Parsing.Structure.IQueryParser"/>.
            </summary>
            <param name="queryableType">
              A type implementing <see cref="T:System.Linq.IQueryable`1"/>. This type is used to construct the chain of query operators. Must be a generic type
              definition.
            </param>
            <param name="queryParser">The <see cref="T:Remotion.Linq.Parsing.Structure.IQueryParser"/> used to parse queries. Specify an instance of 
              <see cref="T:Remotion.Linq.Parsing.Structure.QueryParser"/> for default behavior. See also <see cref="M:Remotion.Linq.Parsing.Structure.QueryParser.CreateDefault"/>.</param>
            <param name="executor">The <see cref="T:Remotion.Linq.IQueryExecutor"/> used to execute queries against a specific query backend.</param>
        </member>
        <member name="M:Remotion.Linq.DefaultQueryProvider.CreateQuery``1(System.Linq.Expressions.Expression)">
            <summary>
            Creates a new <see cref="T:System.Linq.IQueryable"/> (of type <see cref="P:Remotion.Linq.DefaultQueryProvider.QueryableType"/> with <typeparamref name="T"/> as its generic argument) that
            represents the query defined by <paramref name="expression"/> and is able to enumerate its results.
            </summary>
            <typeparam name="T">The type of the data items returned by the query.</typeparam>
            <param name="expression">An expression representing the query for which a <see cref="T:System.Linq.IQueryable`1"/> should be created.</param>
            <returns>An <see cref="T:System.Linq.IQueryable`1"/> that represents the query defined by <paramref name="expression"/>.</returns>
        </member>
        <member name="P:Remotion.Linq.DefaultQueryProvider.QueryableType">
            <summary>
            Gets the type of queryable created by this provider. This is the generic type definition of an implementation of <see cref="T:System.Linq.IQueryable`1"/>
            (usually a subclass of <see cref="T:Remotion.Linq.QueryableBase`1"/>) with exactly one type argument.
            </summary>
        </member>
        <member name="T:Remotion.Linq.IQueryExecutor">
            <summary>
            Constitutes the bridge between re-linq and a concrete query provider implementation. Concrete providers implement this interface
            and <see cref="T:Remotion.Linq.QueryProviderBase"/> calls the respective method of the interface implementation when a query is to be executed.
            </summary>
        </member>
        <member name="M:Remotion.Linq.IQueryExecutor.ExecuteScalar``1(Remotion.Linq.QueryModel)">
            <summary>
            Executes the given <paramref name="queryModel"/> as a scalar query, i.e. as a query returning a scalar value of type <typeparamref name="T"/>.
            The query ends with a scalar result operator, for example a <see cref="T:Remotion.Linq.Clauses.ResultOperators.CountResultOperator"/> or a <see cref="T:Remotion.Linq.Clauses.ResultOperators.SumResultOperator"/>.
            </summary>
            <typeparam name="T">The type of the scalar value returned by the query.</typeparam>
            <param name="queryModel">The <see cref="T:Remotion.Linq.QueryModel"/> representing the query to be executed. Analyze this via an 
            <see cref="T:Remotion.Linq.IQueryModelVisitor"/>.</param>
            <returns>A scalar value of type <typeparamref name="T"/> that represents the query's result.</returns>
            <remarks>
            The difference between <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteSingle``1(Remotion.Linq.QueryModel,System.Boolean)"/> and <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteScalar``1(Remotion.Linq.QueryModel)"/> is in the kind of object that is returned.
            <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteSingle``1(Remotion.Linq.QueryModel,System.Boolean)"/> is used when a query that would otherwise return a collection result set should pick a single value from the 
            set, for example the first, last, minimum, maximum, or only value in the set. <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteScalar``1(Remotion.Linq.QueryModel)"/> is used when a value is 
            calculated or aggregated from all the values in the collection result set. This applies to, for example, item counts, average calculations,
            checks for the existence of a specific item, and so on.
            </remarks>
        </member>
        <member name="M:Remotion.Linq.IQueryExecutor.ExecuteSingle``1(Remotion.Linq.QueryModel,System.Boolean)">
            <summary>
            Executes the given <paramref name="queryModel"/> as a single object query, i.e. as a query returning a single object of type 
            <typeparamref name="T"/>.
            The query ends with a single result operator, for example a <see cref="T:Remotion.Linq.Clauses.ResultOperators.FirstResultOperator"/> or a <see cref="T:Remotion.Linq.Clauses.ResultOperators.SingleResultOperator"/>.
            </summary>
            <typeparam name="T">The type of the single value returned by the query.</typeparam>
            <param name="queryModel">The <see cref="T:Remotion.Linq.QueryModel"/> representing the query to be executed. Analyze this via an 
            <see cref="T:Remotion.Linq.IQueryModelVisitor"/>.</param>
            <param name="returnDefaultWhenEmpty">If <see langword="true"/>, the executor must return a default value when its result set is empty; 
            if <see langword="false"/>, it should throw an <see cref="T:System.InvalidOperationException"/> when its result set is empty.</param>
            <returns>A single value of type <typeparamref name="T"/> that represents the query's result.</returns>
            <remarks>
            The difference between <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteSingle``1(Remotion.Linq.QueryModel,System.Boolean)"/> and <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteScalar``1(Remotion.Linq.QueryModel)"/> is in the kind of object that is returned.
            <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteSingle``1(Remotion.Linq.QueryModel,System.Boolean)"/> is used when a query that would otherwise return a collection result set should pick a single value from the 
            set, for example the first, last, minimum, maximum, or only value in the set. <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteScalar``1(Remotion.Linq.QueryModel)"/> is used when a value is 
            calculated or aggregated from all the values in the collection result set. This applies to, for example, item counts, average calculations,
            checks for the existence of a specific item, and so on.
            </remarks>
        </member>
        <member name="M:Remotion.Linq.IQueryExecutor.ExecuteCollection``1(Remotion.Linq.QueryModel)">
            <summary>
            Executes the given <paramref name="queryModel"/> as a collection query, i.e. as a query returning objects of type <typeparamref name="T"/>. 
            The query does not end with a scalar result operator, but it can end with a single result operator, for example 
            <see cref="T:Remotion.Linq.Clauses.ResultOperators.SingleResultOperator"/> or <see cref="T:Remotion.Linq.Clauses.ResultOperators.FirstResultOperator"/>. In such a case, the returned enumerable must yield exactly 
            one object (or none if the last result operator allows empty result sets).
            </summary>
            <typeparam name="T">The type of the items returned by the query.</typeparam>
            <param name="queryModel">The <see cref="T:Remotion.Linq.QueryModel"/> representing the query to be executed. Analyze this via an 
            <see cref="T:Remotion.Linq.IQueryModelVisitor"/>.</param>
            <returns>A scalar value of type <typeparamref name="T"/> that represents the query's result.</returns>
        </member>
        <member name="T:Remotion.Linq.IQueryModelVisitor">
            <summary>
            Defines an interface for visiting the clauses of a <see cref="T:Remotion.Linq.QueryModel"/>.
            </summary>
            <remarks>
            <para>
            When implement this interface, implement <see cref="M:Remotion.Linq.IQueryModelVisitor.VisitQueryModel(Remotion.Linq.QueryModel)"/>, then call <c>Accept</c> on every clause that should
            be visited. Child clauses, joins, orderings, and result operators are not visited automatically; they always need to be explicitly visited 
            via <see cref="M:Remotion.Linq.Clauses.IBodyClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,System.Int32)"/>, <see cref="M:Remotion.Linq.Clauses.JoinClause.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,System.Int32)"/>, <see cref="M:Remotion.Linq.Clauses.Ordering.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,Remotion.Linq.Clauses.OrderByClause,System.Int32)"/>, 
            <see cref="M:Remotion.Linq.Clauses.ResultOperatorBase.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,System.Int32)"/>, and so on.
            </para>
            <para>
            <see cref="T:Remotion.Linq.QueryModelVisitorBase"/> provides a robust default implementation of this interface that can be used as a base for other visitors.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.MemberBindings.FieldInfoBinding">
            <summary>
            Represents a <see cref="T:System.Reflection.FieldInfo"/> being bound to an associated <see cref="T:System.Linq.Expressions.Expression"/> instance. This binding's 
            <see cref="M:Remotion.Linq.Parsing.ExpressionVisitors.MemberBindings.FieldInfoBinding.MatchesReadAccess(System.Reflection.MemberInfo)"/> method returns <see langword="true"/> only for the same <see cref="T:System.Reflection.FieldInfo"/> the expression is bound to.
            <seealso cref="T:System.Linq.Expressions.MemberBinding"/>
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.MemberBindings.MemberBinding">
            <summary>
            Represents a <see cref="T:System.Reflection.MemberInfo"/> being bound to an associated <see cref="T:System.Linq.Expressions.Expression"/> instance. This is used by the 
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TransparentIdentifierRemovingExpressionVisitor"/> to represent assignments in constructor calls such as <c>new AnonymousType (a = 5)</c>, 
            where <c>a</c> is the member of <c>AnonymousType</c> and <c>5</c> is the associated expression.
            The <see cref="M:Remotion.Linq.Parsing.ExpressionVisitors.MemberBindings.MemberBinding.MatchesReadAccess(System.Reflection.MemberInfo)"/> method can be used to check whether the member bound to an expression matches a given <see cref="T:System.Reflection.MemberInfo"/>
            (considering read access). See the subclasses for details.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.MemberBindings.MethodInfoBinding">
            <summary>
            Represents a <see cref="T:System.Reflection.MethodInfo"/> being bound to an associated <see cref="T:System.Linq.Expressions.Expression"/> instance. 
            <seealso cref="T:System.Linq.Expressions.MemberBinding"/>
            This binding's 
            <see cref="M:Remotion.Linq.Parsing.ExpressionVisitors.MemberBindings.MethodInfoBinding.MatchesReadAccess(System.Reflection.MemberInfo)"/> method returns <see langword="true"/> for the same <see cref="T:System.Reflection.MethodInfo"/> the expression is bound to or for a
            <see cref="T:System.Reflection.PropertyInfo"/> whose getter method is the <see cref="T:System.Reflection.MethodInfo"/> the expression is bound to.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.MemberBindings.PropertyInfoBinding">
            <summary>
            Represents a <see cref="T:System.Reflection.PropertyInfo"/> being bound to an associated <see cref="T:System.Linq.Expressions.Expression"/> instance. 
            <seealso cref="T:System.Linq.Expressions.MemberBinding"/>
            This binding's 
            <see cref="M:Remotion.Linq.Parsing.ExpressionVisitors.MemberBindings.PropertyInfoBinding.MatchesReadAccess(System.Reflection.MemberInfo)"/> method returns <see langword="true"/> for the same <see cref="T:System.Reflection.PropertyInfo"/> the expression is bound to 
            or for its getter method's <see cref="T:System.Reflection.MethodInfo"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.MultiReplacingExpressionVisitor">
            <summary>
            Replaces <see cref="T:System.Linq.Expressions.Expression"/> nodes according to a given mapping specification. Expressions are also replaced within subqueries; the 
            <see cref="T:Remotion.Linq.QueryModel"/> is changed by the replacement operations, it is not copied. The replacement node is not recursively searched for 
            occurrences of <see cref="T:System.Linq.Expressions.Expression"/> nodes to be replaced.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.PartialEvaluatingExpressionVisitor">
            <summary>
            Takes an expression tree and first analyzes it for evaluatable subtrees (using <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.EvaluatableTreeFindingExpressionVisitor"/>), i.e.
            subtrees that can be pre-evaluated before actually generating the query. Examples for evaluatable subtrees are operations on constant
            values (constant folding), access to closure variables (variables used by the LINQ query that are defined in an outer scope), or method
            calls on known objects or their members. In a second step, it replaces all of the evaluatable subtrees (top-down and non-recursive) by 
            their evaluated counterparts.
            </summary>
            <remarks>
            This visitor visits each tree node at most twice: once via the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.EvaluatableTreeFindingExpressionVisitor"/> for analysis and once
            again to replace nodes if possible (unless the parent node has already been replaced).
            </remarks>
        </member>
        <member name="M:Remotion.Linq.Parsing.ExpressionVisitors.PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(System.Linq.Expressions.Expression,Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.IEvaluatableExpressionFilter)">
            <summary>
            Takes an expression tree and finds and evaluates all its evaluatable subtrees.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.ExpressionVisitors.PartialEvaluatingExpressionVisitor.EvaluateSubtree(System.Linq.Expressions.Expression)">
            <summary>
            Evaluates an evaluatable <see cref="T:System.Linq.Expressions.Expression"/> subtree, i.e. an independent expression tree that is compilable and executable
            without any data being passed in. The result of the evaluation is returned as a <see cref="T:System.Linq.Expressions.ConstantExpression"/>; if the subtree
            is already a <see cref="T:System.Linq.Expressions.ConstantExpression"/>, no evaluation is performed.
            </summary>
            <param name="subtree">The subtree to be evaluated.</param>
            <returns>A <see cref="T:System.Linq.Expressions.ConstantExpression"/> holding the result of the evaluation.</returns>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.ReplacingExpressionVisitor">
            <summary>
            Replaces all nodes that equal a given <see cref="T:System.Linq.Expressions.Expression"/> with a replacement node. Expressions are also replaced within subqueries; the 
            <see cref="T:Remotion.Linq.QueryModel"/> is changed by the replacement operations, it is not copied. The replacement node is not recursively searched for 
            occurrences of the <see cref="T:System.Linq.Expressions.Expression"/> to be replaced.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.SubQueryFindingExpressionVisitor">
            <summary>
            Preprocesses an expression tree for parsing. The preprocessing involves detection of sub-queries and VB-specific expressions.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformation">
            <summary>
            Transforms a given <see cref="T:System.Linq.Expressions.Expression"/>. If the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformation"/> can handle the <see cref="T:System.Linq.Expressions.Expression"/>,
            it should return a new, transformed <see cref="T:System.Linq.Expressions.Expression"/> instance. Otherwise, it should return the input <paramref name="expression"/> 
            instance.
            </summary>
            <param name="expression">The expression to be transformed.</param>
            <returns>The result of the transformation, or <paramref name="expression"/> if no transformation was applied.</returns>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry">
            <summary>
            Manages registration and lookup of <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> objects, and converts them to 
            weakly typed <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformation"/> instances. Use this class together with <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TransformingExpressionVisitor"/>
            in order to apply the registered transformers to an <see cref="T:System.Linq.Expressions.Expression"/> tree.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTranformationProvider">
            <summary>
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTranformationProvider"/> defines an API for classes returning <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformation"/> instances for specific 
            <see cref="T:System.Linq.Expressions.Expression"/> objects. Usually, the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry"/> will be used when an implementation of this
            interface is needed.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTranformationProvider.GetTransformations(System.Linq.Expressions.Expression)">
            <summary>
            Gets the transformers for the given <see cref="T:System.Linq.Expressions.Expression"/>.
            </summary>
            <param name="expression">The <see cref="T:System.Linq.Expressions.Expression"/> to be transformed.</param>
            <returns>
            A sequence containing <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformation"/> objects that should be applied to the <paramref name="expression"/>. Must not
            be <see langword="null"/>.
            </returns>
        </member>
        <member name="M:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry.CreateDefault">
            <summary>
            Creates an <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry"/> with the default transformations provided by this library already registered.
            New transformers can be registered by calling <see cref="M:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry.Register``1(Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer{``0})"/>.
            </summary>
            <returns> A default <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry"/>.</returns>
            <remarks>
            Currently, the default registry contains:
            <list type="bullet">
            <item><see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.VBCompareStringExpressionTransformer"/></item>
            <item><see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.VBInformationIsNothingExpressionTransformer"/></item>
            <item><see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.InvocationOfLambdaExpressionTransformer"/></item>
            <item><see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.NullableValueTransformer"/></item>
            <item><see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.KeyValuePairNewExpressionTransformer"/></item>
            <item><see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.DictionaryEntryNewExpressionTransformer"/></item>
            <item><see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.TupleNewExpressionTransformer"/></item>
            </list>
            </remarks>
        </member>
        <member name="M:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry.Register``1(Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer{``0})">
            <summary>
            Registers the specified <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> for the transformer's 
            <see cref="P:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1.SupportedExpressionTypes"/>. If <see cref="P:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1.SupportedExpressionTypes"/>
            returns <see langword="null"/>, the <paramref name="transformer"/> is registered as a generic transformer which will be applied to all
            <see cref="T:System.Linq.Expressions.Expression"/> nodes.
            </summary>
            <typeparam name="T">The type of expressions handled by the <paramref name="transformer"/>. This should be a type implemented by all
            expressions identified by <see cref="P:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1.SupportedExpressionTypes"/>. For generic transformers, <typeparamref name="T"/> 
            must be <see cref="T:System.Linq.Expressions.Expression"/>.</typeparam>
            <param name="transformer">The transformer to register.</param>
            <remarks>
            <para>
            The order in which transformers are registered is the same order on which they will later be applied by 
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TransformingExpressionVisitor"/>. When more than one transformer is registered for a certain <see cref="T:System.Linq.Expressions.ExpressionType"/>,
            each of them will get a chance to transform a given <see cref="T:System.Linq.Expressions.Expression"/>, until the first one returns a new <see cref="T:System.Linq.Expressions.Expression"/>.
            At that point, the transformation will start again with the new <see cref="T:System.Linq.Expressions.Expression"/> (and, if the expression's type has changed, potentially 
            different transformers).
            </para>
            <para>
            When generic transformers are registered, they act as if they had been registered for all <see cref="T:System.Linq.Expressions.ExpressionType"/> values (including
            custom ones). They will be applied in the order registered, but only after all respective specific transformers have run (without modifying 
            the expression, which would restart the transformation process with the new expression as explained above).
            </para>
            <para>
            When an <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> is registered for an incompatible <see cref="T:System.Linq.Expressions.ExpressionType"/>, this is not detected until 
            the transformer is actually applied to an <see cref="T:System.Linq.Expressions.Expression"/> of that <see cref="T:System.Linq.Expressions.ExpressionType"/>.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1">
            <summary>
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> is implemented by classes that transform <see cref="T:System.Linq.Expressions.Expression"/> instances. The 
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry"/> manages registration of <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> instances, and the 
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TransformingExpressionVisitor"/> applies the transformations.
            </summary>
            <typeparam name="T">The type of expressions handled by this <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> implementation.</typeparam>
            <remarks>
            <para>
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> is a convenience interface that provides strong typing, whereas 
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformation"/> only operates on <see cref="T:System.Linq.Expressions.Expression"/> instances. 
            </para>
            <para>
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> can be used together with the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TransformingExpressionVisitor"/> class by using the 
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry"/> class as the transformation provider. <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry"/> converts 
            strongly typed <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> instances to weakly typed <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformation"/> delegate instances.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1.Transform(`0)">
            <summary>
            Transforms a given <see cref="T:System.Linq.Expressions.Expression"/>. If the implementation can handle the <see cref="T:System.Linq.Expressions.Expression"/>,
            it should return a new, transformed <see cref="T:System.Linq.Expressions.Expression"/> instance. Otherwise, it should return the input
            <paramref name="expression"/> instance.
            </summary>
            <param name="expression">The expression to be transformed.</param>
            <returns>The result of the transformation, or <paramref name="expression"/> if no transformation was applied.</returns>
        </member>
        <member name="P:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1.SupportedExpressionTypes">
            <summary>
            Gets the expression types supported by this <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/>.
            </summary>
            <value>The supported expression types. Return <see langword="null"/> to support all expression types. (This is only sensible when
            <typeparamref name="T"/> is <see cref="T:System.Linq.Expressions.Expression"/>.)
            </value>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.AttributeEvaluatingExpressionTransformer">
            <summary>
            Dynamically discovers attributes implementing the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.AttributeEvaluatingExpressionTransformer.IMethodCallExpressionTransformerAttribute"/> interface on methods and get accessors
            invoked by <see cref="T:System.Linq.Expressions.MethodCallExpression"/> or <see cref="T:System.Linq.Expressions.MemberExpression"/> instances and applies the respective 
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.AttributeEvaluatingExpressionTransformer.IMethodCallExpressionTransformerAttribute">
            <summary>
            Defines an interface for attributes providing an <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> for a given <see cref="T:System.Linq.Expressions.MethodCallExpression"/>.
            </summary>
            <remarks>
            <para>
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.AttributeEvaluatingExpressionTransformer"/> detects attributes implementing this interface while expressions are parsed 
            and uses the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> returned by <see cref="M:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.AttributeEvaluatingExpressionTransformer.IMethodCallExpressionTransformerAttribute.GetExpressionTransformer(System.Linq.Expressions.MethodCallExpression)"/> to modify the expressions.
            </para>
            <para>
            Only one attribute instance implementing <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.AttributeEvaluatingExpressionTransformer.IMethodCallExpressionTransformerAttribute"/> must be applied to a single method or property
            get accessor.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.DictionaryEntryNewExpressionTransformer">
            <summary>
            Detects <see cref="T:System.Linq.Expressions.NewExpression"/> nodes for <see cref="T:System.Collections.DictionaryEntry"/> and adds <see cref="T:System.Reflection.MemberInfo"/> metadata to those nodes.
            This allows LINQ providers to match member access and constructor arguments more easily.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.MemberAddingNewExpressionTransformerBase">
            <summary>
            Provides a base class for transformers detecting <see cref="T:System.Linq.Expressions.NewExpression"/> nodes for tuple types and adding <see cref="T:System.Reflection.MemberInfo"/> metadata 
            to those nodes. This allows LINQ providers to match member access and constructor arguments more easily.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.InvocationOfLambdaExpressionTransformer">
            <summary>
            Detects expressions invoking a <see cref="T:System.Linq.Expressions.LambdaExpression"/> and replaces them with the body of that 
            <see cref="T:System.Linq.Expressions.LambdaExpression"/> (with the parameter references replaced with the invocation arguments).
            Providers use this transformation to be able to handle queries with <see cref="T:System.Linq.Expressions.InvocationExpression"/> instances.
            </summary>
            <remarks>
            When the <see cref="T:System.Linq.Expressions.InvocationExpression"/> is applied to a delegate instance (rather than a 
            <see cref="T:System.Linq.Expressions.LambdaExpression"/>), the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.InvocationOfLambdaExpressionTransformer"/> ignores it.
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.KeyValuePairNewExpressionTransformer">
            <summary>
            Detects <see cref="T:System.Linq.Expressions.NewExpression"/> nodes for <see cref="T:System.Collections.Generic.KeyValuePair`2"/> and adds <see cref="T:System.Reflection.MemberInfo"/> metadata to those nodes.
            This allows LINQ providers to match member access and constructor arguments more easily.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.MethodCallExpressionTransformerAttribute">
            <summary>
            Chooses a given <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> for a specific method (or property get accessor).
            </summary>
            <remarks>
            The <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> must have a default constructor. To choose a transformer that does not have a default constructor,
            create your own custom attribute class implementing 
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.AttributeEvaluatingExpressionTransformer.IMethodCallExpressionTransformerAttribute"/>.
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.NullableValueTransformer">
            <summary>
            Replaces calls to <see cref="P:System.Nullable`1.Value"/> and <see cref="P:System.Nullable`1.HasValue"/> with casts and null checks. This allows LINQ providers
            to treat nullables like reference types.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.TupleNewExpressionTransformer">
            <summary>
            Detects <see cref="T:System.Linq.Expressions.NewExpression"/> nodes for the .NET tuple types and adds <see cref="T:System.Reflection.MemberInfo"/> metadata to those nodes.
            This allows LINQ providers to match member access and constructor arguments more easily.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.VBCompareStringExpressionTransformer">
            <summary>
            Detects expressions calling the CompareString method used by Visual Basic .NET, and replaces them with 
            <see cref="T:Remotion.Linq.Clauses.Expressions.VBStringComparisonExpression"/> instances. Providers use this transformation to be able to handle VB string comparisons
            more easily. See <see cref="T:Remotion.Linq.Clauses.Expressions.VBStringComparisonExpression"/> for details.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.PredefinedTransformations.VBInformationIsNothingExpressionTransformer">
            <summary>
            Detects expressions calling the Information.IsNothing (...) method used by Visual Basic .NET, and replaces them with 
            <see cref="T:System.Linq.Expressions.BinaryExpression"/> instances comparing with <see langword="null"/>. Providers use this transformation to be able to 
            handle queries using IsNothing (...) more easily.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.TransformingExpressionVisitor">
            <summary>
            Applies <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformation"/> delegates obtained from an <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTranformationProvider"/> to an expression tree. 
            The transformations occur in post-order (transforming child <see cref="T:System.Linq.Expressions.Expression"/> nodes before parent nodes). When a transformation changes 
            the current <see cref="T:System.Linq.Expressions.Expression"/>, its child nodes and itself will be revisited (and may be transformed again).
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.TransparentIdentifierRemovingExpressionVisitor">
            <summary>
            Replaces expression patterns of the form <c>new T { x = 1, y = 2 }.x</c> (<see cref="T:System.Linq.Expressions.MemberInitExpression"/>) or 
            <c>new T ( x = 1, y = 2 ).x</c> (<see cref="T:System.Linq.Expressions.NewExpression"/>) to <c>1</c> (or <c>2</c> if <c>y</c> is accessed instead of <c>x</c>).
            Expressions are also replaced within subqueries; the <see cref="T:Remotion.Linq.QueryModel"/> is changed by the replacement operations, it is not copied. 
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.EvaluatableExpressionFilterBase">
            <summary>
            Base class for typical implementations of the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.IEvaluatableExpressionFilter"/>.
            </summary>
            <seealso cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.IEvaluatableExpressionFilter"/>
            <threadsafety static="true" instance="true"/>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.IEvaluatableExpressionFilter">
            <summary>
            The <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.IEvaluatableExpressionFilter"/> interface defines an extension point for disabling partial evaluation on specific <see cref="T:System.Linq.Expressions.Expression"/> nodes.
            </summary>
            <remarks>
            <para>
            Implement the individual evaluation methods and return <see langword="false"/> to mark a specfic <see cref="T:System.Linq.Expressions.Expression"/> node as not partially 
            evaluatable. Note that the partial evaluation infrastructure will take care of visiting an <see cref="T:System.Linq.Expressions.Expression"/> node's children, 
            so the determination can usually be constrained to the attributes of the <see cref="T:System.Linq.Expressions.Expression"/> node itself.
            </para><para>
            Use the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.EvaluatableExpressionFilterBase"/> type as a base class for filter implementations that only require testing a few 
            <see cref="T:System.Linq.Expressions.Expression"/> node types, e.g. to disable partial evaluation for individual method calls.
            </para>
            </remarks>
            <seealso cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.EvaluatableExpressionFilterBase"/>
            <threadsafety static="true" instance="true"/>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.EvaluatableTreeFindingExpressionVisitor">
            <summary>
            Analyzes an expression tree by visiting each of its nodes, finding those subtrees that can be evaluated without modifying the meaning of
            the tree.
            </summary>
            <remarks>
            An expression node/subtree is evaluatable if:
            <list type="bullet">
            <item>it is not a <see cref="T:System.Linq.Expressions.ParameterExpression"/> or any non-standard expression, </item>
            <item>it is not a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> that involves an <see cref="T:System.Linq.IQueryable"/>, and</item>
            <item>it does not have any of those non-evaluatable expressions as its children.</item>
            </list>
            <para>
            <see cref="T:System.Linq.Expressions.ParameterExpression"/> nodes are not evaluatable because they usually identify the flow of
            some information from one query node to the next. 
            </para><para>
            <see cref="T:System.Linq.Expressions.MethodCallExpression"/> nodes that involve <see cref="T:System.Linq.IQueryable"/> parameters or object instances are not evaluatable because they 
            should usually be translated into the target query syntax.
            </para><para>
            In .NET 3.5, non-standard expressions are not evaluatable because they cannot be compiled and evaluated by LINQ. 
            In .NET 4.0, non-standard expressions can be evaluated if they can be reduced to an evaluatable expression.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.EvaluatableTreeFindingExpressionVisitor.IsCurrentExpressionEvaluatable(System.Linq.Expressions.Expression)">
            <summary>
            Determines whether the given <see cref="T:System.Linq.Expressions.Expression"/> is one of the expressions defined by <see cref="T:System.Linq.Expressions.ExpressionType"/> for which
            <see cref="T:System.Linq.Expressions.ExpressionVisitor"/> has a dedicated Visit method. <see cref="M:System.Linq.Expressions.ExpressionVisitor.Visit(System.Linq.Expressions.Expression)"/> handles those by calling the respective Visit method.
            </summary>
            <param name="expression">The expression to check. Must not be <see langword="null"/>.</param>
            <returns>
            <see langword="true"/> if <paramref name="expression"/> is one of the expressions defined by <see cref="T:System.Linq.Expressions.ExpressionType"/> and 
            <see cref="T:System.Linq.Expressions.ExpressionVisitor"/> has a dedicated Visit method for it; otherwise, <see langword="false"/>. 
            Note that <see cref="F:System.Linq.Expressions.ExpressionType.Extension"/>-type expressions are considered 'not supported' and will also return <see langword="false"/>.
            </returns>
        </member>
        <member name="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.NullEvaluatableExpressionFilter">
            <summary>
            Implementation of the null-object pattern for <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.IEvaluatableExpressionFilter"/>.
            </summary>
            <threadsafety static="true" instance="true"/>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser">
            <summary>
            Parses an expression tree into a chain of <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> objects after executing a sequence of 
            <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/> objects.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.CreateDefaultNodeTypeProvider">
            <summary>
            Creates a default <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly 
            registered. Users can add inner providers to register their own expression node parsers.
            </summary>
            <returns>A default <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly 
            registered.</returns>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.CreateDefaultProcessor(Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTranformationProvider,Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.IEvaluatableExpressionFilter)">
            <summary>
            Creates a default <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.CompoundExpressionTreeProcessor"/> that already has the expression tree processing steps defined by the re-linq assembly
            registered. Users can insert additional processing steps.
            </summary>
            <param name="tranformationProvider">
            The tranformation provider to be used by the <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.TransformingExpressionTreeProcessor"/> included
            in the result set. Use <see cref="M:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry.CreateDefault"/> to create a default provider.
            </param>
            <param name="evaluatableExpressionFilter">
            The expression filter used by the <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.PartialEvaluatingExpressionTreeProcessor"/> included in the result set.
            Use <see langword="null"/> to indicate that no custom filtering should be applied.
            </param>
            <returns>
            A default <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.CompoundExpressionTreeProcessor"/> that already has all expression tree processing steps defined by the re-linq assembly
            registered.
            </returns>
            <remarks>
            The following steps are included:
            <list type="bullet">
            		<item><see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.PartialEvaluatingExpressionTreeProcessor"/></item>
            		<item><see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.TransformingExpressionTreeProcessor"/> (parameterized with <paramref name="tranformationProvider"/>)</item>
            	</list>
            </remarks>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.#ctor(Remotion.Linq.Parsing.Structure.INodeTypeProvider,Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> class with a custom <see cref="T:Remotion.Linq.Parsing.Structure.INodeTypeProvider"/> and 
            <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/> implementation.
            </summary>
            <param name="nodeTypeProvider">The <see cref="T:Remotion.Linq.Parsing.Structure.INodeTypeProvider"/> to use when parsing <see cref="T:System.Linq.Expressions.Expression"/> trees. Use 
            <see cref="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.CreateDefaultNodeTypeProvider"/> to create an instance of <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.CompoundNodeTypeProvider"/> that already includes all
            default node types. (The <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.CompoundNodeTypeProvider"/> can be customized as needed by adding or removing 
            <see cref="P:Remotion.Linq.Parsing.Structure.NodeTypeProviders.CompoundNodeTypeProvider.InnerProviders"/>).</param>
            <param name="processor">The <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/> to apply to <see cref="T:System.Linq.Expressions.Expression"/> trees before parsing their nodes. Use
            <see cref="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.CreateDefaultProcessor(Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTranformationProvider,Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.IEvaluatableExpressionFilter)"/> to create an instance of <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.CompoundExpressionTreeProcessor"/> that already includes
            the default steps. (The <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.CompoundExpressionTreeProcessor"/> can be customized as needed by adding or removing 
            <see cref="P:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.CompoundExpressionTreeProcessor.InnerProcessors"/>).</param>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.ParseTree(System.Linq.Expressions.Expression)">
            <summary>
            Parses the given <paramref name="expressionTree"/> into a chain of <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> instances, using 
            <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry"/> to convert expressions to nodes.
            </summary>
            <param name="expressionTree">The expression tree to parse.</param>
            <returns>A chain of <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> instances representing the <paramref name="expressionTree"/>.</returns>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.GetQueryOperatorExpression(System.Linq.Expressions.Expression)">
            <summary>
            Gets the query operator <see cref="T:System.Linq.Expressions.MethodCallExpression"/> represented by <paramref name="expression"/>. If <paramref name="expression"/>
            is already a <see cref="T:System.Linq.Expressions.MethodCallExpression"/>, that is the assumed query operator. If <paramref name="expression"/> is a 
            <see cref="T:System.Linq.Expressions.MemberExpression"/> and the member's getter is registered with <see cref="P:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.NodeTypeProvider"/>, a corresponding 
            <see cref="T:System.Linq.Expressions.MethodCallExpression"/> is constructed and returned. Otherwise, <see langword="null"/> is returned.
            </summary>
            <param name="expression">The expression to get a query operator expression for.</param>
            <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression"/> to be parsed as a query operator, or <see langword="null"/> if the expression does not represent
            a query operator.</returns>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.InferAssociatedIdentifierForSource(System.Linq.Expressions.MethodCallExpression)">
            <summary>
            Infers the associated identifier for the source expression node contained in methodCallExpression.Arguments[0]. For example, for the
            call chain "<c>source.Where (i => i > 5)</c>" (which actually reads "<c>Where (source, i => i > 5</c>"), the identifier "i" is associated
            with the node generated for "source". If no identifier can be inferred, <see langword="null"/> is returned.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.NodeTypeProvider">
            <summary>
            Gets the node type provider used to parse <see cref="T:System.Linq.Expressions.MethodCallExpression"/> instances in <see cref="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.ParseTree(System.Linq.Expressions.Expression)"/>.
            </summary>
            <value>The node type provider.</value>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.Processor">
            <summary>
            Gets the processing steps used by <see cref="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.ParseTree(System.Linq.Expressions.Expression)"/> to process the <see cref="T:System.Linq.Expressions.Expression"/> tree before analyzing its structure.
            </summary>
            <value>The processing steps.</value>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.CompoundExpressionTreeProcessor">
            <summary>
            Implements <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/> by storing a list of inner <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/> instances.
            The <see cref="M:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.CompoundExpressionTreeProcessor.Process(System.Linq.Expressions.Expression)"/> method calls each inner instance in the order defined by the <see cref="P:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.CompoundExpressionTreeProcessor.InnerProcessors"/> property. This is an
            implementation of the Composite Pattern.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor">
            <summary>
            <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/> is implemented by classes that represent steps in the process of parsing the structure
            of an <see cref="T:System.Linq.Expressions.Expression"/> tree. <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> applies a series of these steps to the <see cref="T:System.Linq.Expressions.Expression"/>
            tree before analyzing the query operators and creating a <see cref="T:Remotion.Linq.QueryModel"/>.
            </summary>
            <remarks>
            <para>
            There are predefined implementations of <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/> that should only be left out when parsing an 
            <see cref="T:System.Linq.Expressions.Expression"/> tree when there are very good reasons to do so.
            </para>
            <para>
            <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/> can be implemented to provide custom, complex transformations on an <see cref="T:System.Linq.Expressions.Expression"/>
            tree. For performance reasons, avoid adding too many steps each of which visits the whole tree. For
            simple transformations, consider using <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTransformer`1"/> and <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.TransformingExpressionTreeProcessor"/> - which can
            batch several transformations into a single expression tree visiting run - rather than implementing a dedicated 
            <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/>.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.NullExpressionTreeProcessor">
            <summary>
            Implements the <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/> interface by doing nothing in the <see cref="M:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.NullExpressionTreeProcessor.Process(System.Linq.Expressions.Expression)"/> method. This is an
            implementation of the Null Object Pattern.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.PartialEvaluatingExpressionTreeProcessor">
            <summary>
            Analyzes an <see cref="T:System.Linq.Expressions.Expression"/> tree for sub-trees that are evaluatable in-memory, and evaluates those sub-trees.
            </summary>
            <remarks>
            The <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.PartialEvaluatingExpressionTreeProcessor"/> uses the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.PartialEvaluatingExpressionVisitor"/> for partial evaluation.
            It performs two visiting runs over the <see cref="T:System.Linq.Expressions.Expression"/> tree.
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.TransformingExpressionTreeProcessor">
            <summary>
            Applies a given set of transformations to an <see cref="T:System.Linq.Expressions.Expression"/> tree. The transformations are provided by an instance of
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTranformationProvider"/> (eg., <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry"/>).
            </summary>
            <remarks>
            The <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.TransformingExpressionTreeProcessor"/> uses the <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.TransformingExpressionVisitor"/> to apply the transformations.
            It performs a single visiting run over the <see cref="T:System.Linq.Expressions.Expression"/> tree.
            </remarks>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.TransformingExpressionTreeProcessor.#ctor(Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTranformationProvider)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors.TransformingExpressionTreeProcessor"/> class.
            </summary>
            <param name="provider">A class providing the transformations to apply to the tree, eg., an instance of 
            <see cref="T:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry"/>.</param>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.INodeTypeProvider">
            <summary>
            Provides a common interface for classes mapping a <see cref="T:System.Reflection.MethodInfo"/> to the respective <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>
            type. Implementations are used by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> is encountered to 
            instantiate the right <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> for the given method.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.INodeTypeProvider.IsRegistered(System.Reflection.MethodInfo)">
            <summary>
            Determines whether a node type for the given <see cref="T:System.Reflection.MethodInfo"/> can be returned by this 
            <see cref="T:Remotion.Linq.Parsing.Structure.INodeTypeProvider"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.INodeTypeProvider.GetNodeType(System.Reflection.MethodInfo)">
            <summary>
            Gets the type of <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> that matches the given <paramref name="method"/>, returning <see langword="null"/> 
            if none can be found.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.AggregateExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for the 
            <see cref="M:System.Linq.Queryable.Aggregate``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``0,``0}})"/> and <see cref="M:System.Linq.Enumerable.Aggregate``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})"/> methods.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ResultOperatorExpressionNodeBase">
            <summary>
            Acts as a base class for <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>s standing for <see cref="T:System.Linq.Expressions.MethodCallExpression"/>s that operate on the result of the query
            rather than representing actual clauses, such as <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.CountExpressionNode"/> or <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.DistinctExpressionNode"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeBase">
            <summary>
            Base class for <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> implementations that represent instantiations of <see cref="T:System.Linq.Expressions.MethodCallExpression"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode">
            <summary>
            Interface for classes representing structural parts of an <see cref="T:System.Linq.Expressions.Expression"/> tree.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)">
            <summary>
            Resolves the specified <paramref name="expressionToBeResolved"/> by replacing any occurrence of <paramref name="inputParameter"/>
            by the result of the projection of this <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>. The result is an <see cref="T:System.Linq.Expressions.Expression"/> that goes all the
            way to an <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/>.
            </summary>
            <param name="inputParameter">The parameter representing the input data streaming into an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>. This is replaced
            by the projection data coming out of this <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>.</param>
            <param name="expressionToBeResolved">The expression to be resolved. Any occurrence of <paramref name="inputParameter"/> in this expression
            is replaced.</param>
            <param name="clauseGenerationContext">Context information used during the current parsing process. This structure maps 
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IQuerySourceExpressionNode"/>s  to the clauses created from them. Implementers that also implement 
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IQuerySourceExpressionNode"/> (such as  <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MainSourceExpressionNode"/> or <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectManyExpressionNode"/>) must add 
            their clauses to the mapping in <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Apply(Remotion.Linq.QueryModel,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> if they want to be able to implement <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> correctly.</param>
            <returns>An equivalent of <paramref name="expressionToBeResolved"/> with each occurrence of <paramref name="inputParameter"/> replaced by
            the projection data streaming out of this <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>.</returns>
            <exception cref="T:System.InvalidOperationException">
            This node does not support this operation because it does not stream any data to subsequent nodes.
            </exception>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Apply(Remotion.Linq.QueryModel,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)">
            <summary>
            Applies this <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> to the specified query model. Nodes can add or replace clauses, add or replace expressions, 
            add or replace <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/> objects, or even create a completely new <see cref="T:Remotion.Linq.QueryModel"/>, depending on their semantics.
            </summary>
            <param name="queryModel">The query model this node should be applied to.</param>
            <param name="clauseGenerationContext">Context information used during the current parsing process. This structure maps 
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IQuerySourceExpressionNode"/>s to the clauses created from them. Implementers that 
            also implement <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IQuerySourceExpressionNode"/> (such as 
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MainSourceExpressionNode"/> or <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectManyExpressionNode"/>) must add their clauses to the mapping in 
            <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Apply(Remotion.Linq.QueryModel,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> in order to be able to implement <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> correctly.</param>
            <returns>The modified <paramref name="queryModel"/> or a new <see cref="T:Remotion.Linq.QueryModel"/> that reflects the changes made by this node.</returns>
            <remarks>
            For <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MainSourceExpressionNode"/> objects, which mark the end of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain, this method must not be called.
            Instead, use <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.MainSourceExpressionNode.CreateMainFromClause(Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> to generate a <see cref="T:Remotion.Linq.Clauses.MainFromClause"/> and instantiate a new 
            <see cref="T:Remotion.Linq.QueryModel"/> with that clause.
            </remarks>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Source">
            <summary>
            Gets the source <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> that streams data into this node.
            </summary>
            <value>The source <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>, or <see langword="null"/> if this node is the end of the chain.</value>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.AssociatedIdentifier">
            <summary>
            Gets the identifier associated with this <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>. <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> tries to find the identifier
            that was originally associated with this node in the query written by the user by analyzing the parameter names of the next expression in the 
            method call chain.
            </summary>
            <value>The associated identifier.</value>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeBase.WrapQueryModelAfterEndOfQuery(Remotion.Linq.QueryModel,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)">
            <summary>
            Wraps the <paramref name="queryModel"/> into a subquery after a node that indicates the end of the query (
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ResultOperatorExpressionNodeBase"/> or <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.GroupByExpressionNode"/>). Override this method
            when implementing a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> that does not need a subquery to be created if it occurs after the query end.
            </summary>
            <remarks>
            <para>
            When an ordinary node follows a result operator or group node, it cannot simply append its clauses to the <paramref name="queryModel"/> 
            because semantically, the result operator (or grouping) must be executed _before_ the clause. Therefore, in such scenarios, we wrap 
            the current query model into a <see cref="T:Remotion.Linq.Clauses.Expressions.SubQueryExpression"/> that we put into the <see cref="T:Remotion.Linq.Clauses.MainFromClause"/> of a new 
            <see cref="T:Remotion.Linq.QueryModel"/>.
            </para>
            <para>
            This method also changes the <see cref="P:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeBase.Source"/> of this node because logically, all <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeBase.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> operations must be handled
            by the new <see cref="T:Remotion.Linq.Clauses.MainFromClause"/> holding the <see cref="T:Remotion.Linq.Clauses.Expressions.SubQueryExpression"/>. For example, consider the following call chain:
            <code>
            MainSource (...)
              .Select (x =&gt; x)
              .Distinct ()
              .Select (x =&gt; x)
            </code>
            
            Naively, the last Select node would resolve (via Distinct and Select) to the <see cref="T:Remotion.Linq.Clauses.MainFromClause"/> created by the initial MainSource.
            After this method is executed, however, that <see cref="T:Remotion.Linq.Clauses.MainFromClause"/> is part of the sub query, and a new <see cref="T:Remotion.Linq.Clauses.MainFromClause"/> 
            has been created to hold it. Therefore, we replace the chain as follows:
            <code>
            MainSource (MainSource (...).Select (x =&gt; x).Distinct ())
              .Select (x =&gt; x)
            </code>
            
            Now, the last Select node resolves to the new <see cref="T:Remotion.Linq.Clauses.MainFromClause"/>.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeBase.SetResultTypeOverride(Remotion.Linq.QueryModel)">
            <summary>
            Sets the result type override of the given <see cref="T:Remotion.Linq.QueryModel"/>.
            </summary>
            <param name="queryModel">The query model to set the <see cref="P:Remotion.Linq.QueryModel.ResultTypeOverride"/> of.</param>
            <remarks>
            By default, the result type override is set to <see cref="P:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeBase.NodeResultType"/> in the <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeBase.Apply(Remotion.Linq.QueryModel,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> method. This ensures that the query
            model represents the type of the query correctly. Specific node parsers can override this method to set the 
            <see cref="P:Remotion.Linq.QueryModel.ResultTypeOverride"/> to another value, or to clear it (set it to <see langword="null"/>). Do not leave the
            <see cref="P:Remotion.Linq.QueryModel.ResultTypeOverride"/> unchanged when overriding this method, as a source node might have set it to a value that doesn't 
            fit this node.
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.AggregateFromSeedExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for the 
            <see cref="M:System.Linq.Queryable.Aggregate``2(System.Linq.IQueryable{``0},``1,System.Linq.Expressions.Expression{System.Func{``1,``0,``1}})"/>, <see cref="M:System.Linq.Queryable.Aggregate``3(System.Linq.IQueryable{``0},``1,System.Linq.Expressions.Expression{System.Func{``1,``0,``1}},System.Linq.Expressions.Expression{System.Func{``1,``2}})"/>,
            <see cref="M:System.Linq.Enumerable.Aggregate``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})"/>, and <see cref="M:System.Linq.Enumerable.Aggregate``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},System.Func{``1,``2})"/>
            methods.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.AllExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for the 
            <see cref="M:System.Linq.Queryable.All``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/> and
            <see cref="M:System.Linq.Enumerable.All``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})"/> methods.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.AnyExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for the <see cref="M:System.Linq.Queryable.Any``1(System.Linq.IQueryable{``0})"/>,
            <see cref="M:System.Linq.Queryable.Any``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>,
            <see cref="M:System.Linq.Enumerable.Any``1(System.Collections.Generic.IEnumerable{``0})"/>, and
            <see cref="M:System.Linq.Enumerable.Any``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})"/> methods.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.AsQueryableExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.AsQueryable``1(System.Collections.Generic.IEnumerable{``0})"/> or <see cref="M:System.Linq.Queryable.AsQueryable(System.Collections.IEnumerable)"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it will not modify the <see cref="T:Remotion.Linq.QueryModel"/>, i.e. the call to <see cref="M:System.Linq.Queryable.AsQueryable``1(System.Collections.Generic.IEnumerable{``0})"/> 
            will be removed given how it is transparent to the process of executing the query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.AverageExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for the different overloads of <see cref="M:System.Linq.Queryable.Average(System.Linq.IQueryable{System.Int32})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.CastExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.Cast``1(System.Linq.IQueryable)"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext">
            <summary>
            Encapsulates contextual information used while generating clauses from <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> instances.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ConcatExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.Concat``1(System.Linq.IQueryable{``0},System.Collections.Generic.IEnumerable{``0})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it usually follows (or replaces) a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode"/> of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that 
            represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.QuerySourceSetOperationExpressionNodeBase">
            <summary>
            Acts as a base class for <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.UnionExpressionNode"/> and <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ConcatExpressionNode"/>, i.e., for node parsers for set operations
            acting as an <see cref="T:Remotion.Linq.Clauses.IQuerySource"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IQuerySourceExpressionNode">
            <summary>
            Interface for classes representing query source parts of an <see cref="T:System.Linq.Expressions.Expression"/> tree.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ContainsExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.Contains``1(System.Linq.IQueryable{``0},``0)"/> and
            <see cref="M:System.Linq.Enumerable.Contains``1(System.Collections.Generic.IEnumerable{``0},``0)"/>. 
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.CountExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.Count``1(System.Linq.IQueryable{``0})"/>,
            <see cref="M:System.Linq.Queryable.Count``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>,
            for the Count properties of <see cref="T:System.Collections.Generic.List`1"/>, <see cref="T:System.Collections.ArrayList"/>, <see cref="T:System.Collections.Generic.ICollection`1"/>, 
            and <see cref="T:System.Collections.ICollection"/>, and for the <see cref="P:System.Array.Length"/> property of arrays.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.DefaultIfEmptyExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.DefaultIfEmpty``1(System.Linq.IQueryable{``0})"/> and
            <see cref="M:System.Linq.Queryable.DefaultIfEmpty``1(System.Linq.IQueryable{``0},``0)"/> and 
            <see cref="M:System.Linq.Enumerable.DefaultIfEmpty``1(System.Collections.Generic.IEnumerable{``0})"/> and
            <see cref="M:System.Linq.Enumerable.DefaultIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0)"/>
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it usually follows (or replaces) a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode"/> of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that 
            represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.DistinctExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.Distinct``1(System.Linq.IQueryable{``0})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it usually follows (or replaces) a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode"/> of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that 
            represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ExceptExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.Except``1(System.Linq.IQueryable{``0},System.Collections.Generic.IEnumerable{``0})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it usually follows (or replaces) a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode"/> of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that 
            represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ExpressionNodeInstantiationException">
            <summary>
            Thrown whan an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> parser cannot be instantiated for a query. Note that this <see cref="T:System.Exception"/> is not serializable
            and intended to be caught in the call-site where it will then replaced by a different (serializable) exception.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ExpressionResolver">
            <summary>
            Resolves an expression using <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/>, removing transparent identifiers and detecting subqueries
            in the process. This is used by methods such as <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode.GetResolvedSelector(Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/>, which are
            used when a clause is created from an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.FirstExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.First``1(System.Linq.IQueryable{``0})"/>,
            <see cref="M:System.Linq.Queryable.First``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>,
            <see cref="M:System.Linq.Queryable.FirstOrDefault``1(System.Linq.IQueryable{``0})"/> or
            <see cref="M:System.Linq.Queryable.FirstOrDefault``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.GroupByExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for the different <see cref="M:System.Linq.Queryable.GroupBy``2(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"/> 
            overloads that do not take a result selector. The overloads with a result selector are represented by 
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.GroupByWithResultSelectorExpressionNode"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.GroupByWithResultSelectorExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for the different <see cref="M:System.Linq.Queryable.GroupBy``2(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"/> 
            overloads that do take a result selector. The overloads without a result selector are represented by 
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.GroupByExpressionNode"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            </summary>
            <remarks>
            The GroupBy overloads with result selector are parsed as if they were a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode"/> following a 
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.GroupByExpressionNode"/>:
            <code>
            x.GroupBy (k =&gt; key, e =&gt; element, (k, g) =&gt; result)
            </code>
            is therefore equivalent to:
            <code>
            c.GroupBy (k =&gt; key, e =&gt; element).Select (grouping =&gt; resultSub)
            </code>
            where resultSub is the same as result with k and g substituted with grouping.Key and grouping, respectively.
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.GroupJoinExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.GroupJoin``4(System.Linq.IQueryable{``0},System.Collections.Generic.IEnumerable{``1},System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``1,``2}},System.Linq.Expressions.Expression{System.Func{``0,System.Collections.Generic.IEnumerable{``1},``3}})"/>
            or <see cref="M:System.Linq.Enumerable.GroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,System.Collections.Generic.IEnumerable{``1},``3})"/>
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IntersectExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.Intersect``1(System.Linq.IQueryable{``0},System.Collections.Generic.IEnumerable{``0})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it usually follows (or replaces) a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode"/> of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that 
            represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.JoinExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.Join``4(System.Linq.IQueryable{``0},System.Collections.Generic.IEnumerable{``1},System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``1,``2}},System.Linq.Expressions.Expression{System.Func{``0,``1,``3}})"/>
            or <see cref="M:System.Linq.Enumerable.Join``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``1,``3})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.LastExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.Last``1(System.Linq.IQueryable{``0})"/>,
            <see cref="M:System.Linq.Queryable.Last``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>,
            <see cref="M:System.Linq.Queryable.LastOrDefault``1(System.Linq.IQueryable{``0})"/> or
            <see cref="M:System.Linq.Queryable.LastOrDefault``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.LongCountExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.LongCount``1(System.Linq.IQueryable{``0})"/>,
            <see cref="M:System.Linq.Queryable.LongCount``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>,
            and for the <see cref="P:System.Array.Length"/> property of arrays.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MainSourceExpressionNode">
            <summary>
            Represents the first expression in a LINQ query, which acts as the main query source.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="P:Remotion.Linq.Parsing.Structure.IntermediateModel.MainSourceExpressionNode.ParsedExpression"/> tree is parsed.
            This node usually marks the end (i.e. the first node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MaxExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.Max``1(System.Linq.IQueryable{``0})"/> or <see cref="M:System.Linq.Queryable.Max``2(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeFactory">
            <summary>
            Creates instances of classes implementing the <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> interface via Reflection.
            </summary>
            <remarks>
            The classes implementing <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> instantiated by this factory must implement a single constructor. The source and 
            constructor parameters handed to the <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeFactory.CreateExpressionNode(System.Type,Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionParseInfo,System.Object[])"/> method are passed on to the constructor; for each argument where no 
            parameter is passed, <see langword="null"/> is passed to the constructor.
            </remarks>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeFactory.CreateExpressionNode(System.Type,Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionParseInfo,System.Object[])">
            <summary>
            Creates an instace of type <paramref name="nodeType"/>.
            </summary>
            <exception cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ExpressionNodeInstantiationException">
            Thrown if the <paramref name="parseInfo"/> or the <paramref name="additionalConstructorParameters"/> 
            do not match expected constructor parameters of the <paramref name="nodeType"/>.
            </exception>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionParseInfo">
            <summary>
            Contains metadata about a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> that is parsed into a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionNodeBase"/>.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionParseInfo.AssociatedIdentifier">
            <summary>
            Gets the associated identifier, i.e. the name the user gave the data streaming out of this expression. For example, the 
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectManyExpressionNode"/> corresponding to a <c>from c in C</c> clause should get the identifier "c".
            If there is no user-defined identifier (or the identifier is impossible to infer from the expression tree), a generated identifier
            is given instead.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionParseInfo.Source">
            <summary>
            Gets the source expression node, i.e. the node streaming data into the parsed node.
            </summary>
            <value>The source.</value>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.IntermediateModel.MethodCallExpressionParseInfo.ParsedExpression">
            <summary>
            Gets the <see cref="T:System.Linq.Expressions.MethodCallExpression"/> being parsed.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MinExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.Min``1(System.Linq.IQueryable{``0})"/> or <see cref="M:System.Linq.Queryable.Min``2(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.OfTypeExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.OfType``1(System.Linq.IQueryable)"/> and <see cref="M:System.Linq.Enumerable.OfType``1(System.Collections.IEnumerable)"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.OrderByDescendingExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.OrderByDescending``2(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.OrderByExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.OrderBy``2(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.QuerySourceExpressionNodeUtility">
            <summary>
            Provides common functionality used by implementors of <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IQuerySourceExpressionNode"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.IntermediateModel.QuerySourceExpressionNodeUtility.ReplaceParameterWithReference(Remotion.Linq.Parsing.Structure.IntermediateModel.IQuerySourceExpressionNode,System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)">
            <summary>
            Replaces the given parameter with a back-reference to the <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> corresponding to <paramref name="referencedNode"/>.
            </summary>
            <param name="referencedNode">The referenced node.</param>
            <param name="parameterToReplace">The parameter to replace with a <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/>.</param>
            <param name="expression">The expression in which to replace the parameter.</param>
            <param name="context">The clause generation context.</param>
            <returns><paramref name="expression"/>, with <paramref name="parameterToReplace"/> replaced with a <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/>
            pointing to the clause corresponding to <paramref name="referencedNode"/>.</returns>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.IntermediateModel.QuerySourceExpressionNodeUtility.GetQuerySourceForNode(Remotion.Linq.Parsing.Structure.IntermediateModel.IQuerySourceExpressionNode,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)">
            <summary>
            Gets the <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> corresponding to the given <paramref name="node"/>, throwing an <see cref="T:System.InvalidOperationException"/>
            if no such clause has been registered in the given <paramref name="context"/>.
            </summary>
            <param name="node">The node for which the <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> should be returned.</param>
            <param name="context">The clause generation context.</param>
            <returns>The <see cref="T:Remotion.Linq.Clauses.IQuerySource"/> corresponding to <paramref name="node"/>.</returns>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ResolvedExpressionCache`1">
            <summary>
            Caches a resolved expression in the <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> classes.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ReverseExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.Reverse``1(System.Linq.IQueryable{``0})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it usually follows (or replaces) a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode"/> of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that 
            represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.Select``2(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectManyExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.SelectMany``3(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Collections.Generic.IEnumerable{``1}}},System.Linq.Expressions.Expression{System.Func{``0,``1,``2}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            This node represents an additional query source introduced to the query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SingleExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.Single``1(System.Linq.IQueryable{``0})"/>,
            <see cref="M:System.Linq.Queryable.Single``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>,
            <see cref="M:System.Linq.Queryable.SingleOrDefault``1(System.Linq.IQueryable{``0})"/> or 
            <see cref="M:System.Linq.Queryable.SingleOrDefault``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SkipExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.Skip``1(System.Linq.IQueryable{``0},System.Int32)"/>
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it usually follows (or replaces) a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode"/> of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that 
            represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SumExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for the different overloads of <see cref="O:System.Linq.Queryable.Sum"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it marks the beginning (i.e. the last node) of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.TakeExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for <see cref="M:System.Linq.Queryable.Take``1(System.Linq.IQueryable{``0},System.Int32)"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it usually follows (or replaces) a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode"/> of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that 
            represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ThenByDescendingExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.ThenByDescending``2(System.Linq.IOrderedQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it follows an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.OrderByExpressionNode"/>, an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.OrderByDescendingExpressionNode"/>, 
            a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ThenByExpressionNode"/>, or a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ThenByDescendingExpressionNode"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ThenByExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.ThenBy``2(System.Linq.IOrderedQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it follows an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.OrderByExpressionNode"/>, an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.OrderByDescendingExpressionNode"/>, 
            a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ThenByExpressionNode"/>, or a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.ThenByDescendingExpressionNode"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.UnionExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.Union``1(System.Linq.IQueryable{``0},System.Collections.Generic.IEnumerable{``0})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            When this node is used, it usually follows (or replaces) a <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.SelectExpressionNode"/> of an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain that 
            represents a query.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IntermediateModel.WhereExpressionNode">
            <summary>
            Represents a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> for 
            <see cref="M:System.Linq.Queryable.Where``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"/>.
            It is generated by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when an <see cref="T:System.Linq.Expressions.Expression"/> tree is parsed.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.IQueryParser">
            <summary>
            <see cref="T:Remotion.Linq.Parsing.Structure.IQueryParser"/> is implemented by classes taking an <see cref="T:System.Linq.Expressions.Expression"/> tree and parsing it into a <see cref="T:Remotion.Linq.QueryModel"/>.
            </summary>
            <remarks>
            The default implementation of this interface is <see cref="T:Remotion.Linq.Parsing.Structure.QueryParser"/>. LINQ providers can, however, implement <see cref="T:Remotion.Linq.Parsing.Structure.IQueryParser"/>
            themselves, eg. in order to decorate or replace the functionality of <see cref="T:Remotion.Linq.Parsing.Structure.QueryParser"/>.
            </remarks>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.IQueryParser.GetParsedQuery(System.Linq.Expressions.Expression)">
            <summary>
            Gets the <see cref="T:Remotion.Linq.QueryModel"/> of the given <paramref name="expressionTreeRoot"/>.
            </summary>
            <param name="expressionTreeRoot">The expression tree to parse.</param>
            <returns>A <see cref="T:Remotion.Linq.QueryModel"/> that represents the query defined in <paramref name="expressionTreeRoot"/>.</returns>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.MethodCallExpressionParser">
            <summary>
            Parses a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> and creates an <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> from it. This is used by 
            <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> for parsing whole expression trees.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.CompoundNodeTypeProvider">
            <summary>
            Implements <see cref="T:Remotion.Linq.Parsing.Structure.INodeTypeProvider"/> by storing a list of inner <see cref="T:Remotion.Linq.Parsing.Structure.INodeTypeProvider"/> instances.
            The <see cref="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.CompoundNodeTypeProvider.IsRegistered(System.Reflection.MethodInfo)"/> and <see cref="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.CompoundNodeTypeProvider.GetNodeType(System.Reflection.MethodInfo)"/> methods delegate to these inner instances. This is an
            implementation of the Composite Pattern.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry">
            <summary>
            Maps the <see cref="T:System.Reflection.MethodInfo"/> objects used in <see cref="T:System.Linq.Expressions.MethodCallExpression"/> objects to the respective <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>
            types. This is used by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> is encountered to instantiate the
            right <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> for the given method.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly">
            <summary>
            Creates a <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry"/> and registers all relevant <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> implementations in the <b>Remotion.Linq</b> assembly.
            </summary>
            <returns>
            A <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry"/> with all <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> types in the <b>Remotion.Linq</b> assembly registered.
            </returns>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(System.Reflection.MethodInfo,System.Boolean)">
            <summary>
            Gets the registerable method definition from a given <see cref="T:System.Reflection.MethodInfo"/>. A registerable method is a <see cref="T:System.Reflection.MethodInfo"/> object
            that can be registered via a call to <see cref="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry.Register(System.Collections.Generic.IEnumerable{System.Reflection.MethodInfo},System.Type)"/>. When the given <paramref name="method"/> is passed to 
            <see cref="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry.GetNodeType(System.Reflection.MethodInfo)"/> and its corresponding registerable method was registered, the correct node type is returned.
            </summary>
            <param name="method">The method for which the registerable method should be retrieved. Must not be <see langword="null"/>.</param>
            <param name="throwOnAmbiguousMatch">
              <see langword="true"/> to throw a <see cref="T:System.NotSupportedException"/> if the method cannot be matched to a distinct generic method definition, 
              <see langword="false"/> to return <see langword="null"/> if an unambiguous match is not possible.
            </param>
            <returns>
            <para>
              <paramref name="method"/> itself, unless it is a closed generic method or declared in a closed generic type. In the latter cases,
              the corresponding generic method definition respectively the method declared in a generic type definition is returned.
            </para><para>
              If no generic method definition could be matched and <paramref name="throwOnAmbiguousMatch"/> was set to <see langword="false"/>, 
              <see langword="null"/> is returned.
            </para>
            </returns>
            <exception cref="T:System.NotSupportedException">
            Thrown if <paramref name="throwOnAmbiguousMatch"/> is set to <see langword="true"/> and no distinct generic method definition could be resolved.
            </exception>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry.Register(System.Collections.Generic.IEnumerable{System.Reflection.MethodInfo},System.Type)">
            <summary>
            Registers the specific <paramref name="methods"/> with the given <paramref name="nodeType"/>. The given methods must either be non-generic
            or open generic method definitions. If a method has already been registered before, the later registration overwrites the earlier one.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry.IsRegistered(System.Reflection.MethodInfo)">
            <summary>
            Determines whether the specified method was registered with this <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry.GetNodeType(System.Reflection.MethodInfo)">
            <summary>
            Gets the type of <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> registered with this <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry"/> instance that
            matches the given <paramref name="method"/>, returning <see langword="null"/> if none can be found.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry.RegisteredMethodInfoCount">
            <summary>
            Returns the count of the registered <see cref="T:System.Reflection.MethodInfo"/>s.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodNameBasedNodeTypeRegistry">
            <summary>
            Maps the <see cref="T:System.Reflection.MethodInfo"/> objects used in <see cref="T:System.Linq.Expressions.MethodCallExpression"/> objects to the respective <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>
            types based on the method names and a filter (as defined by <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.NameBasedRegistrationInfo"/>). 
            This is used by <see cref="T:Remotion.Linq.Parsing.Structure.ExpressionTreeParser"/> when a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> is encountered to instantiate the right 
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> for the given method.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly">
            <summary>
            Creates a <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodNameBasedNodeTypeRegistry"/> and registers all relevant <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> implementations in the <b>Remotion.Linq</b> assembly.
            </summary>
            <returns>
            A <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry"/> with all <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> types in the <b>Remotion.Linq</b> assembly registered.
            </returns>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodNameBasedNodeTypeRegistry.Register(System.Collections.Generic.IEnumerable{Remotion.Linq.Parsing.Structure.NodeTypeProviders.NameBasedRegistrationInfo},System.Type)">
            <summary>
            Registers the given <paramref name="nodeType"/> for the query operator methods defined by the given <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.NameBasedRegistrationInfo"/>
            objects.
            </summary>
            <param name="registrationInfo">A sequence of objects defining the methods to register the node type for.</param>
            <param name="nodeType">The type of the <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> to register.</param>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodNameBasedNodeTypeRegistry.IsRegistered(System.Reflection.MethodInfo)">
            <summary>
            Determines whether the specified method was registered with this <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodNameBasedNodeTypeRegistry.GetNodeType(System.Reflection.MethodInfo)">
            <summary>
            Gets the type of <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> registered with this <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodInfoBasedNodeTypeRegistry"/> instance that
            matches the given <paramref name="method"/>, returning <see langword="null"/> if none can be found.
            </summary>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodNameBasedNodeTypeRegistry.RegisteredNamesCount">
            <summary>
            Returns the count of the registered method names.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.NameBasedRegistrationInfo">
            <summary>
            Defines a name and a filter predicate used when determining the matching expression node type by <see cref="T:Remotion.Linq.Parsing.Structure.NodeTypeProviders.MethodNameBasedNodeTypeRegistry"/>.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Parsing.Structure.QueryParser">
            <summary>
            Takes an <see cref="T:System.Linq.Expressions.Expression"/> tree and parses it into a <see cref="T:Remotion.Linq.QueryModel"/> by use of an <see cref="P:Remotion.Linq.Parsing.Structure.QueryParser.ExpressionTreeParser"/>.
            It first transforms the <see cref="T:System.Linq.Expressions.Expression"/> tree into a chain of <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> instances, and then calls 
            <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.MainSourceExpressionNode.CreateMainFromClause(Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> and <see cref="M:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Apply(Remotion.Linq.QueryModel,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)"/> in order to instantiate all the 
            <see cref="T:Remotion.Linq.Clauses.IClause"/>s. With those, a <see cref="T:Remotion.Linq.QueryModel"/> is created and returned.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.QueryParser.CreateDefault">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Parsing.Structure.QueryParser"/> class, using default parameters for parsing. 
            The <see cref="P:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.NodeTypeProvider"/> used has all relevant methods of the <see cref="T:System.Linq.Queryable"/> class 
            automatically registered, and the <see cref="P:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.Processor"/> comprises partial evaluation, and default 
            expression transformations. See <see cref="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.CreateDefaultNodeTypeProvider"/>, 
            <see cref="M:Remotion.Linq.Parsing.Structure.ExpressionTreeParser.CreateDefaultProcessor(Remotion.Linq.Parsing.ExpressionVisitors.Transformation.IExpressionTranformationProvider,Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation.IEvaluatableExpressionFilter)"/>, and <see cref="M:Remotion.Linq.Parsing.ExpressionVisitors.Transformation.ExpressionTransformerRegistry.CreateDefault"/>
            for details.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.QueryParser.#ctor(Remotion.Linq.Parsing.Structure.ExpressionTreeParser)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.Parsing.Structure.QueryParser"/> class, using the given <paramref name="expressionTreeParser"/> to
            convert <see cref="T:System.Linq.Expressions.Expression"/> instances into <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/>s. Use this constructor if you wish to customize the
            parser. To use a default parser (with the possibility to register custom node types), use the <see cref="M:Remotion.Linq.Parsing.Structure.QueryParser.CreateDefault"/> method.
            </summary>
            <param name="expressionTreeParser">The expression tree parser.</param>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.QueryParser.GetParsedQuery(System.Linq.Expressions.Expression)">
            <summary>
            Gets the <see cref="T:Remotion.Linq.QueryModel"/> of the given <paramref name="expressionTreeRoot"/>.
            </summary>
            <param name="expressionTreeRoot">The expression tree to parse.</param>
            <returns>A <see cref="T:Remotion.Linq.QueryModel"/> that represents the query defined in <paramref name="expressionTreeRoot"/>.</returns>
        </member>
        <member name="M:Remotion.Linq.Parsing.Structure.QueryParser.ApplyAllNodes(Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode,Remotion.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)">
            <summary>
            Applies all nodes to a <see cref="T:Remotion.Linq.QueryModel"/>, which is created by the trailing <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MainSourceExpressionNode"/> in the 
            <paramref name="node"/> chain.
            </summary>
            <param name="node">The entry point to the <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain.</param>
            <param name="clauseGenerationContext">The clause generation context collecting context information during the parsing process.</param>
            <returns>A <see cref="T:Remotion.Linq.QueryModel"/> created by the training <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.MainSourceExpressionNode"/> and transformed by each node in the
            <see cref="T:Remotion.Linq.Parsing.Structure.IntermediateModel.IExpressionNode"/> chain.</returns>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.QueryParser.NodeTypeProvider">
            <summary>
            Gets the <see cref="T:Remotion.Linq.Parsing.Structure.INodeTypeProvider"/> used by <see cref="M:Remotion.Linq.Parsing.Structure.QueryParser.GetParsedQuery(System.Linq.Expressions.Expression)"/> to parse <see cref="T:System.Linq.Expressions.MethodCallExpression"/> instances.
            </summary>
            <value>The node type registry.</value>
        </member>
        <member name="P:Remotion.Linq.Parsing.Structure.QueryParser.Processor">
            <summary>
            Gets the <see cref="T:Remotion.Linq.Parsing.Structure.IExpressionTreeProcessor"/> used by <see cref="M:Remotion.Linq.Parsing.Structure.QueryParser.GetParsedQuery(System.Linq.Expressions.Expression)"/> to process the <see cref="T:System.Linq.Expressions.Expression"/> tree 
            before analyzing its structure.
            </summary>
            <value>The processor.</value>
        </member>
        <member name="T:Remotion.Linq.Parsing.ThrowingExpressionVisitor">
            <summary>
            Implements an <see cref="T:Remotion.Linq.Parsing.RelinqExpressionVisitor"/> that throws an exception for every expression type that is not explicitly supported.
            Inherit from this class to ensure that an exception is thrown when an expression is passed 
            </summary>
        </member>
        <member name="M:Remotion.Linq.Parsing.ThrowingExpressionVisitor.VisitUnhandledItem``2(``0,System.String,System.Func{``0,``1})">
            <summary>
            Called when an unhandled item is visited. This method provides the item the visitor cannot handle (<paramref name="unhandledItem"/>), 
            the <paramref name="visitMethod"/> that is not implemented in the visitor, and a delegate that can be used to invoke the 
            <paramref name="baseBehavior"/> of the <see cref="T:Remotion.Linq.Parsing.RelinqExpressionVisitor"/> class. The default behavior of this method is to call the
            <see cref="M:Remotion.Linq.Parsing.ThrowingExpressionVisitor.CreateUnhandledItemException``1(``0,System.String)"/> method, but it can be overridden to do something else.
            </summary>
            <typeparam name="TItem">The type of the item that could not be handled. Either an <see cref="T:System.Linq.Expressions.Expression"/> type, a <see cref="T:System.Linq.Expressions.MemberBinding"/> 
            type, or <see cref="T:System.Linq.Expressions.ElementInit"/>.</typeparam>
            <typeparam name="TResult">The result type expected for the visited <paramref name="unhandledItem"/>.</typeparam>
            <param name="unhandledItem">The unhandled item.</param>
            <param name="visitMethod">The visit method that is not implemented.</param>
            <param name="baseBehavior">The behavior exposed by <see cref="T:Remotion.Linq.Parsing.RelinqExpressionVisitor"/> for this item type.</param>
            <returns>An object to replace <paramref name="unhandledItem"/> in the expression tree. Alternatively, the method can throw any exception.</returns>
        </member>
        <member name="T:Remotion.Linq.Parsing.TupleExpressionBuilder">
            <summary>
            <see cref="T:Remotion.Linq.Parsing.TupleExpressionBuilder"/> can be used to build tuples incorporating a sequence of <see cref="T:System.Linq.Expressions.Expression"/>s. 
            For example, given three expressions, exp1, exp2, and exp3, it will build nested <see cref="T:System.Linq.Expressions.NewExpression"/>s that are equivalent to the 
            following: new KeyValuePair(exp1, new KeyValuePair(exp2, exp3)).
            Given an <see cref="T:System.Linq.Expressions.Expression"/> whose type matches that of a tuple built by <see cref="T:Remotion.Linq.Parsing.TupleExpressionBuilder"/>, the builder can also return 
            an enumeration of accessor expressions that can be used to access the tuple elements in the same order as they were put into the nested tuple 
            expression. In above example, this would yield tupleExpression.Key, tupleExpression.Value.Key, and tupleExpression.Value.Value.
            This class can be handy whenever a set of <see cref="T:System.Linq.Expressions.Expression"/> needs to be put into a single <see cref="T:System.Linq.Expressions.Expression"/> 
            (eg., a select projection), especially if each sub-expression needs to be explicitly accessed at a later point of time (eg., to retrieve the 
            items from a statement surrounding a sub-statement yielding the tuple in its select projection).
            </summary>
        </member>
        <member name="T:Remotion.Linq.QueryableBase`1">
            <summary>
            Acts as a common base class for <see cref="T:System.Linq.IQueryable`1"/> implementations based on re-linq. In a specific LINQ provider, a custom queryable
            class should be derived from <see cref="T:Remotion.Linq.QueryableBase`1"/> which supplies an implementation of <see cref="T:Remotion.Linq.IQueryExecutor"/> that is used to 
            execute the query. This is then used as an entry point (the main data source) of a LINQ query.
            </summary>
            <typeparam name="T">The type of the result items yielded by this query.</typeparam>
        </member>
        <member name="M:Remotion.Linq.QueryableBase`1.#ctor(Remotion.Linq.Parsing.Structure.IQueryParser,Remotion.Linq.IQueryExecutor)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.QueryableBase`1"/> class with a <see cref="T:Remotion.Linq.DefaultQueryProvider"/> and the given
            <paramref name="executor"/>. This constructor should be used by subclasses to begin a new query. The <see cref="P:Remotion.Linq.QueryableBase`1.Expression"/> generated by
            this constructor is a <see cref="T:System.Linq.Expressions.ConstantExpression"/> pointing back to this <see cref="T:Remotion.Linq.QueryableBase`1"/>.
            </summary>
            <param name="queryParser">The <see cref="T:Remotion.Linq.Parsing.Structure.IQueryParser"/> used to parse queries. Specify an instance of 
              <see cref="T:Remotion.Linq.Parsing.Structure.QueryParser"/> for default behavior. See also <see cref="M:Remotion.Linq.Parsing.Structure.QueryParser.CreateDefault"/>.</param>
            <param name="executor">The <see cref="T:Remotion.Linq.IQueryExecutor"/> used to execute the query represented by this <see cref="T:Remotion.Linq.QueryableBase`1"/>.</param>
        </member>
        <member name="M:Remotion.Linq.QueryableBase`1.#ctor(System.Linq.IQueryProvider)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.QueryableBase`1"/> class with a specific <see cref="T:System.Linq.IQueryProvider"/>. This constructor
            should only be used to begin a query when <see cref="T:Remotion.Linq.DefaultQueryProvider"/> does not fit the requirements.
            </summary>
            <param name="provider">The provider used to execute the query represented by this <see cref="T:Remotion.Linq.QueryableBase`1"/> and to construct
            queries around this <see cref="T:Remotion.Linq.QueryableBase`1"/>.</param>
        </member>
        <member name="M:Remotion.Linq.QueryableBase`1.#ctor(System.Linq.IQueryProvider,System.Linq.Expressions.Expression)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Linq.QueryableBase`1"/> class with a given <paramref name="provider"/> and 
            <paramref name="expression"/>. This is an infrastructure constructor that must be exposed on subclasses because it is used by 
            <see cref="T:Remotion.Linq.DefaultQueryProvider"/> to construct queries around this <see cref="T:Remotion.Linq.QueryableBase`1"/> when a query method (e.g. of the
            <see cref="T:System.Linq.Queryable"/> class) is called.
            </summary>
            <param name="provider">The provider used to execute the query represented by this <see cref="T:Remotion.Linq.QueryableBase`1"/> and to construct
            queries around this <see cref="T:Remotion.Linq.QueryableBase`1"/>.</param>
            <param name="expression">The expression representing the query.</param>
        </member>
        <member name="M:Remotion.Linq.QueryableBase`1.GetEnumerator">
            <summary>
            Executes the query via the <see cref="P:Remotion.Linq.QueryableBase`1.Provider"/> and returns an enumerator that iterates through the items returned by the query.
            </summary>
            <returns>
            A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the query result.
            </returns>
        </member>
        <member name="P:Remotion.Linq.QueryableBase`1.Expression">
            <summary>
            Gets the expression tree that is associated with the instance of <see cref="T:System.Linq.IQueryable"/>. This expression describes the
            query represented by this <see cref="T:Remotion.Linq.QueryableBase`1"/>.
            </summary>
            <value></value>
            <returns>
            The <see cref="T:System.Linq.Expressions.Expression"/> that is associated with this instance of <see cref="T:System.Linq.IQueryable"/>.
            </returns>
        </member>
        <member name="P:Remotion.Linq.QueryableBase`1.Provider">
            <summary>
            Gets the query provider that is associated with this data source. The provider is used to execute the query. By default, a 
            <see cref="T:Remotion.Linq.DefaultQueryProvider"/> is used that parses the query and passes it on to an implementation of <see cref="T:Remotion.Linq.IQueryExecutor"/>.
            </summary>
            <value></value>
            <returns>
            The <see cref="T:System.Linq.IQueryProvider"/> that is associated with this data source.
            </returns>
        </member>
        <member name="P:Remotion.Linq.QueryableBase`1.ElementType">
            <summary>
            Gets the type of the element(s) that are returned when the expression tree associated with this instance of <see cref="T:System.Linq.IQueryable"/> is executed.
            </summary>
            <value></value>
            <returns>
            A <see cref="T:System.Type"/> that represents the type of the element(s) that are returned when the expression tree associated with this object is executed.
            </returns>
        </member>
        <member name="T:Remotion.Linq.QueryModel">
            <summary>
            Provides an abstraction of an expression tree created for a LINQ query. <see cref="T:Remotion.Linq.QueryModel"/> instances are passed to LINQ providers based
            on re-linq via <see cref="T:Remotion.Linq.IQueryExecutor"/>, but you can also use <see cref="T:Remotion.Linq.Parsing.Structure.QueryParser"/> to parse an expression tree by hand or construct
            a <see cref="T:Remotion.Linq.QueryModel"/> manually via its constructor.
            </summary>
            <remarks>
            The different parts of the query are mapped to clauses, see <see cref="P:Remotion.Linq.QueryModel.MainFromClause"/>, <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/>, and 
            <see cref="P:Remotion.Linq.QueryModel.SelectClause"/>. The simplest way to process all the clauses belonging to a <see cref="T:Remotion.Linq.QueryModel"/> is by implementing
            <see cref="T:Remotion.Linq.IQueryModelVisitor"/> (or deriving from <see cref="T:Remotion.Linq.QueryModelVisitorBase"/>) and calling <see cref="M:Remotion.Linq.QueryModel.Accept(Remotion.Linq.IQueryModelVisitor)"/>.
            </remarks>
        </member>
        <member name="M:Remotion.Linq.QueryModel.#ctor(Remotion.Linq.Clauses.MainFromClause,Remotion.Linq.Clauses.SelectClause)">
            <summary>
            Initializes a new instance of <see cref="T:Remotion.Linq.QueryModel"/>
            </summary>
            <param name="mainFromClause">The <see cref="T:Remotion.Linq.Clauses.MainFromClause"/> of the query. This is the starting point of the query, generating items 
            that are filtered and projected by the query.</param>
            <param name="selectClause">The <see cref="P:Remotion.Linq.QueryModel.SelectClause"/> of the query. This is the end point of
            the query, it defines what is actually returned for each of the items coming from the <see cref="P:Remotion.Linq.QueryModel.MainFromClause"/> and passing the 
            <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/>. After it, only the <see cref="P:Remotion.Linq.QueryModel.ResultOperators"/> modify the result of the query.</param>
        </member>
        <member name="M:Remotion.Linq.QueryModel.GetOutputDataInfo">
            <summary>
            Gets an <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/> object describing the data streaming out of this <see cref="T:Remotion.Linq.QueryModel"/>. If a query ends with
            the <see cref="P:Remotion.Linq.QueryModel.SelectClause"/>, this corresponds to <see cref="M:Remotion.Linq.Clauses.SelectClause.GetOutputDataInfo"/>. If a query has 
            <see cref="P:Remotion.Linq.QueryModel.ResultOperators"/>, the data is further modified by those operators.
            </summary>
            <returns>Gets a <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/> object describing the data streaming out of this <see cref="T:Remotion.Linq.QueryModel"/>.</returns>
            <remarks>
            The data streamed from a <see cref="T:Remotion.Linq.QueryModel"/> is often of type <see cref="T:System.Linq.IQueryable`1"/> instantiated
            with a specific item type, unless the
            query ends with a <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/>. For example, if the query ends with a <see cref="T:Remotion.Linq.Clauses.ResultOperators.CountResultOperator"/>, the
            result type will be <see cref="T:System.Int32"/>.
            </remarks>
            <exception cref="T:System.InvalidOperationException">
            The <see cref="P:Remotion.Linq.QueryModel.ResultTypeOverride"/> is not compatible with the calculated <see cref="T:Remotion.Linq.Clauses.StreamedData.IStreamedDataInfo"/> calculated from the <see cref="P:Remotion.Linq.QueryModel.ResultOperators"/>.
            </exception>
        </member>
        <member name="M:Remotion.Linq.QueryModel.GetUniqueIdentfierGenerator">
            <summary>
            Gets the <see cref="T:Remotion.Linq.UniqueIdentifierGenerator"/> which is used by the <see cref="T:Remotion.Linq.QueryModel"/>.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Remotion.Linq.QueryModel.Accept(Remotion.Linq.IQueryModelVisitor)">
            <summary>
            Accepts an implementation of <see cref="T:Remotion.Linq.IQueryModelVisitor"/> or <see cref="T:Remotion.Linq.QueryModelVisitorBase"/>, as defined by the Visitor pattern.
            </summary>
        </member>
        <member name="M:Remotion.Linq.QueryModel.ToString">
            <summary>
            Returns a <see cref="T:System.String"/> representation of this <see cref="T:Remotion.Linq.QueryModel"/>.
            </summary>
        </member>
        <member name="M:Remotion.Linq.QueryModel.Clone">
            <summary>
            Clones this <see cref="T:Remotion.Linq.QueryModel"/>, returning a new <see cref="T:Remotion.Linq.QueryModel"/> equivalent to this instance, but with its clauses being
            clones of this instance's clauses. Any <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> in the cloned clauses that points back to another clause 
            in this <see cref="T:Remotion.Linq.QueryModel"/> (including its subqueries) is adjusted to point to the respective clones in the cloned 
            <see cref="T:Remotion.Linq.QueryModel"/>. Any subquery nested in the <see cref="T:Remotion.Linq.QueryModel"/> is also cloned.
            </summary>
        </member>
        <member name="M:Remotion.Linq.QueryModel.Clone(Remotion.Linq.Clauses.QuerySourceMapping)">
            <summary>
            Clones this <see cref="T:Remotion.Linq.QueryModel"/>, returning a new <see cref="T:Remotion.Linq.QueryModel"/> equivalent to this instance, but with its clauses being
            clones of this instance's clauses. Any <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> in the cloned clauses that points back to another clause 
            in  this <see cref="T:Remotion.Linq.QueryModel"/> (including its subqueries) is adjusted to point to the respective clones in the cloned 
            <see cref="T:Remotion.Linq.QueryModel"/>. Any subquery nested in the <see cref="T:Remotion.Linq.QueryModel"/> is also cloned.
            </summary>
            <param name="querySourceMapping">The <see cref="T:Remotion.Linq.Clauses.QuerySourceMapping"/> defining how to adjust instances of 
            <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/> in the cloned <see cref="T:Remotion.Linq.QueryModel"/>. If there is a <see cref="T:Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression"/>
            that points out of the <see cref="T:Remotion.Linq.QueryModel"/> being cloned, specify its replacement via this parameter. At the end of the cloning process,
            this object maps all the clauses in this original <see cref="T:Remotion.Linq.QueryModel"/> to the clones created in the process.
            </param>
        </member>
        <member name="M:Remotion.Linq.QueryModel.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
            <summary>
            Transforms all the expressions in this <see cref="T:Remotion.Linq.QueryModel"/>'s clauses via the given <paramref name="transformation"/> delegate.
            </summary>
            <param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression"/> within this 
            <see cref="T:Remotion.Linq.QueryModel"/>, and those expressions will be replaced with what the delegate returns.</param>
        </member>
        <member name="M:Remotion.Linq.QueryModel.GetNewName(System.String)">
            <summary>
            Returns a new name with the given prefix. The name is different from that of any <see cref="T:Remotion.Linq.Clauses.FromClauseBase"/> added
            in the <see cref="T:Remotion.Linq.QueryModel"/>. Note that clause names that are changed after the clause is added as well as names of other clauses
            than from clauses are not considered when determining "unique" names. Use names only for readability and debugging, not
            for uniquely identifying clauses.
            </summary>
        </member>
        <member name="M:Remotion.Linq.QueryModel.Execute(Remotion.Linq.IQueryExecutor)">
            <summary>
            Executes this <see cref="T:Remotion.Linq.QueryModel"/> via the given <see cref="T:Remotion.Linq.IQueryExecutor"/>. By default, this indirectly calls 
            <see cref="M:Remotion.Linq.IQueryExecutor.ExecuteCollection``1(Remotion.Linq.QueryModel)"/>, but this can be modified by the <see cref="P:Remotion.Linq.QueryModel.ResultOperators"/>.
            </summary>
            <param name="executor">The <see cref="T:Remotion.Linq.IQueryExecutor"/> to use for executing this query.</param>
        </member>
        <member name="M:Remotion.Linq.QueryModel.IsIdentityQuery">
            <summary>
            Determines whether this <see cref="T:Remotion.Linq.QueryModel"/> represents an identity query. An identity query is a query without any body clauses
            whose <see cref="P:Remotion.Linq.QueryModel.SelectClause"/> selects exactly the items produced by its <see cref="P:Remotion.Linq.QueryModel.MainFromClause"/>. An identity query can have
            <see cref="P:Remotion.Linq.QueryModel.ResultOperators"/>.
            </summary>
            <returns>
            	<see langword="true"/> if this <see cref="T:Remotion.Linq.QueryModel"/> represents an identity query; otherwise, <see langword="false"/>.
            </returns>
            <example>
            An example for an identity query is the subquery in that is produced for the <see cref="P:Remotion.Linq.Clauses.SelectClause.Selector"/> in the following 
            query:
            <code>
            from order in ...
            select order.OrderItems.Count()
            </code>
            In this query, the <see cref="P:Remotion.Linq.Clauses.SelectClause.Selector"/> will become a <see cref="T:Remotion.Linq.Clauses.Expressions.SubQueryExpression"/> because 
            <see cref="M:System.Linq.Enumerable.Count``1(System.Collections.Generic.IEnumerable{``0})"/> is treated as a query operator. The 
            <see cref="T:Remotion.Linq.QueryModel"/> in that <see cref="T:Remotion.Linq.Clauses.Expressions.SubQueryExpression"/> has no <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> and a trivial <see cref="P:Remotion.Linq.QueryModel.SelectClause"/>,
            so its <see cref="M:Remotion.Linq.QueryModel.IsIdentityQuery"/> method returns <see langword="true"/>. The outer <see cref="T:Remotion.Linq.QueryModel"/>, on the other hand, does not
            have a trivial <see cref="P:Remotion.Linq.QueryModel.SelectClause"/>, so its <see cref="M:Remotion.Linq.QueryModel.IsIdentityQuery"/> method returns <see langword="false"/>.
            </example>
        </member>
        <member name="M:Remotion.Linq.QueryModel.ConvertToSubQuery(System.String)">
            <summary>
            Creates a new <see cref="T:Remotion.Linq.QueryModel"/> that has this <see cref="T:Remotion.Linq.QueryModel"/> as a sub-query in its <see cref="P:Remotion.Linq.QueryModel.MainFromClause"/>.
            </summary>
            <param name="itemName">The name of the new <see cref="T:Remotion.Linq.QueryModel"/>'s <see cref="P:Remotion.Linq.Clauses.FromClauseBase.ItemName"/>.</param>
            <returns>A new <see cref="T:Remotion.Linq.QueryModel"/> whose <see cref="P:Remotion.Linq.QueryModel.MainFromClause"/>'s <see cref="P:Remotion.Linq.Clauses.FromClauseBase.FromExpression"/> is a 
            <see cref="T:Remotion.Linq.Clauses.Expressions.SubQueryExpression"/> that holds this <see cref="T:Remotion.Linq.QueryModel"/> instance.</returns>
        </member>
        <member name="P:Remotion.Linq.QueryModel.MainFromClause">
            <summary>
            Gets or sets the query's <see cref="T:Remotion.Linq.Clauses.MainFromClause"/>. This is the starting point of the query, generating items that are processed by 
            the <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> and projected or grouped by the <see cref="P:Remotion.Linq.QueryModel.SelectClause"/>.
            </summary>
        </member>
        <member name="P:Remotion.Linq.QueryModel.SelectClause">
            <summary>
            Gets or sets the query's select clause. This is the end point of the query, it defines what is actually returned for each of the 
            items coming from the <see cref="P:Remotion.Linq.QueryModel.MainFromClause"/> and passing the <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/>. After it, only the <see cref="P:Remotion.Linq.QueryModel.ResultOperators"/>
            modify the result of the query.
            </summary>
        </member>
        <member name="P:Remotion.Linq.QueryModel.BodyClauses">
            <summary>
            Gets a collection representing the query's body clauses. Body clauses take the items generated by the <see cref="P:Remotion.Linq.QueryModel.MainFromClause"/>,
            filtering (<see cref="T:Remotion.Linq.Clauses.WhereClause"/>), ordering (<see cref="T:Remotion.Linq.Clauses.OrderByClause"/>), augmenting (<see cref="T:Remotion.Linq.Clauses.AdditionalFromClause"/>), or otherwise
            processing them before they are passed to the <see cref="P:Remotion.Linq.QueryModel.SelectClause"/>.
            </summary>
        </member>
        <member name="P:Remotion.Linq.QueryModel.ResultOperators">
            <summary>
            Gets the result operators attached to this <see cref="P:Remotion.Linq.QueryModel.SelectClause"/>. Result operators modify the query's result set, aggregating,
            filtering, or otherwise processing the result before it is returned.
            </summary>
        </member>
        <member name="T:Remotion.Linq.QueryModelBuilder">
            <summary>
            Collects clauses and creates a <see cref="T:Remotion.Linq.QueryModel"/> from them. This provides a simple way to first add all the clauses and then
            create the <see cref="T:Remotion.Linq.QueryModel"/> rather than the two-step approach (first <see cref="P:Remotion.Linq.QueryModelBuilder.SelectClause"/> and <see cref="P:Remotion.Linq.QueryModelBuilder.MainFromClause"/>,
            then the <see cref="T:Remotion.Linq.Clauses.IBodyClause"/>s) required by <see cref="T:Remotion.Linq.QueryModel"/>'s constructor.
            </summary>
        </member>
        <member name="T:Remotion.Linq.QueryModelVisitorBase">
            <summary>
            Provides a default implementation of <see cref="T:Remotion.Linq.IQueryModelVisitor"/> which automatically visits child items. That is, the default 
            implementation of <see cref="M:Remotion.Linq.QueryModelVisitorBase.VisitQueryModel(Remotion.Linq.QueryModel)"/> automatically calls <c>Accept</c> on all clauses in the <see cref="T:Remotion.Linq.QueryModel"/>
            and the default implementation of <see cref="M:Remotion.Linq.QueryModelVisitorBase.VisitOrderByClause(Remotion.Linq.Clauses.OrderByClause,Remotion.Linq.QueryModel,System.Int32)"/> automatically calls <see cref="M:Remotion.Linq.Clauses.Ordering.Accept(Remotion.Linq.IQueryModelVisitor,Remotion.Linq.QueryModel,Remotion.Linq.Clauses.OrderByClause,System.Int32)"/> on the 
            <see cref="T:Remotion.Linq.Clauses.Ordering"/> instances in its <see cref="P:Remotion.Linq.Clauses.OrderByClause.Orderings"/> collection, and so on.
            </summary>
            <remarks>
            This visitor is hardened against modifications performed on the visited <see cref="T:Remotion.Linq.QueryModel"/> while the model is currently being visited.
            That is, if a the <see cref="P:Remotion.Linq.QueryModel.BodyClauses"/> collection changes while a body clause (or a child item of a body clause) is currently 
            being processed, the visitor will handle that gracefully. The same applies to <see cref="P:Remotion.Linq.QueryModel.ResultOperators"/> and
            <see cref="P:Remotion.Linq.Clauses.OrderByClause.Orderings"/>.
            </remarks>
        </member>
        <member name="T:Remotion.Linq.Transformations.SubQueryFromClauseFlattener">
            <summary>
            Takes a <see cref="T:Remotion.Linq.QueryModel"/> and transforms it by replacing its <see cref="T:Remotion.Linq.Clauses.FromClauseBase"/> instances (<see cref="T:Remotion.Linq.Clauses.MainFromClause"/> and
            <see cref="T:Remotion.Linq.Clauses.AdditionalFromClause"/>) that contain subqueries with equivalent flattened clauses. Subqueries that contain a 
            <see cref="T:Remotion.Linq.Clauses.ResultOperatorBase"/> (such as <see cref="T:Remotion.Linq.Clauses.ResultOperators.DistinctResultOperator"/> or <see cref="T:Remotion.Linq.Clauses.ResultOperators.TakeResultOperator"/>) cannot be
            flattened.
            </summary>
            <example>
            As an example, take the following query:
            <code>
            from c in Customers
            from o in (from oi in OrderInfos where oi.Customer == c orderby oi.OrderDate select oi.Order)
            orderby o.Product.Name
            select new { c, o }
            </code>
            This will be transformed into:
            <code>
            from c in Customers
            from oi in OrderInfos
            where oi.Customer == c
            orderby oi.OrderDate
            orderby oi.Order.Product.Name
            select new { c, oi.Order }
            </code>
            As another example, take the following query:
            <code>
            from c in (from o in Orders select o.Customer)
            where c.Name.StartsWith ("Miller")
            select c
            </code>
            (This query is never produced by the <see cref="T:Remotion.Linq.Parsing.Structure.QueryParser"/>, the only way to construct it is via manually building a 
            <see cref="T:Remotion.Linq.Clauses.MainFromClause"/>.)
            This will be transforemd into:
            <code>
            from o in Orders
            where o.Customer.Name.StartsWith ("Miller")
            select o
            </code>
            </example>
        </member>
        <member name="T:Remotion.Linq.UniqueIdentifierGenerator">
            <summary>
            Generates unique identifiers based on a set of known identifiers.
            An identifier is generated by appending a number to a given prefix. The identifier is considered unique when no known identifier
            exists which equals the prefix/number combination.
            </summary>
        </member>
        <member name="M:Remotion.Linq.UniqueIdentifierGenerator.AddKnownIdentifier(System.String)">
            <summary>
            Adds the given <paramref name="identifier"/> to the set of known identifiers.
            </summary>
            <param name="identifier">The identifier to add.</param>
        </member>
        <member name="M:Remotion.Linq.UniqueIdentifierGenerator.GetUniqueIdentifier(System.String)">
            <summary>
            Gets a unique identifier starting with the given <paramref name="prefix"/>. The identifier is generating by appending a number to the
            prefix so that the resulting string does not match a known identifier.
            </summary>
            <param name="prefix">The prefix to use for the identifier.</param>
            <returns>A unique identifier starting with <paramref name="prefix"/>.</returns>
        </member>
        <member name="T:Remotion.Linq.Utilities.ExpressionExtensions">
            <summary>
            Provides extensions for working with <see cref="T:System.Linq.Expressions.Expression"/> trees.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Utilities.ExpressionExtensions.BuildString(System.Linq.Expressions.Expression)">
            <summary>
            Builds a string from the <paramref name="expression"/> tree, including .NET 3.5.
            </summary>
        </member>
        <member name="T:Remotion.Linq.Utilities.ItemTypeReflectionUtility">
            <summary>
            Provider a utility API for dealing with the item type of generic collections.
            </summary>
        </member>
        <member name="M:Remotion.Linq.Utilities.ItemTypeReflectionUtility.TryGetItemTypeOfClosedGenericIEnumerable(System.Type,System.Type@)">
            <summary>
            Tries to extract the item type from the input <see cref="T:System.Type"/>.
            </summary>
            <param name="possibleEnumerableType">
            The <see cref="T:System.Type"/> that might be an implementation of the <see cref="T:System.Collections.Generic.IEnumerable`1"/> interface. Must not be <see langword="null"/>.
            </param>
            <param name="itemType">An output parameter containing the extracted item <see cref="T:System.Type"/> or <see langword="null"/>.</param>
            <returns><see langword="true"/> if an <paramref name="itemType"/> could be extracted, otherwise <see langword="false"/>.</returns>
        </member>
    </members>
</doc>