static void Main(string[] args)
{
Logs.AddConsoleAppender();
// 注册网络消息
packetHandlersManager.Register((ushort) OpCode.Login, OnLogin);
packetHandlersManager.Register((ushort)OpCode.SendMessage, OnSendMessage);
packetHandlersManager.Register((ushort)OpCode.RecvPrivateMessage, OnSendPrivateMessage);
var servers = new Listener<Session>();
servers.SocketConnect += OnSocketConnect;
servers.SocketDisconnect += OnSocketDisconnect;
servers.SocketRecv += OnSocketRecv;
servers.StartServer(10086);
Logs.Info("服务器启动，等待客户端连接。按Esc键退出");
while (true)
{
var key = Console.ReadKey();
if (key.Key == ConsoleKey.Escape)
break;
Thread.Sleep(100);
}
}
public MessagePump( Listener l )
{
m_Listeners = new Listener[]{ l };
m_Queue = new Queue();
m_Throttled = new Queue();
m_Peek = new byte[4];
}
static void Main(string[] args)
{
using (_store = new AsyncStore<Result>("results"))
using (_frontier = new AsyncStore<FetchTarget>("frontier"))
{
var seeds = new[]
{
"http://www.microsoft.com",
"http://www.theguardian.com/",
"http://www.reddit.com",
};
foreach (var seed in seeds)
{
_frontier.Set(seed, new FetchTarget
{
Level = 1,
Uri = new Uri(seed)
});
}
var listener = new Listener<FetchResult>(x => System.Console.WriteLine("[FETCHED]: {0}", x.ResponseUri));
var crawler = Crawler.Get(new HtmlAgilityPack.DocumentFactory(), _store, _frontier);
crawler.Fetcher.SendTo(listener);
SetConsoleCtrlHandler(x => Handler(crawler, x), true);
crawler.Start();
}
}
public static void Main()
{
var serverAddress = ConfigurationManager.AppSettings.Get("ServerAddress");
var serverPort = int.Parse(ConfigurationManager.AppSettings.Get("ServerPort"));
var clientAddress = ConfigurationManager.AppSettings.Get("ClientAddress");
var clientPort = int.Parse(ConfigurationManager.AppSettings.Get("ClientPort"));
var cs = new UdpClientServer();
var serverChannel = new UdpCommunicationChannel(cs, new ChannelConfig { Address = serverAddress, Port = serverPort });
var clientChannel = new UdpCommunicationChannel(cs, new ChannelConfig { Address = clientAddress, Port = clientPort });
_userService = new GitHubUserSearchService(new HttpClientFactory());
_githubBrowser = new GithubBrowser(new HttpClientFactory());
var userListener = new Listener<UserQuery, UserResponse>(clientChannel, serverChannel);
userListener.ListenObservable(GetUser);
var repoListener = new Listener<RepoQuery, RepoResponse>(clientChannel, serverChannel);
repoListener.ListenObservable(GetRepo);
var favListener = new Listener<FavQuery, FavResponse>(clientChannel, serverChannel);
favListener.ListenObservable(AddToFav);
var publisher = new Publisher<RepoNotification>(serverChannel);
_githubBrowser.NewCommitsFeed
.Select(c => new RepoNotification { Commit = c })
.Subscribe(publisher);
Console.ReadLine();
}
/// <summary>
/// Registers a listener instance with the broker
/// </summary>
/// <param name="address">
/// The address of the listener
/// </param>
/// <param name="listener">
/// The listener to register
/// </param>
public static void Listen(Uri address, Listener listener)
{
if (!listeners.TryAdd(address, listener))
throw new InvalidOperationException(
String.Format("A listener already exists for address {0}", address)
);
}
public Listener Add (string messageType, int controlIndex, string forwardToMethod)
{
Listener listener = new Listener (messageType, controlIndex, forwardToMethod);
Add (listener);
m_Dirty = true;
return listener;
}
/// <summary>
/// Initializes a new instance of the Log class.
/// </summary>
/// <param name="core">The core instance.</param>
public Log(StyleCopCore core)
{
Param.AssertNotNull(core, "core");
object data = core.Registry.CUGetValue("Logging");
if (data != null)
{
try
{
int level = (int)data;
if (level > 0)
{
this.logLevel = StyleCopLogLevel.High;
}
}
catch (FormatException)
{
// Do nothing here since data is registry is invalid.
}
}
if (this.logLevel != StyleCopLogLevel.None)
{
this.listener = new Listener();
Trace.Listeners.Add(this.listener);
}
}
public RoundBasedRegister(IIntercomMessageHub intercomMessageHub,
IBallotGenerator ballotGenerator,
ISynodConfiguration synodConfig,
LeaseConfiguration leaseConfig,
ILogger logger)
{
this.logger = logger;
this.synodConfig = synodConfig;
this.leaseConfig = leaseConfig;
this.intercomMessageHub = intercomMessageHub;
intercomMessageHub.Start();
readBallot = ballotGenerator.Null();
writeBallot = ballotGenerator.Null();
listener = intercomMessageHub.Subscribe();
listener.Where(m => Unsafe.Equals(m.Identity, LeaseReadMessage.MessageIdentity))
.Subscribe(OnReadReceived);
listener.Where(m => Unsafe.Equals(m.Identity, LeaseWriteMessage.MessageIdentity))
.Subscribe(OnWriteReceived);
ackReadStream = listener.Where(m => Unsafe.Equals(m.Identity, LeaseAckReadMessage.MessageIdentity));
nackReadStream = listener.Where(m => Unsafe.Equals(m.Identity, LeaseNackReadMessage.MessageIdentity));
ackWriteStream = listener.Where(m => Unsafe.Equals(m.Identity, LeaseAckWriteMessage.MessageIdentity));
nackWriteStream = listener.Where(m => Unsafe.Equals(m.Identity, LeaseNackWriteMessage.MessageIdentity));
}
public ServerChat()
{
InitializeComponent();
_pChat = new PrivateChat(this);
_listener = new Listener(2016);
_listener.SocketAccepted += ListenerSocketAccept;
}
/// <summary>
///
/// </summary>
internal ClientSocketManager( Listener listener, ServiceHandler serviceHandler, ReceiveQueue receiveBuffer )
{
if ( listener == null )
throw new ArgumentNullException( "listener", "ClientSocketHandler.ClientSocketManager(...) - listener == null error!" );
if ( serviceHandler == null )
throw new ArgumentNullException( "serviceHandler", "ClientSocketHandler.ClientSocketManager(...) - serviceHandle == null error!" );
if ( receiveBuffer == null )
throw new ArgumentNullException( "receiveBuffer", "ClientSocketHandler.ClientSocketManager(...) - receiveBuffer == null error!" );
m_Listener = listener;
m_ServiceHandle = serviceHandler;
m_ReceiveBuffer = receiveBuffer;
{
// �������
m_ReceiveBuffer.Clear();
}
m_ServiceHandle.EventProcessData += OnListenerProcessMessageBlock;
m_ServiceHandle.EventDisconnect += OnListenerDisconnect;
// ��ʼ������ ��ʾ��û���ù�Free(...)����
m_LockFree.SetValid();
}
public void Subscribe(AppEventType type, Listener listener)
{
if (!listenersMap.ContainsKey(type))
listenersMap.Add(type, new Listener(listener));
else
listenersMap[type] += listener;
}
public async Task UpdaterService()
{
var exportProvider = TestHostServices.CreateMinimalExportProvider();
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices(exportProvider));
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1);
var listener = new Listener();
var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable<AnalyzerReference>(analyzerReference), listener);
service.Enable();
// make sure client is ready
var client = await service.GetRemoteHostClientAsync(CancellationToken.None);
// add solution
workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default));
var listeners = exportProvider.GetExports<IAsynchronousOperationListener, FeatureMetadata>();
var workspaceListener = listeners.First(l => l.Metadata.FeatureName == FeatureAttribute.Workspace).Value as IAsynchronousOperationWaiter;
// wait for listener
await workspaceListener.CreateWaitTask();
await listener.CreateWaitTask();
// checksum should already exist
SolutionStateChecksums checksums;
Assert.True(workspace.CurrentSolution.State.TryGetStateChecksums(out checksums));
service.Disable();
}
static void Main(string[] args)
{
Timer t = new Timer();
Listener listen = new Listener();
listen.Subscribe(t);
t.StartTimer();
}
public MessagePump()
{
IPEndPoint[] ipep = Listener.EndPoints;
m_Listeners = new Listener[ipep.Length];
bool success = false;
do {
for (int i = 0; i < ipep.Length; i++) {
Listener l = new Listener(ipep[i]);
if (!success && l != null)
success = true;
m_Listeners[i] = l;
}
if (!success) {
Console.WriteLine("Retrying...");
Thread.Sleep(10000);
}
} while (!success);
m_Queue = new Queue<NetState>();
m_WorkingQueue = new Queue<NetState>();
m_Throttled = new Queue<NetState>();
m_Peek = new byte[4];
}
public async Task Listen_AnonymousData_Ok(
[Frozen]HttpRequestMessage request,
Func<HttpRequestMessage> requestProvider,
[Frozen]Mock<IStreamingUtils> streamingUtils,
[Frozen]Mock<IHttpUtils> httpUtils,
Listener sut)
{
//Arrange
var twits = new[] {"Твиттер это ниочень", "Вот мой мир -- другое дело", "круче только одноклассники"};
var concatenatedTwits = string.Join('\n'.ToString(), twits);
var stream = new MemoryStream(Encoding.UTF8.GetBytes(concatenatedTwits));
var reader = new StreamReader(stream, Encoding.GetEncoding("utf-8"));
httpUtils.Setup(a => a.UnescapeUnicode(It.IsAny<string>())).Returns((string r) => r);
streamingUtils.Setup(a => a.GetReader(It.IsAny<HttpRequestMessage>())).ReturnsAsync(reader);
var results = new List<string>();
Action<string> processRequest = a => results.Add(a);
//Act
await sut.Listen(requestProvider, processRequest);
//Assert
streamingUtils.Verify(a => a.GetReader(request), Times.Once);
results.ShouldAllBeEquivalentTo(twits);
}
public void Start()
{
var cfg = Config.Load();
runner = new Listener(ListenerCallback, "http://*:" + cfg.HttpPort + "/");
runner.Run();
}
public override HResult Initialize()
{
try
{
var hr = base.Initialize();
if (ErrorUtil.Failure(hr))
return hr;
ErrorUtil.ThrowOnFailure(Frame.SetCaption(Labels.FindResults));
_editor = new NiEditor
{
Site = new SiteProxy(this),
Dock = DockStyle.Fill
};
ErrorUtil.ThrowOnFailure(_editor.TextBuffer.SetStateFlags(
NiTextBufferState.ReadOnly
));
ErrorUtil.ThrowOnFailure(_editor.TextBuffer.SetLanguageServiceID(
new Guid(NiConstants.LanguageServiceDefault)
));
_listener = new Listener(this);
Controls.Add(_editor);
return HResult.OK;
}
catch (Exception ex)
{
return ErrorUtil.GetHResult(ex);
}
}
public void Execute(Listener listener, params Type[] candidateTypes)
{
foreach (var testClass in Classes.Filter(candidateTypes))
{
var methods = Methods.Filter(testClass);
var cases = methods.SelectMany(method => CasesForMethod(testClass, method)).ToArray();
var casesBySkipState = cases.ToLookup(CaseExecution.SkipPredicate);
var casesToSkip = casesBySkipState[true];
var casesToExecute = casesBySkipState[false];
foreach (var @case in casesToSkip)
listener.CaseSkipped(@case);
var caseExecutions = casesToExecute.Select(@case => new CaseExecution(@case)).ToArray();
if (!caseExecutions.Any())
continue;
ClassExecution.Behavior.Execute(testClass, this, caseExecutions);
foreach (var caseExecution in caseExecutions)
{
if (caseExecution.Exceptions.Any())
listener.CaseFailed(new FailResult(caseExecution));
else
listener.CasePassed(new PassResult(caseExecution));
}
}
}
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);
}
public void RemoveBinding()
{
Assert.AreEqual(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 21), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 21));
var listener = new Listener();
listener.AddBinding(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 21));
listener.RemoveBinding(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 21));
Assert.AreEqual(0, listener.Bindings.Count);
}
/// <summary>
/// Initializes listener.
/// </summary>
/// <param name="localEndPoint">Local endpoint.</param>
private static void InitializeListener( IPEndPoint localEndPoint )
{
m_ListenerService = new Listener(localEndPoint, m_BackLog);
m_ListenerService.OnStarted += new OnListenerStartedEventHandler(ListenerService_OnStarted);
m_ListenerService.OnStopped += new OnListenerStoppedEventHandler(ListenerService_OnStopped);
m_ListenerService.OnTerminated += new OnListenerTerminatedEventHandler(ListenerService_OnTerminated);
m_ListenerService.OnConnectionAccepted += new OnConnectionAcceptedEventHandler(ListenerService_OnConnectionAccepted);
}
/**
* <p>Adds an event listener that will be run when this confidence object is updated. The listener will be locked and
* is likely to be invoked on a peer thread.</p>
*
* <p>Note that this is NOT called when every block arrives. Instead it is called when the transaction
* transitions between confidence states, ie, from not being seen in the chain to being seen (not necessarily in
* the best chain). If you want to know when the transaction gets buried under another block, implement a
* {@link BlockChainListener}, attach it to a {@link BlockChain} and then use the getters on the
* confidence object to determine the new depth.</p>
*/
public synchronized void addEventListener(Listener listener) {
Preconditions.checkNotNull(listener);
if (listeners == null)
listeners = new ArrayList<Listener>(2);
// Dedupe registrations. This makes the wallet code simpler.
if (!listeners.contains(listener))
listeners.add(listener);
}
static void Main(string[] args)
{
ListwithListeners list = new ListwithListeners();
Listener listen = new Listener(list);
list.add(1);
Console.Read();
}
private void mapPanel_Paint(object sender, PaintEventArgs e)
{
_listener = new Listener(Listener.EntryThreadPoint);
var tmp = mapPanel.CreateGraphics();
_player = new PointDrawer(ref tmp);
_mover = new Mover(_player, ref pingScrollBar);
mapPanel.Paint -= mapPanel_Paint;
}
public ILoggerListener GetListener()
{
if (_listener == null)
{
_listener = new Listener(this);
}
return _listener;
}
public OutputPane()
{
InitializeComponent();
m_Listener = new Listener(this);
System.Diagnostics.Trace.Listeners.Add(m_Listener);
Trace.WriteLine("Output pane created");
}
internal PlaybackStream(uint sampleRate, OpenALAudioFormat format, PlaybackDevice device, IntPtr context)
{
_sampleRate = sampleRate;
_format = format;
_device = device;
_context = context;
CreateSource();
Listener = new Listener(_context);
}
static void Main(string[] args)
{
var options = new Options(args);
var loader = new Loader(options.AssemblyPaths);
var processor = new Processor(loader);
var listener = new Listener(processor, options.Port);
new NukeServer(listener, Console.Out, options).Start();
}
/// <summary>
/// Removes the listener.
/// </summary>
/// <returns><c>true</c>, if listener was removed, <c>false</c> otherwise.</returns>
/// <param name="listener">Listener.</param>
public bool Remove (Listener listener)
{
bool doesContain = m_Listeners.Contains (listener);
if (doesContain) {
m_Listeners.Remove (listener);
m_Dirty = true;
}
return doesContain;
}
static void Main(string[] args)
{
var listener = new Listener();
listener.Subscribe();
Messenger.Default.Send(new object());
Console.ReadLine();
}
public static bool FireLongPressed(FrameworkElement element, long elapsedMilliseconds, Listener listener)
{
var args = new UwpLongPressEventArgs(element, elapsedMilliseconds)
{
Listener = listener
};
listener?.OnLongPressed(args);
return(args.Handled);
}
public override string GetLauncher(Listener listener, Grunt grunt, HttpProfile profile)
{
this.StagerCode = listener.GetGruntStagerCode(grunt, profile);
this.Base64ILByteString = listener.CompileGruntStagerCode(grunt, profile, this.OutputKind, false);
// Credit DotNetToJscript (tyranid - James Forshaw)
byte[] serializedDelegate = Convert.FromBase64String(FrontBinaryFormattedDelegate).Concat(Convert.FromBase64String(this.Base64ILByteString)).Concat(Convert.FromBase64String(EndBinaryFormattedDelegate)).ToArray();
int ofs = serializedDelegate.Length % 3;
if (ofs != 0)
{
int length = serializedDelegate.Length + (3 - ofs);
Array.Resize(ref serializedDelegate, length);
}
string base64Delegate = Convert.ToBase64String(serializedDelegate);
int lineLength = 80;
List <String> splitString = new List <String>();
for (int i = 0; i < base64Delegate.Length; i += lineLength)
{
splitString.Add(base64Delegate.Substring(i, Math.Min(lineLength, base64Delegate.Length - i)));
}
string language = "";
string code = "";
if (this.ScriptLanguage == ScriptingLanguage.JScript)
{
string DelegateBlock = String.Join("\"+\r\n\"", splitString.ToArray());
code = JScriptTemplate.Replace(Environment.NewLine, "\r\n").Replace("{{REPLACE_GRUNT_IL_BYTE_STRING}}", DelegateBlock);
language = "JScript";
}
else if (this.ScriptLanguage == ScriptingLanguage.VBScript)
{
string DelegateBlock = String.Join("\"\r\ns = s & \"", splitString.ToArray());
code = VBScriptTemplate.Replace(Environment.NewLine, "\r\n").Replace("{{REPLACE_GRUNT_IL_BYTE_STRING}}", DelegateBlock);
if (this.ScriptType == ScriptletType.Stylesheet)
{
code = "<![CDATA[\r\n" + code + "\r\n]]>";
}
language = "VBScript";
}
if (this.ScriptType == ScriptletType.Plain)
{
this.DiskCode = code;
}
else if (this.ScriptType == ScriptletType.Scriptlet || this.ScriptType == ScriptletType.TaggedScript)
{
string TaggedScript = TaggedScriptTemplate.Replace(Environment.NewLine, "\r\n").Replace("{{REPLACE_SCRIPT_LANGUAGE}}", language);
TaggedScript = TaggedScript.Replace("{{REPLACE_SCRIPT}}", code);
if (this.ScriptType == ScriptletType.TaggedScript)
{
this.DiskCode = TaggedScript;
}
else
{
this.DiskCode = ScriptletCodeTemplate.Replace(Environment.NewLine, "\r\n").Replace("{{REPLACE_TAGGED_SCRIPT}}", TaggedScript).Replace("{{REPLACE_PROGID}}", this.ProgId);
}
}
else if (this.ScriptType == ScriptletType.Stylesheet)
{
this.DiskCode = StylesheetCodeTemplate.Replace(Environment.NewLine, "\r\n").Replace("{{REPLACE_SCRIPT_LANGUAGE}}", language);
this.DiskCode = DiskCode.Replace("{{REPLACE_SCRIPT}}", code);
}
if (this.DotNetFrameworkVersion == Common.DotNetVersion.Net35)
{
this.DiskCode = this.DiskCode.Replace("{{REPLACE_VERSION_SETTER}}", "");
}
else if (this.DotNetFrameworkVersion == Common.DotNetVersion.Net40)
{
this.DiskCode = this.DiskCode.Replace("{{REPLACE_VERSION_SETTER}}", JScriptNet40VersionSetter);
}
return(GetLauncher(this.DiskCode));
}
public virtual string GetLauncher(Listener listener, Grunt grunt, HttpProfile profile)
{
return("");
}
public virtual string GetHostedLauncher(Listener listener, HostedFile hostedFile)
{
return("");
}
static void ShutdownThread(bool restarting, string msg)
{
try {
Logger.Log(LogType.SystemActivity, "Server shutting down ({0})", msg);
} catch { }
// Stop accepting new connections and disconnect existing sessions
try {
if (Listener != null)
{
Listener.Close();
}
} catch (Exception ex) { Logger.LogError(ex); }
try {
Player[] players = PlayerInfo.Online.Items;
foreach (Player p in players)
{
p.Leave(msg);
}
} catch (Exception ex) { Logger.LogError(ex); }
byte[] kick = Packet.Kick(msg, false);
try {
INetSocket[] pending = INetSocket.pending.Items;
foreach (INetSocket p in pending)
{
p.Send(kick, false);
}
} catch (Exception ex) { Logger.LogError(ex); }
Plugin.UnloadAll();
OnShuttingDownEvent.Call(restarting, msg);
try {
string autoload = null;
Level[] loaded = LevelInfo.Loaded.Items;
foreach (Level lvl in loaded)
{
if (!lvl.SaveChanges)
{
continue;
}
autoload = autoload + lvl.name + "=" + lvl.physics + Environment.NewLine;
lvl.Save(false, true);
lvl.SaveBlockDBChanges();
}
if (Server.SetupFinished && !Server.Config.AutoLoadMaps)
{
File.WriteAllText("text/autoload.txt", autoload);
}
} catch (Exception ex) { Logger.LogError(ex); }
try {
Logger.Log(LogType.SystemActivity, "Server shutdown completed");
} catch { }
try { FileLogger.Flush(null); } catch { }
if (restarting)
{
Process.Start(RestartPath);
}
Environment.Exit(0);
}
public async Task TearDownAsync()
{
await Listener.StopAsync(CancellationToken);
Listener.Dispose();
}
public void InvalidPortTests(string input, string expectedDomain, string expectedPort = null)
{
var(domain, port) = Listener.SplitDomainAndPort(input);
Assert.Equal(domain, expectedDomain);
Assert.Equal(port, expectedPort);
}
public void addListener(Listener list)
{
listenerList.Add(list);
}
public static bool FireLongPressed(FrameworkElement element, Windows.UI.Xaml.Input.PointerRoutedEventArgs e, long elapsedMilliseconds, Listener listener)
{
var args = new UwpLongPressEventArgs(element, e, elapsedMilliseconds)
{
Listener = listener
};
listener?.OnLongPressed(args);
e.Handled = args.Handled;
return(e.Handled);
}
public void NotifyActionEvent(QQActionEventType type, object target)
{
Listener?.Invoke(this, new QQActionEvent(type, target));
}
