private bool IsPacketAllowed(IMessageReader message, bool hostOnly) { if (Player == null) { return(false); } Game?game = Player.Game; // GameCode must match code of the current game assigned to the player. if (message.ReadInt32() != game.Code) { return(false); } // Some packets should only be sent by the host of the game. if (hostOnly) { if (game.HostId == Id) { return(true); } _logger.LogWarning("[{0}] Client sent packet only allowed by the host ({1}).", Id, game.HostId); return(false); } return(true); }
public Vector3 ReadByteAngles(IMessageReader reader) { float angleX = AngleByteToFloat(reader.ReadByte()); float angleY = (reader.ReadByte()); return new Vector3(angleX, angleY, 0); }
/// <summary> /// Create messageReader accroding to file extension /// </summary> /// <param name="CaptureFile">Capture file path</param> /// <returns></returns> IMessageReader CreateMessageReader(string CaptureFile) { IMessageReader reader = null; //Create and Initialize Message Meta data loader catalog MessageMetadataLoaderCatalog messageMetadataLoaderCatalog = new MessageMetadataLoaderCatalog(); messageMetadataLoaderCatalog.Initialize(monitor.Settings.ExtensionLoadPath); if (PersistUtils.IsUnparsedProjectFile(CaptureFile)) { //If capture file is an uncompressed project file reader = FileMessageReader.CreateReaderFromProjectFile(CaptureFile, messageMetadataLoaderCatalog); } else if (PersistUtils.IsCompressedUnparsedProjectFile(CaptureFile) || PersistUtils.IsCompressedProjectFile(CaptureFile)) { //If capture file is a compressed project file reader = FileMessageReader.CreateReaderFromCompressedFile(CaptureFile, messageMetadataLoaderCatalog); } else { //other file type, such as netmon capture file FileReaderCatalog fileReaderCatalog = new FileReaderCatalog(); fileReaderCatalog.Initialize(monitor.Settings.ExtensionLoadPath); IFileLoader fileLoader = fileReaderCatalog.GetRegisteredFileLoaders(CaptureFile).First(); reader = fileLoader.OpenFile(CaptureFile, fileLoader.CreateDefaultConfig(null)); } return(reader); }
public IPart Parse(IMessageReader reader, ContentType contentType, ContentDisposition contentDisposition, EContentTransferEncoding contentTransferEncoding, string boundary, string uid, string attachmentDirectory) { BoundedMessageReader reader2; MessagePart part = new MessagePart(); if (contentTransferEncoding == EContentTransferEncoding.Base64) { reader2 = new Base64MessageReader(reader, boundary); } else if (contentTransferEncoding == EContentTransferEncoding.QuotedPrintable) { reader2 = new QuotedPrintableMessageReader(reader, boundary); } else { reader2 = new UnencodedMessageReader(reader, boundary); } PopMessage message = new MailMessageParser().Parse(reader2, uid, attachmentDirectory); part.Message = message; if (reader2.FinalBoundaryReached) { this.RaiseFinalBoundaryReached(); } return(part); }
internal Message(string eventName, byte[] body, IBasicProperties basicProperties) { this.Body = body; this.BasicProperties = basicProperties; this.messageReader = null; this.EventName = eventName; }
public StoreMessages(IMessageReader messageReader, IMessageSender messageSender, ICosmosDbClient cosmosClient, IHealthTester healthTester) { _messageReader = messageReader; _messageSender = messageSender; _cosmosClient = cosmosClient; _healthTester = healthTester; }
public static void Deserialize(IMessageReader reader, out uint netId, out string id, out string version, out PluginSide side) { netId = reader.ReadPackedUInt32(); id = reader.ReadString(); version = reader.ReadString(); side = (PluginSide)reader.ReadByte(); }
public virtual void ParseUnencoded(IMessageReader reader, ContentType contentType, ContentDisposition contentDisposition, string boundary) { byte[] buffer; bool flag = false; byte[] data = new byte[] { 13, 10 }; Label_0019: buffer = reader.ReadLine(); if (!reader.EndOfMessage) { switch (BoundaryChecker.CheckBoundary(buffer, boundary)) { case EBoundaryType.NotBoundary: if (flag) { this.ContentWriter.Write(data); } this.ContentWriter.Write(buffer); flag = true; goto Label_0019; case EBoundaryType.Final: this.RaiseFinalBoundaryReached(); break; } } }
private static void HandleToServer(string source, IMessageReader packet) { var tagName = TagMap.ContainsKey(packet.Tag) ? TagMap[packet.Tag] : "Unknown"; Console.ForegroundColor = ConsoleColor.White; Console.WriteLine($"{source,-15} Server received: {packet.Tag,-2} {tagName}"); switch (packet.Tag) { case 0: Console.WriteLine("- GameInfo length " + packet.ReadBytesAndSize().Length); break; case 1: Console.WriteLine("- GameCode " + packet.ReadInt32()); Console.WriteLine("- Unknown " + packet.ReadByte()); break; case 5: case 6: Console.WriteLine("- GameCode " + packet.ReadInt32()); Console.WriteLine(HexUtils.HexDump(packet.Buffer.ToArray().Take(packet.Length).ToArray())); // packet.Position = packet.Length; break; } }
protected override byte PacketProperty => 0x08; // LiteNetLib.PacketProperty.UnconnectedMessage public MasterServerMessageSource( MessagingConfiguration configuration, IMessageReader messageReader, IEncryptedMessageReader encryptedMessageReader) : base(configuration, messageReader, encryptedMessageReader) { }
public FrmTip(IMessageReader IReader) { InitializeComponent(); reader = IReader; TrasenClasses.GeneralControls.ListViewEx lstMessage = new TrasenClasses.GeneralControls.ListViewEx(); lstMessage.View = View.Details; lstMessage.Dock = DockStyle.Fill; lstMessage.FullRowSelect = true; lstMessage.HideSelection = false; this.plContent.Controls.Add(lstMessage); if (reader is LISMessageReader) { lstMessage.Columns.Add("验单号"); lstMessage.Columns.Add("内容"); lstMessage.Columns.Add("状态"); lstMessage.Columns[0].Width = 0; lstMessage.Columns[1].Width = 300; foreach (MessageStruct message in reader.Messages) { ListViewItem item = new ListViewItem(); item.Text = message.KeyFieldValue.ToString(); item.SubItems.Add(message.Content); item.SubItems.Add(message.IsRead ? "已阅" : "未读"); item.Tag = message; lstMessage.Items.Add(item); } } lstMessage.DoubleClick += new EventHandler(lstMessage_DoubleClick); }
public static void Deserialize(IMessageReader reader, out int announcementVersion, out int id, out Language language) { reader.ReadByte(); // SendOption header, probably added by accident announcementVersion = reader.ReadPackedInt32(); id = reader.ReadPackedInt32(); language = (Language)reader.ReadPackedInt32(); }
public QueueMonitor(IMessageReader reader, IMessageConverter converter, MessageValidator validator, IValidationOutput output) { _reader = reader; _converter = converter; _validator = validator; _output = output; }
private static void WritePacket(PacketSerializationContext context, IMessageReader reader, MessageType messageType) { context.Writer.Write((byte)messageType); context.Writer.Write((byte)reader.Tag); context.Writer.Write((int)reader.Length); context.Writer.Write(reader.Buffer, reader.Offset, reader.Length); }
private SlotMachineEngine() { this.symbolFactory = new SymbolFactory(); this.messageWriter = new ConsoleMessageWriter(); this.messageReader = new ConsoleMessageReader(); this.player = new Player(); }
/// <summary> /// Reads the equipment data from a message reader /// </summary> /// <param name="reader"></param> protected override void readData(IMessageReader reader) { int numArmorSlots = reader.ReadInt(); for (int i = 0; i < numArmorSlots; i++) { ArmorType type = (ArmorType)reader.ReadByte(); string frameId = reader.ReadString(); Frame frame = Frame.FindFrameById(frameId); if (frame != null) { StartCoroutine(equipAmorDeferred(frame)); } } int numCombatItemSlots = reader.ReadInt(); for (int i = 0; i < numCombatItemSlots; i++) { int index = reader.ReadInt(); Frame frame = Frame.FindFrameById(reader.ReadString()); if (frame != null) { StartCoroutine(equipCombatItemDeferred(index, frame)); } } }
public ValueTask HandleMessageAsync(IClient client, IMessageReader reader, MessageType messageType) { var clientInfo = client.GetReactor(); if (clientInfo == null) { return(default);
public void MessageHandlerFactoryCreatorWriteTestMethod() { IMessageHandlerFactory _nmf = new MyMessageHandlerFactory(Guid.NewGuid()); Assert.IsNotNull(_nmf); IMessageReader _nmr = _nmf.GetIMessageReader("UDP", null, null); }
private static Vector2 ReadVector2(IMessageReader reader) { var v1 = reader.ReadUInt16() / (float)ushort.MaxValue; var v2 = reader.ReadUInt16() / (float)ushort.MaxValue; return(new Vector2(XRange.Lerp(v1), YRange.Lerp(v2))); }
/// <summary> /// Initialises a new instance of the <see cref="RecordingMessageReader"/> class and /// specified the inner message reader, the output stream and a value indicating if the /// decorator owns the output. /// </summary> /// <param name="inner">The inner message reader.</param> /// <param name="output">The output stream.</param> /// <param name="ownsOutput"><see langword="true"/> if the decorator owns the specified output /// stream, otherwise; <see langword="false"/>.</param> /// <exception cref="System.ArgumentNullException"> /// Thrown when <paramref name="inner"/> or <paramref name="output"/> is /// <see langword="null"/>. /// </exception> public RecordingMessageReader(IMessageReader inner, Stream output, bool ownsOutput) { Guard.NotNull(inner, "inner"); Guard.NotNull(output, "output"); Initialise(inner, output, ownsOutput); }
/// <summary> /// Deserialize a packet/message to a new GameOptionsData object. /// </summary> /// <param name="reader">Message reader object containing the raw message.</param> /// <returns>GameOptionsData object.</returns> public static GameOptionsData DeserializeCreate(IMessageReader reader) { var options = new GameOptionsData(); options.Deserialize(reader.ReadBytesAndSize()); return(options); }
public static void TestReadMessages(IMessageReader messageReader) { IMessageReader _messageReader = messageReader; _messageReader.ReadMessage(); XmlDocument messageXML = new XmlDocument(); messageXML.Load(@"C:\Temp\RequestMessage_1423572802_File187E1E8A7F16147A6B87962E07933B406_acknowledgement_20150210125836_.xml"); string[] results = _messageReader.GetMessageResults <string[]>(); foreach (var s in results) { Console.WriteLine(s); } // GovTalkMessage message = _messageReader.Message(messageXML.ToXDocument()); string bodytype = _messageReader.GetBodyType(); Console.WriteLine(bodytype); ErrorResponse err = _messageReader.GetBody <ErrorResponse>(); }
public static void Deserialize(IMessageReader reader, out int gameCode, out byte unknown) { var slice = reader.ReadBytes(sizeof(Int32) + sizeof(byte)).Span; gameCode = slice.ReadInt32(); unknown = slice.ReadByte(); }
public static void Deserialize(IMessageReader reader, out AlterGameTags gameTag, out bool isPublic) { var slice = reader.ReadBytes(sizeof(byte) + sizeof(byte)).Span; gameTag = (AlterGameTags)slice.ReadByte(); isPublic = slice.ReadBoolean(); }
public void Deserialize(IMessageReader reader) { PlayerName = reader.ReadString(); Color = (ColorType)reader.ReadPackedInt32(); Hat = (HatType)reader.ReadPackedUInt32(); Pet = (PetType)reader.ReadPackedUInt32(); Skin = (SkinType)reader.ReadPackedUInt32(); var flag = reader.ReadByte(); Disconnected = (flag & 1) > 0; IsImpostor = (flag & 2) > 0; IsDead = (flag & 4) > 0; var taskCount = reader.ReadByte(); if (Tasks.Count != taskCount) { Tasks = new List <InnerGameData.TaskInfo>(taskCount); } for (var i = 0; i < taskCount; i++) { Tasks[i] ??= new InnerGameData.TaskInfo(); Tasks[i].Deserialize(reader); } }
public Enumerator(Session session, MessageQueue messageQueue, IMessageReader reader) { this.session = session; this.innerEnumerator = messageQueue.GetMessageEnumerator2(); this.reader = reader; }
/// <summary> /// Deserialize a packet. /// </summary> /// <param name="reader"><see cref="IMessageReader" /> with <see cref="IMessageReader.Tag" /> 0.</param> /// <param name="chatMode">The chat type selected in the client of the player.</param> /// <returns>Deserialized <see cref="GameOptionsData" />.</returns> public static GameOptionsData Deserialize(IMessageReader reader, out QuickChatModes chatMode) { var gameOptionsData = GameOptionsData.DeserializeCreate(reader); chatMode = (QuickChatModes)reader.ReadByte(); return(gameOptionsData); }
/// <summary> /// Deserialize a packet. /// </summary> /// <param name="reader"><see cref="IMessageReader" /> with <see cref="IMessageReader.Tag" /> 0.</param> /// <param name="chatType">The chat type selected in the client of the player.</param> /// <returns>Deserialized <see cref="GameOptionsData" />.</returns> public static GameOptionsData Deserialize(IMessageReader reader, out ChatType chatType) { var gameOptionsData = GameOptionsData.DeserializeCreate(reader); chatType = (ChatType)reader.ReadByte(); return(gameOptionsData); }
/// <summary>Initializes a new instance of the <see cref="TextMessageProvider"/> class.</summary> /// <param name="name">The name.</param> /// <param name="path">The path.</param> /// <param name="format">The message format.</param> public TextMessageProvider(string name, string path, MessageFormat format) { Name = name; Path = path; MessageFormat messageFormat = format; IMessageParser messageParser = messageFormat == MessageFormat.Motorola ? (IMessageParser) new MotorolaTextMessageParser() : new NokiaTextMessageParser(); textMessageReader = new TextMessageReader { MessageParser = messageParser }; }
public Controller(IMessageReader messageReader, SCG.IEnumerable <IMessageWriter> messageWriters, IOrderBookWriter orderBookWriter, ILogger logger) { _messageReader = messageReader; _messageWriters = messageWriters; _orderBookWriter = orderBookWriter; _logger = logger; _orderPool = new OrderPool(logger); }
internal void RemoveMessageReader(IMessageReader messageReader) { if (messageReader == null) { throw new ArgumentNullException("messageReader"); } messageReader.ReadMessageCompleted -= MessageHandler; }
public Vector3 ReadVector3(IMessageReader reader) { float x = reader.ReadFloat(); float y = reader.ReadFloat(); float z = reader.ReadFloat(); return new Vector3(x, y, z); }
/// <summary> /// Handles the receiving of data. /// </summary> /// <param name="message">The buffer containing the bytes received.</param> internal virtual async ValueTask HandleReceive(MessageReader message, int bytesReceived) { // Check if the first message received is the hello packet. if (_isFirst) { _isFirst = false; // Slice 4 bytes to get handshake data. if (_listener != null) { using (IMessageReader handshake = message.Copy(4)) { await _listener.InvokeNewConnection(handshake, this); } } } switch (message.Buffer[0]) { //Handle reliable receives case (byte)MessageType.Reliable: await ReliableMessageReceive(message, bytesReceived); break; //Handle acknowledgments case (byte)UdpSendOption.Acknowledgement: AcknowledgementMessageReceive(message.Buffer, bytesReceived); break; //We need to acknowledge hello and ping messages but dont want to invoke any events! case (byte)UdpSendOption.Ping: await ProcessReliableReceive(message.Buffer, 1); Statistics.LogHelloReceive(bytesReceived); break; case (byte)UdpSendOption.Hello: await ProcessReliableReceive(message.Buffer, 1); Statistics.LogHelloReceive(bytesReceived); break; case (byte)UdpSendOption.Disconnect: message.Offset = 1; message.Position = 0; await DisconnectRemote("The remote sent a disconnect request", message); break; //Treat everything else as unreliable default: await InvokeDataReceived(MessageType.Unreliable, message, 1, bytesReceived); Statistics.LogUnreliableReceive(bytesReceived - 1, bytesReceived); break; } }
public override async ValueTask HandleMessageAsync(IMessageReader reader, MessageType messageType) { var flag = reader.Tag; Logger.Verbose("Server got {0}.", flag); switch (flag) { case MessageFlags.HostGame: { using var packet = MessageWriter.Get(MessageType.Reliable); Message13RedirectS2C.Serialize(packet, false, _nodeProvider.Get()); await Connection.SendAsync(packet); break; } case MessageFlags.JoinGame: { Message01JoinGameC2S.Deserialize( reader, out var gameCode, out _); using var packet = MessageWriter.Get(MessageType.Reliable); var endpoint = await _nodeLocator.FindAsync(GameCodeParser.IntToGameName(gameCode)); if (endpoint == null) { Message01JoinGameS2C.SerializeError(packet, false, DisconnectReason.GameMissing); } else { Message13RedirectS2C.Serialize(packet, false, endpoint); } await Connection.SendAsync(packet); break; } case MessageFlags.GetGameListV2: { // TODO: Implement. using var packet = MessageWriter.Get(MessageType.Reliable); Message01JoinGameS2C.SerializeError(packet, false, DisconnectReason.Custom, DisconnectMessages.NotImplemented); await Connection.SendAsync(packet); break; } default: { Logger.Warning("Received unsupported message flag on the redirector ({0}).", flag); break; } } }
public void Send(IMessageReader reader) { int bytesRead = 0; byte[] buffer = new byte[1024]; do { bytesRead = reader.Read(buffer, 0, buffer.Length); } while (bytesRead > 0); }
public async Task SendAsync(IMessageReader reader) { int bytesRead = 0; byte[] buffer = new byte[1024]; do { bytesRead = await reader.ReadAsync(buffer, 0, buffer.Length); } while (bytesRead > 0); }
public void Deserialize(IMessageReader reader) { var num = reader.ReadByte(); VotedFor = (sbyte)((num & VoteMask) - 1); IsDead = (num & DeadBit) > 0; DidVote = (num & VotedBit) > 0; DidReport = (num & ReportedBit) > 0; }
private void ConvertHeaders(IMessageReader input, IMessageBuilder output) { var headerCount = input.ItemCount; output.BeginHeaders(headerCount); for (; headerCount > 0; headerCount--) { input.Read(); output.WriteHeader(input.PropertyName, input.StringValue); } output.EndHeaders(); }
/// <summary> /// Initilises a new instance of the <see cref="AK.F1.Timing.Server.Proxy.ProxySessionManager"/> /// class and specified the source <see cref="AK.F1.Timing.IMessageReader"/>. /// </summary> /// <param name="reader">The source <see cref="AK.F1.Timing.IMessageReader"/>.</param> /// <exception cref="System.ArgumentNullException"> /// Thrown when <paramref name="reader"/> is <see langword="null"/>. /// </exception> public ProxySessionManager(IMessageReader reader) { Guard.NotNull(reader, "reader"); _messageReader = reader; _cancellationToken = _cancellationTokenSource.Token; _readMessagesTask = new Task(ReadMessagesTask, _cancellationToken); _readMessagesTask.ContinueFaultWith(_ => Dispose()); _readMessagesTask.Start(); _mainTask = new Task(MainTask, _cancellationToken); _mainTask.ContinueFaultWith(_ => Dispose()); _mainTask.Start(); }
public ErrorMessageRecoveryHandler( IQueueRetrieval queueRetreival, IMessageWriter messageWriter, IMessageReader messageReader, IErrorRetry errorRetry, IDeleteFiles errorDelete, IPurgeQueue errorPurge) { _queueRetreival = queueRetreival; _messageWriter = messageWriter; _messageReader = messageReader; _errorRetry = errorRetry; _errorDelete = errorDelete; _errorPurge = errorPurge; }
public Program( ArgParser argParser, IQueueRetreival queueRetreival, IMessageWriter messageWriter, IMessageReader messageReader, IQueueInsertion queueInsertion, IErrorRetry errorRetry) { this.argParser = argParser; this.queueRetreival = queueRetreival; this.messageWriter = messageWriter; this.messageReader = messageReader; this.queueInsertion = queueInsertion; this.errorRetry = errorRetry; }
private void ConvertArrayContent(IMessageReader reader, IObjectBuilder builder) { var itemCount = reader.ItemCount; builder.BeginArray(itemCount); for (; itemCount > 0; itemCount--) { builder.BeginItem(); reader.Read(); ConvertValue(reader, builder); builder.EndItem(); } builder.EndArray(); }
private void ConvertStructContent(IMessageReader reader, IObjectBuilder builder) { var elementCount = reader.ItemCount; builder.BeginStruct(reader.ItemCount); for (; elementCount > 0; elementCount--) { builder.BeginItem(); reader.Read(); builder.WritePropertyName(reader.PropertyName); ConvertValue(reader, builder); builder.EndItem(); } builder.EndStruct(); }
public void Convert(IMessageReader input, IMessageBuilder output) { if (!input.Read()) { throw new ProtocolException("Packet Header not recognized."); } output.BeginMessage(input.MessageType); input.Read(); if (input.ReadState == ReadState.Headers) { ConvertHeaders(input, output); input.Read(); } output.BeginContent(); if (input.MessageType == MessageType.Request) { input.Read(); output.SetMethod(input.StringValue); input.Read(); ConvertArrayContent(input, output); } else { while(input.Read() && input.ReadState == ReadState.Body) { ConvertValue(input, output); } } output.EndContent(); output.EndMessage(); input.Read(); if (input.ReadState != ReadState.EndOfFile) { throw new ProtocolException("Expected EndOfFile"); } }
public ConsumerCallbackEventArgs(IMessageReader reader) { this.reader = reader; }
private static void Read(IMessageReader reader) { Log.Info("connecting..."); try { using(reader) { Message message; while((message = reader.Read()) != null) { Log.Info(message.ToString()); } } Log.Info("disconnected"); } catch(Exception exc) { Log.Error(exc); } }
public void SetUp() { conventions = new Conventions(new TypeNameSerializer()); messageReader = new MessageReader(); }
public static void TestReadMessages(IMessageReader messageReader) { IMessageReader _messageReader = messageReader; _messageReader.ReadMessage(); XmlDocument messageXML = new XmlDocument(); messageXML.Load(@"C:\Temp\RequestMessage_1423572802_File187E1E8A7F16147A6B87962E07933B406_acknowledgement_20150210125836_.xml"); string[] results = _messageReader.GetMessageResults<string[]>(); foreach (var s in results) { Console.WriteLine(s); } // GovTalkMessage message = _messageReader.Message(messageXML.ToXDocument()); string bodytype = _messageReader.GetBodyType(); Console.WriteLine(bodytype); ErrorResponse err = _messageReader.GetBody<ErrorResponse>(); }
private void Initialise(IMessageReader inner, Stream output, bool ownsOutput) { Inner = inner; Output = output; OwnsOutput = ownsOutput; Writer = new DecoratedObjectWriter(output); Stopwatch = new Stopwatch(); }
public CallbackExceptionEventArgs(Exception exception, IMessageReader reader) { this.exception = exception; this.detail = new Hashtable(); this.reader = reader; }
/// <summary> /// Initialises a new instance of the <see cref="RecordingMessageReader"/> class and /// specified the inner message reader and the output file path. /// </summary> /// <param name="inner">The inner message reader.</param> /// <param name="path">The output file path.</param> /// <exception cref="System.ArgumentNullException"> /// Thrown when <paramref name="inner"/> or <paramref name="path"/> is /// <see langword="null"/>. /// </exception> /// <exception cref="System.IO.IOException"> /// Thrown when an IO error occurs whilst creating the internal /// <see cref="System.IO.FileStream"/> using the supplied arguments. /// </exception> public RecordingMessageReader(IMessageReader inner, string path) { Guard.NotNull(inner, "inner"); Initialise(inner, new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None), true); }
public void Send(IMessageReader reader) { throw new NotImplementedException(); }
public void SetUp() { messageReader = new MessageReader(); }
internal void RemoveMessageReader(IMessageReader messageReader) { if (messageReader == null) throw new ArgumentNullException("messageReader"); messageReader.ReadMessageCompleted -= MessageHandler; }
public BrokerNackEventArgs(IMessageReader reader, IHeaderProperties properties) { this.reader = reader; this.properties = properties; }
public void SetUp() { conventions = new Conventions(); messageReader = new MessageReader(); }
private void RunCore(IMessageReader reader, IPEndPoint endpoint, int connectionBacklog) { using(var server = new TcpServer( endpoint: endpoint ?? new IPEndPoint(IPAddress.Any, ProxyMessageReader.DefaultPort), handler: new ProxySessionManager(reader), backlog: connectionBacklog)) { server.Start(); CmdLineCancelKey.WaitFor().Dispose(); } }
/// <summary> /// Initializes a new instance of the <see cref="MessageEventArg" /> class. /// </summary> /// <param name="newMessage">The new message to be processed by the consumer or a producer outcome to be /// sent over the network by the underlying message transport protocol.</param> /// <param name="dataSetId">The data set identifier.</param> /// <param name="producerId">The producer identifier.</param> public MessageEventArg(IMessageReader newMessage, UInt16 dataSetId, Guid producerId) { MessageContent = newMessage; DataSetId = dataSetId; ProducerId = producerId; }
private void ConvertValue(IMessageReader reader, IObjectBuilder builder) { switch (reader.ValueType) { case ContentType.Array: ConvertArrayContent(reader, builder); break; case ContentType.Struct: ConvertStructContent(reader, builder); break; case ContentType.Int: builder.WriteInt32Value(reader.IntValue); break; case ContentType.Boolean: builder.WriteBooleanValue(reader.BooleanValue); break; case ContentType.String: builder.WriteStringValue(reader.StringValue); break; case ContentType.Float: builder.WriteDoubleValue(reader.DoubleValue); break; case ContentType.Base64: builder.WriteBase64String(reader.StringValue); break; default: throw new ArgumentOutOfRangeException(); } }
public Task SendAsync(IMessageReader reader) { throw new NotImplementedException(); }