C# Listener.Start方法代码示例

        public static void Main(string[] args)
        {
            for (int i = 0; i < args.Length; i++) {
                switch(args[i]) {
                    case "-p":
                        if (!int.TryParse(args[++i], out port)) {
                            Environment.Exit(-1);
                        }
                        break;
                    case "-s":
                        documentroot = args[++i];
                        break;
                }
            }
            if (args.Contains("--version")) {
                Console.WriteLine("Hermione HTTP Server version {0}", Listener.version);
                return;
            }
            Listener listener = new Listener(host, port);
            if (documentroot != String.Empty) {
                listener.ServerRoot = documentroot;
            }
            listener.Start();

            Environment.Exit(0);
        }

        private void StartWebListener()
        {
            CtxTrace.TraceInformation();
            IDesktopServiceConfiguration config = DesktopServiceConfiguration.Read();

            Uri listenUrl = new Uri(String.Format(ListenUrlPattern, config.ListenPort));
            WebServiceHost host = new WebServiceHost(typeof(DesktopService), listenUrl);
            host.AddServiceEndpoint(typeof(IDesktopService), new WebHttpBinding(), "");
            ServiceDebugBehavior sdb = host.Description.Behaviors.Find<ServiceDebugBehavior>();
            sdb.HttpHelpPageEnabled = false;
            listener = new Listener(host);
            listener.Start();
        }

        public void AddClientConnect()
        {
            Listener listener = new Listener(endPoint);
            ClientsManager clientManager = new ClientsManager();
            listener.NewConnection += clientManager.AddClient;
            listener.Start();
            clientManager.Start();

            protocol.Connect(endPoint, ref desktopSocket);

            Thread.Sleep(2000);
            clientManager.Stop();
            listener.Stop();
            Assert.Pass();
        }

        public static void Main(string[] args)
        {
            var sender = new Sender ();
            var listener = new Listener ();
            listener.DiscoveredEndPoint += delegate(object obj, Listener.DiscoveredEndPointEventArgs e) {
                Console.WriteLine("DiscoveredEndPoint event was raised.  End Point is {0}", e.EndPoint.ToString());
            };

            Console.WriteLine ("Starting Listener");
            listener.Start ();

            Console.WriteLine ("Choose either 's' to send, or 'x' to exit");
            ConsoleKeyInfo cki;

            bool continueLoop = true;
            do
            {
                if (Console.KeyAvailable)
                {
                    cki = Console.ReadKey(true);
                    switch (cki.KeyChar)
                    {
                    case 's':
                        sender.Send();
                        break;
                    case 'x':
                        Console.WriteLine("Try exiting...");

                        listener.Stop();
                        continueLoop = false;
                        break;
                    }
                }

                Thread.Sleep(10);
            } while (continueLoop);

            Console.WriteLine ("Please press any key to exit...");
            Console.ReadKey (true);
        }

 protected override void OnStart(string[] args)
 {
     _listener = new Listener();
     _listener.Start();
 }

        public void Reload()
        {
            // some logic in configuration updated the config when saving, we need to read it again
            _config = Configuration.Load();

            Server server = _config.GetCurrentServer();
            if (String.IsNullOrEmpty(server.Host) ||
                (server.Port <= 0 || server.Port > 65535) ||
                String.IsNullOrEmpty(server.Password))
            {
                return;
            }

            if (_xsocksRunner == null)
            {
                _xsocksRunner = new XsocksRunner();
                _xsocksRunner.LogMessageReceived += _xsocksRunner_LogMessageReceived;
            }
            if (_polipoRunner == null)
            {
                _polipoRunner = new PolipoRunner();
            }
            if (_pacServer == null)
            {
                _pacServer = new PACServer();
                _pacServer.PACFileChanged += PACServerPACFileChanged;
            }
            if (_gfwListUpdater == null)
            {
                _gfwListUpdater = new GFWListUpdater();
                _gfwListUpdater.UpdateCompleted += PACServerPACUpdateCompleted;
                _gfwListUpdater.Error += PACServerPACUpdateError;
            }

            if (_listener != null)
            {
                _listener.Stop();
            }

            // don't put polipoRunner.Start() before pacServer.Stop()
            // or bind will fail when switching bind address from 0.0.0.0 to 127.0.0.1
            // though UseShellExecute is set to true now
            // http://stackoverflow.com/questions/10235093/socket-doesnt-close-after-application-exits-if-a-launched-process-is-open
            _xsocksRunner.Stop();
            _polipoRunner.Stop();

            try
            {
                _xsocksRunner.Start(_config);
                _polipoRunner.Start(_config);

                _pacServer.HttpProxyPort = _polipoRunner.RunningPort;

                List<Listener.IService> services = new List<Listener.IService>();
                services.Add(_pacServer);
                _listener = new Listener(services);
                _listener.Start(_config.PACServerPort, _config.ShareOverLan);
            }
            catch (Exception e)
            {
                // translate Microsoft language into human language
                // i.e. An attempt was made to access a socket in a way forbidden by its access permissions => Port already in use
                if (e is SocketException)
                {
                    SocketException se = (SocketException)e;
                    if (se.SocketErrorCode == SocketError.AccessDenied)
                    {
                        e = new Exception("Port already in use", e);
                    }
                }
                Logging.LogUsefulException(e);
                ReportError(e);
            }

            if (ConfigChanged != null)
            {
                ConfigChanged(this, new EventArgs());
            }

            UpdateSystemProxy();
            Utils.ReleaseMemory();
        }

 public void CanHost()
 {
     var server = new Listener(new IPEndPoint(IPAddress.Any, 8888));
     server.Start();
 }

    static void Main()
    {
        // start server

        IntPtr current = System.Diagnostics.Process.GetCurrentProcess().MainWindowHandle;
        EnableMenuItem(GetSystemMenu(current, false), SC_CLOSE, MF_GRAYED);
        controlerPlayers = new controlerPlayers();
        DateData.initialiseDateTheme();
        DateData.initialiseDateEvent();

        l = new Listener(clientPort);
        l.SocketAccepted += new Listener.SocketAcceptedHandeler(l_SocketAccepted);
        l.Start();
        //keep allive
        while (keepAlive)
        {
            doCMD(Console.ReadLine().ToLower());
        }
    }

 public void Start()
 {
     var listener = new Listener(RequestReceived);
     listener.Start();
 }

 public void ListenerAddClient()
 {
     Listener listener = new Listener(endPoint);
     listener.Start();
     protocol.Connect(endPoint, ref desktopSocket);
     Thread.Sleep(1000);
     listener.Stop();
     Assert.Pass();
 }