C# Channel.ToString方法代码示例

        public void Should_return_the_correct_site_based_on_the_originating_site_header()
        {
            var router = new OriginatingSiteHeaderRouter();

            var message = new TransportMessage();

            var defaultChannel = new Channel
                                     {
                                         Type = "http",
                                         Address = "http://x.y"

                                     };

            message.Headers.Add(Headers.OriginatingSite, defaultChannel.ToString());

            Assert.AreEqual(defaultChannel, router.GetDestinationSitesFor(message).First().Channel);
        }

        /// <summary>
        /// Downloads the latest build for the given channel into the "/Update" folder.
        /// </summary>
        public static bool DownloadLatestVersion( Channel channel )
        {
            try
            {
                Directory.CreateDirectory( @"LANdrop\Update" );
                string fileName = Path.Combine( @"LANdrop\Update", String.Format( "LANdrop_{0}{1}.exe", ChannelFunctions.ToUrlPart( LastVersionInfo[channel].Channel ), LastVersionInfo[channel].BuildNumber ) );
                string tempFileName = fileName + ".part";

                // Download the file.
                new WebClient( ).DownloadFile( ServerAddress + "/files/" + channel.ToString( ).ToLower( ) + "/" + LastVersionInfo[channel].BuildNumber + "/LANdrop.exe", tempFileName );

                // Success! Remove other updates and the .part suffix.
                foreach ( var file in new DirectoryInfo( @"LANdrop\Update" ).GetFiles( "LANdrop_" + ChannelFunctions.ToUrlPart( channel ) + "*.exe" ) )
                    File.Delete( file.FullName );

                File.Move( tempFileName, fileName );
                LastDownloadedBuild[channel] = LastVersionInfo[channel];
                return true;
            }
            catch ( WebException ) { return false; }
        }

        /// <summary>
        ///     Emit a message to all listeners
        /// </summary>
        /// <param name="channel">The channel to emit on</param>
        /// <param name="data">The data to send</param>
        /// <param name="global">Should the data be sent to other processes</param>
        private static void Emit(Channel channel, string data, bool global = false)
        {
            if (global)
            {
                var transport = new JObject {{"channel", channel.ToString()}, {"data", data}};
                if (channel != Channel.Log)
                    Log.Entry(LogName, transport.ToString());
                SendMessage(transport.ToString());

                // If this bus instance is a client, wait for the event to be bounced-back before processing
                if (_client != null)
                    return;
            }
            if (channel != Channel.Log)
                Log.Entry(LogName, "Emmiting message on channel: " + channel);

            if (!Registrar.ContainsKey(channel)) return;
            try
            {
                var json = JObject.Parse(data);
                foreach (var action in Registrar[channel])
                    action.Invoke(json);
            }
            catch (Exception ex)
            {
                Log.Error(LogName, "Unable to parse data");
                Log.Error(LogName, ex);
            }
        }

 public bool GetMute(Channel channel)
 {
     return UPnP.InvokeAction<bool>(_service, "GetMute", InstanceId, channel.ToString());
 }

 public void SetVolumeDB(Channel channel, short desiredVolume)
 {
     UPnP.InvokeAction(_service, "SetVolumeDB", InstanceId, channel.ToString(), desiredVolume);
 }

 public ushort SetRelativeVolume(Channel channel, int adjustment)
 {
     return UPnP.InvokeAction<ushort>(_service, "SetRelativeVolume", InstanceId, channel.ToString(), adjustment);
 }

 public void SetMute(Channel channel, bool desiredMute)
 {
     UPnP.InvokeAction(_service, "SetMute", InstanceId, channel.ToString(), desiredMute);
 }

 public void SetLoudness(Channel channel, bool desiredLoudness)
 {
     UPnP.InvokeAction(_service, "SetLoudness", InstanceId, channel.ToString(), desiredLoudness);
 }

 public void RestoreVolumePriorToRamp(Channel channel)
 {
     UPnP.InvokeAction(_service, "RestoreVolumePriorToRamp", InstanceId, channel.ToString());
 }

 public uint RampToVolume(Channel channel, RampType rampType, short desiredVolume)
 {
     return UPnP.InvokeAction<uint>(_service, "RampToVolume", InstanceId, channel.ToString(), rampType.ToString(), desiredVolume);
 }

 public void GetVolumeDBRange(Channel channel)
 {
     // TODO: return MinValue/MaxValue
     object[] results = UPnP.InvokeAction(_service, "GetVolumeDBRange", InstanceId, channel.ToString());
 }

 public short GetVolumeDB(Channel channel)
 {
     return UPnP.InvokeAction<short>(_service, "GetVolumeDB", InstanceId, channel.ToString());
 }

 public static string ToUrlPart( Channel channel )
 {
     return channel.ToString( ).ToLower( );
 }

 private int ChannelToIndex(Channel channel)
 {
     string s = channel.ToString();
     s = s.Replace("Channel", "");
     int index = Convert.ToInt32(s) - 1;
     if (index >= 11) // we skip channel 10 so subtract one to get the track number
         index--;
     return index;
 }

        TSQueue<float> AddChannel(Channel channel)
        {
            lock(dictionary)
            {
                //Check if channel is already in use
                if(dictionary.ContainsKey(channel))
                    throw new Exception(String.Format("Session already uses {0}", channel.ToString()[0])); //!!Possible bug

                TTLChannel ttlChannel = GetChannel(encoder, channel);
                TSQueue<float> queue = new TSQueue<float>();
                dictionary.Add(channel, new ChannelQueue(ttlChannel, queue));
                return queue;
            }
        }