ScanQueryOperator.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Core / System / Linq / Parallel / QueryOperators / ScanQueryOperator.cs / 1305376 / ScanQueryOperator.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
// 
// ScanQueryOperator.cs 
//
// [....] 
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

using System.Collections.Generic; 
using System.Diagnostics.Contracts;
using System.Threading; 
 
namespace System.Linq.Parallel
{ 
    /// 
    /// A scan is just a simple operator that is positioned directly on top of some
    /// real data source. It's really just a place holder used during execution and
    /// analysis -- it should never actually get opened. 
    /// 
    ///  
    internal sealed class ScanQueryOperator : QueryOperator 
    {
 
        private readonly IEnumerable m_data; // The actual data source to scan.

        //------------------------------------------------------------------------------------
        // Constructs a new scan on top of the target data source. 
        //
 
        internal ScanQueryOperator(IEnumerable data) 
            : base(Scheduling.DefaultPreserveOrder, QuerySettings.Empty)
        { 
            Contract.Assert(data != null);

            ParallelEnumerableWrapper wrapper = data as ParallelEnumerableWrapper;
            if (wrapper != null) 
            {
                data = wrapper.WrappedEnumerable; 
            } 

            m_data = data; 
        }

        //-----------------------------------------------------------------------------------
        // Accesses the underlying data source. 
        //
 
        public IEnumerable Data 
        {
            get { return m_data; } 
        }

        //-----------------------------------------------------------------------------------
        // Override of the query operator base class's Open method. It creates a partitioned 
        // stream that reads scans the data source.
        // 
 
        internal override QueryResults Open(QuerySettings settings, bool preferStriping)
        { 
            Contract.Assert(settings.DegreeOfParallelism.HasValue);

            IList dataAsList = m_data as IList;
            if (dataAsList != null) 
            {
                return new ListQueryResults(dataAsList, settings.DegreeOfParallelism.GetValueOrDefault(), preferStriping); 
            } 
            else
            { 
                return new ScanEnumerableQueryOperatorResults(m_data, settings);
            }
        }
 

        //----------------------------------------------------------------------------------- 
        // IEnumerable data source represented as QueryResults. Typically, we would not 
        // use ScanEnumerableQueryOperatorResults if the data source implements IList.
        // 

        internal override IEnumerator GetEnumerator(ParallelMergeOptions? mergeOptions, bool suppressOrderPreservation)
        {
            return m_data.GetEnumerator(); 
        }
 
 
        //----------------------------------------------------------------------------------------
        // Returns an enumerable that represents the query executing sequentially. 
        //

        internal override IEnumerable AsSequentialQuery(CancellationToken token)
        { 
            return m_data;
        } 
 
        //---------------------------------------------------------------------------------------
        // The state of the order index of the results returned by this operator. 
        //

        internal override OrdinalIndexState OrdinalIndexState
        { 
            get
            { 
                return m_data is IList 
                    ? OrdinalIndexState.Indexible
                    : OrdinalIndexState.Correct; 
            }
        }

 
        //----------------------------------------------------------------------------------------
        // Whether this operator performs a premature merge. 
        // 

        internal override bool LimitsParallelism 
        {
            get { return false; }
        }
 
        private class ScanEnumerableQueryOperatorResults : QueryResults
        { 
            private IEnumerable m_data; // The data source for the query 

            private QuerySettings m_settings; // Settings collected from the query 

            internal ScanEnumerableQueryOperatorResults(IEnumerable data, QuerySettings settings)
            {
                m_data = data; 
                m_settings = settings;
            } 
 
            internal override void GivePartitionedStream(IPartitionedStreamRecipient recipient)
            { 
                // Since we are not using m_data as an IList, we can pass useStriping = false.
                PartitionedStream partitionedStream = ExchangeUtilities.PartitionDataSource(
                    m_data, m_settings.DegreeOfParallelism.Value, false);
                recipient.Receive(partitionedStream); 
            }
        } 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK