public App() : base() { messageSent = MessageSent.NONE; clientMiniCheckers = new MainWindow(); udpHandler = new ClientUDPMessageHandler(); clientMiniCheckers.Show(); WireHandlers(); setupRequestResponseBackgroundThead(); }
/// <summary> /// Writes a producer request to the server asynchronously. /// </summary> /// <param name="request">The request to make.</param> /// <param name="callback">The code to execute once the message is completely sent.</param> public void BeginWrite(ProducerRequest request, MessageSent<ProducerRequest> callback) { NetworkStream stream = _client.GetStream(); RequestContext<ProducerRequest> ctx = new RequestContext<ProducerRequest>(stream, request); byte[] data = request.GetBytes(); stream.BeginWrite( data, 0, data.Length, delegate(IAsyncResult asyncResult) { RequestContext<ProducerRequest> context = (RequestContext<ProducerRequest>)asyncResult.AsyncState; if (callback != null) { callback(context); } context.NetworkStream.EndWrite(asyncResult); context.NetworkStream.Dispose(); }, ctx); }
/// <summary> /// Constructs request and sent it to Kafka server asynchronously /// </summary> /// <param name="topic"> /// The topic. /// </param> /// <param name="partition"> /// The partition. /// </param> /// <param name="messages"> /// The list of messages to sent. /// </param> /// <param name="callback"> /// The callback invoked when a request is finished being sent. /// </param> public void Send(string topic, int partition, IEnumerable <Message> messages, MessageSent <ProducerRequest> callback) { this.EnsuresNotDisposed(); Guard.NotNullNorEmpty(topic, "topic"); Guard.NotNull(messages, "messages"); Guard.Assert <ArgumentException>(() => messages.All(x => x.PayloadSize <= this.Config.MaxMessageSize)); this.Send(new ProducerRequest(topic, partition, messages), callback); }
private void SendErrorMessage(string message) { MessageSent?.Invoke(MessageType.Error, message); }
private void SendInfoMessage(string message) { MessageSent?.Invoke(MessageType.Info, message); }
public SendMsgAction(IWeChatContext context, MessageSent msg, ActionEventListener listener = null) : base(context, listener) { _msg = msg; }
protected virtual void OnMessageSent(long idGroup, int total, int process) => MessageSent?.Invoke(this, new MessageSentEventArgs(idGroup, total, process));
/// <summary> /// Sends request to Kafka server asynchronously /// </summary> /// <param name="request"> /// The request. /// </param> /// <param name="callback"> /// The callback invoked when a request is finished being sent. /// </param> public void Send(ProducerRequest request, MessageSent<ProducerRequest> callback) { Guard.Assert<ArgumentNullException>(() => request != null); Guard.Assert<ArgumentNullException>(() => request.MessageSet != null); Guard.Assert<ArgumentNullException>(() => request.MessageSet.Messages != null); Guard.Assert<ArgumentException>( () => request.MessageSet.Messages.All(x => x.PayloadSize <= this.Config.MaxMessageSize)); using (var conn = new KafkaConnection(this.config.Host, this.config.Port)) { conn.BeginWrite(request, callback); } }
private void HandleMenuLogout(object sender, RoutedEventArgs e) { messageSent = MessageSent.LOGOUT; udpHandler.SendRequest(string.Format("LOGOUT,{0}", username)); }
public void RaiseMessageSent(MessageInfo info) { MessageSent?.Invoke(info); }
private static void DoPublishSynchronouslyOnSameThread(TMessage message) { if (MessageSent != null) MessageSent.Invoke(message); }
public void Handle(MessageSent scheduleSmsForSendingLater) { MarkAsComplete(); }
protected virtual void OnMessageSent(System.IO.Stream e) { MessageSent?.Invoke(this, e); }
private void DiscordClientOnMessageSent(object sender, global::Discord.MessageEventArgs e) { MessageSent?.Invoke(this, new EventArgs.MessageEventArgs(new DiscordMessage(e.Message), new DiscordServer(e.Server), new DiscordChannel(e.Channel), new DiscordUser(e.User))); }
private void SendBtn_Click(object sender, EventArgs e) { MessageSent?.Invoke(SendTxt.Text); ReceiveMessage($"({username}) {SendTxt.Text.Trim()}"); SendTxt.Text = ""; }
/// <summary> /// /// </summary> /// <param name="info"></param> /// <returns>true if connection is finished and need to be closed</returns> private async Task <bool> ProcessLineAsync(string info) { if (info == null) { throw new ArgumentNullException(nameof(info)); } logger.LogInformation($"Receive: {info}"); if (info.Contains("VRC") && !atc) { vrc = true; atc = true; await SendAsync($"$DI{ClientCode}:CLIENT:client V1.00:3ef36a24"); logger.LogInformation("Sent VRC Hello"); } //else if (!this.atc && !this.es) //{ // this.es = true; // this.atc = true; // Console.WriteLine("Sent EuroScope Hello"); //} if (info.StartsWith("%" + callsign)) { // %EDDM_TWR:18700:4:100:3:48.35378:11.78609:0 var tokens = info.Split(':'); var freq = int.Parse("1" + tokens[1]); var alt = int.Parse(tokens[2]); //var protocol = tokens[3]; //var rating = tokens[4]; var lat = double.Parse(tokens[5], CultureInfo.InvariantCulture); var lng = double.Parse(tokens[6], CultureInfo.InvariantCulture); AtcUpdated?.Invoke(this, new AtcUpdatedEventArgs(callsign, freq, alt, lat, lng)); AtcMessageSent?.Invoke(this, new AtcMessageSentEventArgs("*", info)); } if (info.StartsWith($"#DA{callsign}:SERVER")) { // #DAEDDM_TWR:SERVER Disconnect(); return(true); } if (info.StartsWith("#AP")) { // #APNWA360:SERVER:1363753::1:100:6:Jim Levain KBLI // #APTHY73Q:SERVER:1349469::1:100:2:Bedran Batkitar LTFM } if (info.StartsWith("$AX")) { // METAR var station = info.Substring($"$AX{callsign}:SERVER:METAR:".Length, 4); await SendMETARAsync(station); } if (info.StartsWith("$CQ")) { // TODO: Command // (e.g. $CQHYHY:@94835:BC:HY3088:2677 --- Set squawk) // (e.g. $CQKAUS_TWR:SERVER:FP:DS-TZZ --- Requesting flight plan) //$CQCYVR_TWR:@94835:DR:USEP6Q --- Assume a callsign //#TMCYVR_TWR:FP:USEP6Q --- Release var tokens = info.Substring("$CQ".Length).Split(new char[] { ':' }, 4); var sender = tokens[0]; var recipient = tokens[1]; var command = tokens[2]; var data = tokens.Length == 4 ? tokens[3] : null; if (recipient == "SERVER") { switch (command) { case "ATC": await SendAsync($"$CRSERVER:{callsign}:ATC:Y:{data}"); break; case "CAPS": await SendAsync($"$CRSERVER:{callsign}:CAPS:ATCINFO=1:SECPOS=1"); break; case "IP": var ipep = (IPEndPoint)tcpClient.Client.RemoteEndPoint; var ipa = ipep.Address; await SendAsync($"$CRSERVER:{callsign}:IP:{ipa}"); await SendAsync($"$CQSERVER:{callsign}:CAPS"); break; case "FP": FlightPlanRequested?.Invoke(this, new FlightPlanRequestedEventArgs(data)); break; } } else { // Real Name // $CQCYVR_TWR:EDDM_GND:RN // Expect: $CREDDM_GND:WADD_TWR:RN:<Name>Hy:<location>Vancouver FIR 2004/1-1 CZVR 20200404:<rating>3 AtcMessageSent?.Invoke(this, new AtcMessageSentEventArgs(recipient, info)); } } if (info.StartsWith("$CR")) { //$CRCYVR_TWR:CYVR_GND:CAPS:ATCINFO=1:SECPOS=1:MODELDESC=1:ONGOINGCOORD=1 var tokens = info.Split(":"); var recipient = tokens[1]; if (recipient == "SERVER") { // Ignore } else { AtcMessageSent?.Invoke(this, new AtcMessageSentEventArgs(recipient, info)); } } if (info.StartsWith("$HO") || info.StartsWith("#PC")) { // Manual transfer // $HOCYVR_TWR:CZVR_CTR:NF-OJS // #PCCYVR_TWR:CZVR_CTR:CCP:ST:NF-OJS:1::::::::: var tokens = info.Split(":"); var recipient = tokens[1]; if (recipient == "SERVER") { // Probably never happen } else { AtcMessageSent?.Invoke(this, new AtcMessageSentEventArgs(recipient, info)); } } if (info.StartsWith($"#TM{callsign}:")) { // TODO: Message (e.g. #TMHYHY:FP:HY3088 SET 2677) // #TMEDDM_TWR:@18700:hello all var tokens = info.Split(new char[] { ':' }, 3); var to = tokens[1]; var msg = tokens[2]; MessageSent?.Invoke(this, new MessageSentEventArgs(to, msg)); AtcMessageSent?.Invoke(this, new AtcMessageSentEventArgs("*", info)); } if (this.vrc) { if (info.Contains($"$CQ{callsign}:SERVER:ATC:{callsign}") && !this.atc) { logger.LogInformation("Send VRC"); await SendAsync($"$CR{ClientCode}:{callsign}:ATC:Y:{callsign}"); this.atc = true; } } else { if (info.StartsWith("#AA")) { // #AACYVR_TWR:SERVER:HY:NA:123:3:9:1:0:49.19470:-123.18397:100 // #AAEGHQ_ATIS:SERVER:Daniel Button:1343255::4:100 logger.LogInformation("Connected"); var tokens = info.Substring("#AA".Length).Split(":"); callsign = tokens[0]; var to = tokens[1]; var realName = tokens[2]; var certificate = tokens[3]; var password = tokens[4]; var rating = tokens[5]; var lat = tokens.Length > 9 ? double.Parse(tokens[9], CultureInfo.InvariantCulture) : (double?)null; var lon = tokens.Length > 10 ? double.Parse(tokens[10], CultureInfo.InvariantCulture) : (double?)null; await SendAsync($"#TM{ClientCode}:{callsign}:Connected to {ClientName}."); Connected?.Invoke(this, new ConnectedEventArgs(callsign, realName, certificate, rating, lat, lon)); } } return(false); }
/// <summary> /// Raises MessageSent event. /// </summary> /// <param name="message">Received message</param> protected virtual void OnMessageSent(IScsMessage message) => MessageSent?.Invoke(this, new MessageEventArgs(message, DateTime.Now));
private void Poll() { var jObject = new JObject(); jObject["chat_token"] = Token; jObject["usernames"] = JArray.FromObject(AccountData.Users.Where(x => x.Update).Select(x => x.Name).ToArray()); jObject["after"] = LastPollTime + 0.005; try { var response = Requester.PostRequest(Methods.ChatHistory, jObject); var obj = JsonConvert.DeserializeObject(response) as JObject; var chatHistory = new ChatHistory(); var chatObject = obj["chats"] as JObject; foreach (var kvp in chatObject) { foreach (JObject msgObject in kvp.Value as JArray) { var channel = string.Empty; if (msgObject["channel"] != null) { channel = msgObject["channel"].ToString(); } if (msgObject["is_join"] != null) { var presence = new Presence( msgObject["id"].ToString(), double.Parse(msgObject["t"].ToString()), kvp.Key, msgObject["from_user"].ToString(), channel, bool.Parse(msgObject["is_join"].ToString()) ); chatHistory.Push(presence); } else { var message = new Message( msgObject["id"].ToString(), double.Parse(msgObject["t"].ToString()), kvp.Key, msgObject["from_user"].ToString(), channel, msgObject["msg"].ToString() ); chatHistory.Push(message); } } } if (!chatHistory.IsEmpty) { LastPollTime = chatHistory.Last.Timestamp; } while (!chatHistory.IsEmpty) { var element = chatHistory.Pop(); if (element is Presence) { var pres = element as Presence; var channel = AccountData.FindUser(pres.To).FindChannel(pres.Channel); if (channel != null) { if (!pres.Joined) { if (channel.MemberExists(pres.From)) { channel.Members.Remove(pres.From); } } else { if (!channel.MemberExists(pres.From)) { channel.Members.Add(pres.From); } } } PresenceReceived?.Invoke(this, new PresenceEventArgs(pres)); continue; } else if (element is Message) { if (element.From != element.To) { if (!RelayedIDs.Contains(element.ID)) { RelayedIDs.Add(element.ID); MessageReceived?.Invoke(this, new MessageEventArgs(element as Message)); } } else { if (!RelayedIDs.Contains(element.ID)) { RelayedIDs.Add(element.ID); MessageSent?.Invoke(this, new MessageEventArgs(element as Message)); } } if (RelayedIDs.Count > 100) { RelayedIDs.Clear(); } } } } catch (RequestException e) { ErrorOccured?.Invoke(this, new ErrorEventArgs(e)); } }
private void Log(string logText) { MessageSent.Invoke(this, new MessageSentEventArgs(MessageType.Log, logText)); }
private void Navigate(INotifier destination) { MessageSent.Invoke(this, new MessageSentEventArgs(MessageType.Navigation, destination)); }
/// <summary> /// Constructs request and sent it to Kafka server asynchronously /// </summary> /// <param name="topic"> /// The topic. /// </param> /// <param name="partition"> /// The partition. /// </param> /// <param name="messages"> /// The list of messages to sent. /// </param> /// <param name="callback"> /// The callback invoked when a request is finished being sent. /// </param> public void Send(string topic, int partition, IEnumerable<Message> messages, MessageSent<ProducerRequest> callback) { this.EnsuresNotDisposed(); Guard.NotNullNorEmpty(topic, "topic"); Guard.NotNull(messages, "messages"); Guard.Assert<ArgumentException>(() => messages.All(x => x.PayloadSize <= this.Config.MaxMessageSize)); this.Send(new ProducerRequest(topic, partition, messages), callback); }
protected void OnMessageSent() { MessageSent?.Invoke(this, new ConnectionMessageEventArgs()); }
private void handleEvents(List <DatafeedEvent> datafeedEvents) { foreach (DatafeedEvent eventv4 in datafeedEvents) { if (eventv4.initiator.user.userId != botClient.getBotUserInfo().id) { switch (eventv4.type) { case "MESSAGESENT": MessageSent messageSent = eventv4.payload.messageSent; if (messageSent.message.stream.streamType.Equals("ROOM")) { foreach (RoomListener listener in roomListeners) { listener.onRoomMessage(messageSent.message); } } else { foreach (IMListener listener in IMListeners) { listener.onIMMessage(messageSent.message); } } break; case "INSTANTMESSAGECREATED": foreach (IMListener listeners in IMListeners) { listeners.onIMCreated(eventv4.payload.instantMessageCreated.stream); } break; case "ROOMCREATED": foreach (RoomListener listener in roomListeners) { listener.onRoomCreated(eventv4.payload.roomCreated); } break; case "ROOMUPDATED": foreach (RoomListener listener in roomListeners) { listener.onRoomUpdated(eventv4.payload.roomUpdated); } break; case "ROOMDEACTIVATED": foreach (RoomListener listener in roomListeners) { listener.onRoomDeactivated(eventv4.payload.roomDeactivated); } break; case "ROOMREACTIVATED": foreach (RoomListener listener in roomListeners) { listener.onRoomReactivated(eventv4.payload.roomReactivated.stream); } break; case "USERJOINEDROOM": foreach (RoomListener listener in roomListeners) { listener.onUserJoinedRoom(eventv4.payload.userJoinedRoom); } break; case "USERLEFTROOM": foreach (RoomListener listener in roomListeners) { listener.onUserLeftRoom(eventv4.payload.userLeftRoom); } break; case "ROOMMEMBERPROMOTEDTOOWNER": foreach (RoomListener listener in roomListeners) { listener.onRoomMemberPromotedToOwner(eventv4.payload.roomMemberPromotedToOwner); } break; case "ROOMMEMBERDEMOTEDFROMOWNER": foreach (RoomListener listener in roomListeners) { listener.onRoomMemberDemotedFromOwner(eventv4.payload.roomMemberDemotedFromOwner); } break; case "CONNECTIONACCEPTED": foreach (ConnectionListener listener in connectionListeners) { listener.onConnectionAccepted(eventv4.payload.connectionAccepted.fromUser); } break; case "CONNECTIONREQUESTED": foreach (ConnectionListener listener in connectionListeners) { listener.onConnectionRequested(eventv4.payload.connectionRequested.toUser); } break; default: break; } } } }
private void OnConnectionMessageSent(object source, ConnectionMessageEventArgs e) { MessageSent?.Invoke(source, e); }
void OnMessageSent(string json) => MessageSent?.Invoke(json);
public Task <ActionEvent> SendMsg(MessageSent msg, ActionEventListener listener = null) { return(new SendMsgAction(Context, msg) .ExecuteAsyncAuto()); }
private void SendWarningMessage(string message) { MessageSent?.Invoke(MessageType.Warning, message); }
protected virtual void OnMessageSent(string data) { MessageSent?.Invoke(this, data); }
/// <summary> /// Writes a producer request to the server asynchronously. /// </summary> /// <param name="request">The request to make.</param> /// <param name="callback">The code to execute once the message is completely sent.</param> /// <remarks> /// Do not dispose connection till callback is invoked, /// otherwise underlying network stream will be closed. /// </remarks> public void BeginWrite(ProducerRequest request, MessageSent<ProducerRequest> callback) { this.EnsuresNotDisposed(); Guard.NotNull(request, "request"); if (callback == null) { this.BeginWrite(request); return; } NetworkStream stream = client.GetStream(); var ctx = new RequestContext<ProducerRequest>(stream, request); byte[] data = request.RequestBuffer.GetBuffer(); stream.BeginWrite( data, 0, data.Length, delegate(IAsyncResult asyncResult) { var context = (RequestContext<ProducerRequest>)asyncResult.AsyncState; callback(context); context.NetworkStream.EndWrite(asyncResult); }, ctx); }
private void OnMessageSended(IPCMessage message) { MessageSent?.Invoke(this, message); }
/// <summary> /// Sends a list of messages to Kafka. /// </summary> /// <param name="topic">The topic to publish to.</param> /// <param name="partition">The partition to publish to.</param> /// <param name="messages">The list of messages to send.</param> /// <param name="callback"> /// A block of code to execute once the request has been sent to Kafka. This value may /// be set to null. /// </param> public void SendAsync(string topic, int partition, IList <Message> messages, MessageSent <ProducerRequest> callback) { SendAsync(new ProducerRequest(topic, partition, messages), callback); }
public Task <ActionEvent> SendMsg(MessageSent msg, ActionEventListener listener = null) { return(GetModule <IChatModule>().SendMsg(msg, listener)); }
protected virtual void OnMessageSent(Tuple <Guid, System.IO.Stream> e) { MessageSent?.Invoke(this, e); }
internal void TransferToBus(IBus bus) { var rebusEvents = bus.Advanced.Events; if (MessageContextEstablished != null) { foreach (var listener in MessageContextEstablished.GetInvocationList().Cast <MessageContextEstablishedEventHandler>()) { rebusEvents.MessageContextEstablished += listener; } } if (MessageSent != null) { foreach (var listener in MessageSent.GetInvocationList().Cast <MessageSentEventHandler>()) { rebusEvents.MessageSent += listener; } } if (BeforeMessage != null) { foreach (var listener in BeforeMessage.GetInvocationList().Cast <BeforeMessageEventHandler>()) { rebusEvents.BeforeMessage += listener; } } if (AfterMessage != null) { foreach (var listener in AfterMessage.GetInvocationList().Cast <AfterMessageEventHandler>()) { rebusEvents.AfterMessage += listener; } } if (BusStarted != null) { foreach (var listener in BusStarted.GetInvocationList().Cast <BusStartedEventHandler>()) { rebusEvents.BusStarted += listener; } } if (BusStopped != null) { foreach (var listener in BusStopped.GetInvocationList().Cast <BusStoppedEventHandler>()) { rebusEvents.BusStopped += listener; } } if (BeforeTransportMessage != null) { foreach (var listener in BeforeTransportMessage.GetInvocationList().Cast <BeforeTransportMessageEventHandler>()) { rebusEvents.BeforeTransportMessage += listener; } } if (AfterTransportMessage != null) { foreach (var listener in AfterTransportMessage.GetInvocationList().Cast <AfterTransportMessageEventHandler>()) { rebusEvents.AfterTransportMessage += listener; } } if (PoisonMessage != null) { foreach (var listener in PoisonMessage.GetInvocationList().Cast <PoisonMessageEventHandler>()) { rebusEvents.PoisonMessage += listener; } } if (UncorrelatedMessage != null) { foreach (var listener in UncorrelatedMessage.GetInvocationList().Cast <UncorrelatedMessageEventHandler>()) { rebusEvents.UncorrelatedMessage += listener; } } foreach (var messageMutator in MessageMutators) { rebusEvents.MessageMutators.Add(messageMutator); } foreach (var unitOfWorkManager in unitOfWorkManagers) { rebusEvents.AddUnitOfWorkManager(unitOfWorkManager); } }
protected virtual void OnMessageSent(Message message) { MessageSent?.Invoke(this, new MessageEvent(message)); }
public void SendMessage(Message msg) { MessageSent?.Invoke(this, msg); }
private void HandleMenuLogin(object sender, RoutedEventArgs e) { username = ""; var dialog = new LoginModal(); dialog.Owner = clientMiniCheckers; dialog.ShowDialog(); messageSent = MessageSent.LOGIN; username = dialog.GetUsername(); udpHandler.SendRequest(string.Format("LOGIN,{0},{1}", username, dialog.GetPassword())); }
/// <summary> /// Sends a list of messages to Kafka. /// </summary> /// <param name="topic">The topic to publish to.</param> /// <param name="partition">The partition to publish to.</param> /// <param name="messages">The list of messages to send.</param> /// <param name="callback"> /// A block of code to execute once the request has been sent to Kafka. This value may /// be set to null. /// </param> public void SendAsync(string topic, int partition, IList<Message> messages, MessageSent<ProducerRequest> callback) { SendAsync(new ProducerRequest(topic, partition, messages), callback); }
private void RequestResponseBackground_Thread() { while (true) { var response = udpHandler.GetResponse(); var action = ""; if (response.Equals("OKAY") || response.Equals("DONE")) { switch (messageSent) { case MessageSent.LOGIN: clientMiniCheckers.UpdateStatus("Logged on as " + username); clientMiniCheckers.MenuLoginSuccessful(); action = "Login"; break; case MessageSent.LOGOUT: clientMiniCheckers.UpdateStatus("Logged out"); clientMiniCheckers.MenuLogoutSuccessful(); username = ""; action = "Logout"; break; case MessageSent.NONE: action = "wrong message"; break; default: action = "Wrong message"; break; } } else if (response.Equals("ERROR")) { switch (messageSent) { case MessageSent.LOGIN: ShowLoginErrorDialog(); action = "Login"; break; case MessageSent.LOGOUT: action = "Logout"; break; case MessageSent.NONE: action = "wrong message"; break; default: action = "Wrong message"; break; } } Debug.WriteLine(action + ": " + response); messageSent = MessageSent.NONE; } }
/// <summary> /// Send a request to Kafka asynchronously. /// </summary> /// <remarks> /// If the callback is not specified then the method behaves as a fire-and-forget call /// with the callback being ignored. By the time this callback is executed, the /// <see cref="RequestContext.NetworkStream"/> will already have been closed given an /// internal call <see cref="NetworkStream.EndWrite"/>. /// </remarks> /// <param name="request">The request to send to Kafka.</param> /// <param name="callback"> /// A block of code to execute once the request has been sent to Kafka. This value may /// be set to null. /// </param> public void SendAsync(ProducerRequest request, MessageSent<ProducerRequest> callback) { if (request.IsValid()) { KafkaConnection connection = new KafkaConnection(Server, Port); if (callback == null) { // fire and forget connection.BeginWrite(request.GetBytes()); } else { // execute with callback connection.BeginWrite(request, callback); } } }
/// <summary> /// Constructs request and sent it to Kafka server asynchronously /// </summary> /// <param name="topic"> /// The topic. /// </param> /// <param name="partition"> /// The partition. /// </param> /// <param name="messages"> /// The list of messages to sent. /// </param> /// <param name="callback"> /// The callback invoked when a request is finished being sent. /// </param> public void Send(string topic, int partition, IEnumerable<Message> messages, MessageSent<ProducerRequest> callback) { Guard.Assert<ArgumentNullException>(() => !string.IsNullOrEmpty(topic)); Guard.Assert<ArgumentNullException>(() => messages != null); Guard.Assert<ArgumentException>(() => messages.All(x => x.PayloadSize <= this.Config.MaxMessageSize)); this.Send(new ProducerRequest(topic, partition, messages), callback); }
/// <summary> /// Sends request to Kafka server asynchronously /// </summary> /// <param name="request"> /// The request. /// </param> /// <param name="callback"> /// The callback invoked when a request is finished being sent. /// </param> public void Send(ProducerRequest request, MessageSent<ProducerRequest> callback) { this.EnsuresNotDisposed(); Guard.NotNull(request, "request"); Guard.NotNull(request.MessageSet, "request.MessageSet"); Guard.NotNull(request.MessageSet.Messages, "request.MessageSet.Messages"); Guard.Assert<ArgumentException>( () => request.MessageSet.Messages.All(x => x.PayloadSize <= this.Config.MaxMessageSize)); connection.BeginWrite(request, callback); }