//--------------------------------------------------------------------------------------- // Returns a QueryOperator<T> for any IEnumerable<T> data source. This will just do a // cast and return a reference to the same data source if the source is another query // operator, but will lazily allocate a scan operation and return that otherwise. // // Arguments: // source - any enumerable data source to be wrapped // // Return Value: // A query operator. // internal static QueryOperator <TOutput> AsQueryOperator(IEnumerable <TOutput> source) { Contract.Assert(source != null); // Just try casting the data source to a query operator, in the case that // our child is just another query operator. QueryOperator <TOutput> sourceAsOperator = source as QueryOperator <TOutput>; if (sourceAsOperator == null) { OrderedParallelQuery <TOutput> orderedQuery = source as OrderedParallelQuery <TOutput>; if (orderedQuery != null) { // We have to handle OrderedParallelQuery<T> specially. In all other cases, // ParallelQuery *is* the QueryOperator<T>. But, OrderedParallelQuery<T> // is not QueryOperator<T>, it only has a reference to one. Ideally, we // would want SortQueryOperator<T> to inherit from OrderedParallelQuery<T>, // but that conflicts with other constraints on our class hierarchy. sourceAsOperator = (QueryOperator <TOutput>)orderedQuery.SortOperator; } else { // If the cast failed, then the data source is a real piece of data. We // just construct a new scan operator on top of it. sourceAsOperator = new ScanQueryOperator <TOutput>(source); } } Contract.Assert(sourceAsOperator != null); return(sourceAsOperator); }
internal override IEnumerator <TSource> GetEnumerator(ParallelMergeOptions?mergeOptions, bool suppressOrderPreservation) { ScanQueryOperator <TSource> childAsScan = m_child as ScanQueryOperator <TSource>; if (childAsScan != null) { return(childAsScan.Data.GetEnumerator()); } return(base.GetEnumerator(mergeOptions, suppressOrderPreservation)); }