C# StreamType类代码示例

 public ActionResult ReadAjax(StreamType streamType, long id, ShowReadEntries showReadEntries = ShowReadEntries.Hide)
 {
     var entries = this.rssSubscriptionService
         .LoadAllUnreadRssEntriesToReadForCurrentUserFromSubscription(streamType, id, showReadEntries);
     var result = this.Json(entries, JsonRequestBehavior.AllowGet);
     return result;
 }

        /// <summary>
        /// Gets an activity stream asynchronously.
        /// </summary>
        /// <param name="activityId">The Strava activity id.</param>
        /// <param name="typeFlags">Specifies the type of stream.</param>
        /// <param name="resolution">Specifies the resolution of the stream.</param>
        /// <returns>The stream data.</returns>
        public async Task<List<ActivityStream>> GetActivityStreamAsync(String activityId, StreamType typeFlags, StreamResolution resolution = StreamResolution.All)
        {
            StringBuilder types = new StringBuilder();

            foreach (StreamType type in (StreamType[])Enum.GetValues(typeof(StreamType)))
            {
                if (typeFlags.HasFlag(type))
                {
                    types.Append(type.ToString().ToLower());
                    types.Append(",");
                }
            }

            types.Remove(types.ToString().Length - 1, 1);

            String getUrl = String.Format("{0}/{1}/streams/{2}?{3}&access_token={4}",
                Endpoints.Activity,
                activityId,
                types,
                resolution != StreamResolution.All ? "resolution=" + resolution.ToString().ToLower() : "",
                Authentication.AccessToken
                );

            String json = await WebRequest.SendGetAsync(new Uri(getUrl));

            return Unmarshaller<List<ActivityStream>>.Unmarshal(json);
        }

		private StreamInfo (int streamIndex, StreamType st, String streamName, Dictionary<String, String> attributeDictionary) {
			m_streamIndex = streamIndex;
			m_streamType = st;
			m_language = null;
			m_streamName = streamName;
			m_attributeDictionary = attributeDictionary;
		}

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    public MiStreamRecord (StreamType streamType, string stream)
      : base ()
    {
      Type = streamType;

      Stream = stream;
    }

 public Stream(int HabboId, int AchievedItemId, Object AchievedItem, StreamType StreamType)
 {
     this.HabboId = HabboId;
     this.AchievedItemId = AchievedItemId;
     this.AchievedItem = AchievedItem;
     this.StreamType = StreamType;
 }

        public LogFile(string filename, StreamType streams = StreamType.All, ScriptBlock errorCallback = null)
        {
            fileName = System.IO.Path.GetFileName(filename);
            path = System.IO.Path.GetDirectoryName(filename);

            Streams = streams;
            ErrorCallback = errorCallback;
        }

        public bool IsStreamEnabled( StreamType stream )
        {
            IntPtr error = IntPtr.Zero;
            var value = NativeMethod.Device.rs_is_stream_enabled( device, stream, out error );
            RealSenseException.Handle( error );

            return value != 0;
        }

        public int GetStreamWidth( StreamType stream )
        {
            IntPtr error = IntPtr.Zero;
            var value = NativeMethod.Device.rs_get_stream_width( device, stream, out error );
            RealSenseException.Handle( error );

            return value;
        }

        public FormatType GetStreamFormat( StreamType stream )
        {
            IntPtr error = IntPtr.Zero;
            var value = NativeMethod.Device.rs_get_stream_format( device, stream, out error );
            RealSenseException.Handle( error );

            return value;
        }

        /*----------------------------------------------------------------
        ** Constructor
         * 
         * Parameters:  templatePath - the template to be loaded
         *              streamType - the document format of the template
         *              dataSource - new fields for the remapping
        **--------------------------------------------------------------*/
        public FieldRemappingDialog(string templatePath, StreamType streamType, DataSet dataSource)
        {
            InitializeComponent();

            m_template = templatePath;
            m_datasource = dataSource;
            templateStreamType = streamType;
        }

 //
 // Readable stream constructor
 //
 public StreamWrapper(int size, BasicStream s)
 {
     type_ = StreamType.Read;
     s_ = s;
     spos_ = 0;
     bytes_ = null;
     pos_ = 0;
     length_ = size;
 }

 public HekaDAQOutputStream(string name, StreamType streamType, ushort channelNumber, HekaDAQController controller)
     : base(name, controller)
 {
     this.ChannelType = streamType;
     this.ChannelNumber = channelNumber;
     this.MeasurementConversionTarget = (ChannelType == StreamType.DO_PORT || ChannelType == StreamType.XO)
         ? Measurement.UNITLESS : DAQCountUnits;
     this.Controller = controller;
     this.Clock = controller.Clock;
 }

 public HekaDAQInputStream(string name, StreamType streamType, ushort channelNumber, HekaDAQController controller)
     : base(name, controller)
 {
     this.ChannelType = streamType;
     this.ChannelNumber = channelNumber;
     this.MeasurementConversionTarget = (ChannelType == StreamType.DIGITAL_IN || ChannelType == StreamType.AUX_IN)
         ? Measurement.UNITLESS : "V";
     this.Controller = controller;
     this.Clock = controller;
 }

 /** 
     @brief Get the stream index number
     @param[in] StreamType	The stream type
     @return The stream index numebr.
 **/
 public static Int32 StreamTypeToIndex(StreamType type)
 {
     Int32 s = 0;
     while ((Int32)type > 1)
     {
         type = (StreamType)((Int32)type >> 1);
         s++;
     }
     return s;
 }

 public FeatureRequest(
     long userId,
     long rssEntryId,
     StreamType modelStreamType,
     FeatureRequestType featureRequestType)
 {
     this.UserId = userId;
     this.RssEntryId = rssEntryId;
     this.StreamType = modelStreamType;
     this.Type = featureRequestType;
 }