C# IObservable.ToPointStream方法代码示例

        /// <summary>
        /// Produces output whenever the processor utilization exceeds a threshold consistently over some duration. Both the threshold
        /// and duration are configurable in real-time via the UI.
        /// </summary>
        /// <param name="application">Application hosting the query.</param>
        /// <param name="configurationSource">Real-time configuration data from UI.</param>
        /// <returns>IObservable event sink for the StreamInsight query.</returns>
        public static dynamic ProcessorUtilizationSustainedThreshold(
            Application application,
            IObservable<ThresholdConfiguration> configurationSource)
        {
            const string dataStreamName = "dataStream";

            var dataStream = InputData.CreateProcessorTimeInput(application, streamName: dataStreamName);

            // first, smooth the processor time to avoid false negatives (when we dip below threshold)
            var smoothed = from win in dataStream.HoppingWindow(
                               TimeSpan.FromSeconds(2.0),
                               TimeSpan.FromSeconds(0.25),
                               HoppingWindowOutputPolicy.ClipToWindowEnd)
                           select new { Value = win.Avg(s => s.Value) };

            // drive advance time settings from the data stream to the configuration stream
            var ats = new AdvanceTimeSettings(
                null,
                new AdvanceTimeImportSettings(dataStreamName),
                AdvanceTimePolicy.Adjust);

            var configurationStream = configurationSource.ToPointStream(
                application,
                c => PointEvent.CreateInsert(DateTime.UtcNow, c),
                ats,
                "configurationStream");

            // treat the configuration stream as a signal: the start of each event is the end
            // of the previous event
            configurationStream = configurationStream
                .AlterEventDuration(e => TimeSpan.MaxValue)
                .ClipEventDuration(configurationStream, (s, e) => true);

            // join data and configuration streams
            var joined = from d in dataStream
                         from c in configurationStream
                         select new { d.Value, c.Duration, c.Threshold };

            // use alter lifetime to apply the requested duration
            joined = joined.AlterEventDuration(e => e.Payload.Duration);

            // detect when the threshold is sustained for the requested duration
            var query = from win in joined.SnapshotWindow(SnapshotWindowOutputPolicy.Clip)
                        select new { Min = win.Min(s => s.Value), Threshold = win.Avg(s => s.Threshold) } into a
                        where a.Min > a.Threshold
                        select a;

            return from p in query.ToPointObservable()
                   where p.EventKind == EventKind.Insert
                   select new { p.StartTime, p.Payload.Min };
        }