コード例 #1
0
 private void CheckFlags(DataIdentifier _stepDataIdentifier1, Packet packet, DataIdentifier _stepDataIdentifier2 = DataIdentifier.Null, int WaitingTime = 1000)
 {
     stepDataIdentifier1          = _stepDataIdentifier1;
     stepDataIdentifier2          = _stepDataIdentifier2;
     receivePacket.dataIdentifier = DataIdentifier.CLOSE;
     ChangeProgressData(stepDataIdentifier1.ToString());
     while (receivePacket.dataIdentifier != stepDataIdentifier1 && receivePacket.dataIdentifier != stepDataIdentifier2 && !stopped)
     {
         if (stopped || failed)
         {
             return;
         }
         try
         {
             if (client != null)
             {
                 client.SendMessage(packet);
             }
         }
         catch
         {
             client = null;
         }
         Thread.Sleep(WaitingTime);
     }
     if (!failed && !stopped)
     {
         SaveProgress(new ProgressComputerData("Images/Done.ico", computer.Name, receivePacket.dataIdentifier.ToString()));
     }
 }
コード例 #2
0
ファイル: Packet.cs プロジェクト: baotranvu/baotranvu
 //Default Contructor
 public Packet()
 {
     identifier = DataIdentifier.Null;
     message    = null;
     sender     = null;
     receiver   = null;
 }
コード例 #3
0
        private void saveSignalData(DataIdentifier identifier)
        {
            string signalDataStore = ConfigurationManager.AppSettings.Get("DefaultSignalDataStore");

            signalDataStore = signalDataStore.EndsWith("\\") ? signalDataStore.Substring(0, (signalDataStore.Length - 1)) : signalDataStore;

            if (!Directory.Exists(signalDataStore))
            {
                Directory.CreateDirectory(signalDataStore);
            }

            string signalDataDirectory = String.Format("{0}\\{1}", signalDataStore, identifier.DataUniqueID);

            if (!Directory.Exists(signalDataDirectory))
            {
                Directory.CreateDirectory(signalDataDirectory);
            }

            string filePath = String.Format("{0}\\{1}.bmp", signalDataDirectory, DateTime.Now.ToString("yyyy-MM-dd-hh-mm-ss"));

            using (FileStream fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                byte[] rawDataByte = ((object[])(identifier.RawData))[0] as byte[];

                fileStream.Write(rawDataByte, 0, rawDataByte.Length);
            }

            this.currentSignalFile = filePath;
        }
コード例 #4
0
        private void startListener()
        {
            this.communicationManager = new CommunicationManager()
            {
                LocalAddress  = ConfigurationManager.AppSettings.Get("LocalAddress"),
                RemoteAddress = ConfigurationManager.AppSettings.Get("RemoteAddress"),
                LocalPort     = int.Parse(ConfigurationManager.AppSettings.Get("LocalPort")),
                RemotePort    = int.Parse(ConfigurationManager.AppSettings.Get("RemotePort")),
                TimeToLive    = int.Parse(ConfigurationManager.AppSettings.Get("TimeToLive"))
            };

            this.communicationManager.Start();

            byte[] bytesReceived = null;

            int bytesCount = -1;

            while (true)
            {
                bytesReceived = this.communicationManager.Receive(out bytesCount);

                if ((bytesCount > 0) && (bytesReceived != null) && (bytesReceived.Length > 0))
                {
                    DataIdentifier identifier = CommonUtility.BinaryDeserialize(bytesReceived) as DataIdentifier; //JsonUtility.JsonDeserialize(bytesReceived, typeof(DataIdentifier), null, null) as DataIdentifier;

                    DataPair pair = this.doAcquisition(identifier);

                    this.saveDataPair(pair);

                    Thread thread = new Thread(this.threadProcSafe);

                    thread.Start(pair);
                }
            }
        }
コード例 #5
0
        public void Read(BinaryReader reader, ModSaveInfo info)
        {
            dataLength    = reader.ReadInt64();
            dataID        = DataIdentifier.Read(reader);
            IsCustomModel = reader.ReadBoolean();
            switch (dataID.Type)
            {
            case IdentifierType.ACTOR:
                ReadData <CustomActorData, VanillaActorData>(reader, info);
                break;

            case IdentifierType.GADGET:
                ReadData <CustomGadgetData, VanillaGadgetData>(reader, info);
                break;

            case IdentifierType.LANDPLOT:
                ReadData <CustomLandPlotData, VanillaPlotData>(reader, info);
                break;

            case IdentifierType.GORDO:
                ReadData <GordoV01>(reader);
                break;

            case IdentifierType.TREASUREPOD:
                ReadData <TreasurePodV01>(reader);
                break;

            case IdentifierType.EXCHANGEOFFER:
                ReadData <ExchangeOfferV04>(reader);
                break;

            default:
                throw new NotImplementedException();
            }
        }
コード例 #6
0
        public virtual void Notify(DataIdentifier Identifier)
        {
            this.DataIdentifier = Identifier;

            if (this.communicationManager == null)
            {
                this.communicationManager = new CommunicationManager()
                {
                    RemoteAddress = ModuleConfiguration.Default_MulticastAddress,
                    RemotePort    = ModuleConfiguration.Default_MulticastPort,
                    LocalAddress  = ModuleConfiguration.Default_LocalAddress,
                    LocalPort     = ModuleConfiguration.Default_LocalPort,
                    TimeToLive    = ModuleConfiguration.Default_TimeToLive,
                    PipeName      = ModuleConfiguration.Default_PipeName
                };

                //this.communicationManager.Start();

                this.communicationManager.Start((int)(ModuleConfiguration.Default_CommunicationType));
            }

            byte[] data = CommonUtility.BinarySerialize(Identifier); //JsonUtility.JsonSerialize(Identifier, null, null);

            this.communicationManager.Send(data);
        }
コード例 #7
0
        /// <summary>
        /// Read a specified clipboard data, encrypt and save it into a file.
        /// </summary>
        /// <param name="clipboardReader">The <see cref="ClipboardReader"/> used to read the data.</param>
        /// <param name="identifier">The data identifier.</param>
        /// <param name="clipboardDataPath">The full path to the clipboard data folder.</param>
        private void WriteClipboardDataToFile(ClipboardReader clipboardReader, DataIdentifier identifier, string clipboardDataPath)
        {
            Requires.NotNull(clipboardReader, nameof(clipboardReader));
            Requires.NotNull(identifier, nameof(identifier));
            Requires.NotNullOrWhiteSpace(clipboardDataPath, nameof(clipboardDataPath));

            var dataFilePath = Path.Combine(clipboardDataPath, $"{identifier.Identifier}.dat");

            if (File.Exists(dataFilePath))
            {
                Logger.Instance.Fatal(new FileLoadException($"The file {dataFilePath} already exists."));
            }

            var dataPassword = SecurityHelper.ToSecureString(SecurityHelper.EncryptString(SecurityHelper.ToSecureString(identifier.Identifier.ToString())));

            Requires.NotNull(dataPassword, nameof(dataPassword));

            clipboardReader.BeginRead(identifier.FormatName);
            Requires.IsTrue(clipboardReader.IsReadable);
            Requires.IsTrue(clipboardReader.CanReadNextBlock());

            using (var fileStream = File.OpenWrite(dataFilePath))
                using (var aesStream = new AesStream(fileStream, dataPassword, SecurityHelper.GetSaltKeys(dataPassword).GetBytes(16)))
                {
                    aesStream.AutoDisposeBaseStream = false;
                    while (clipboardReader.CanReadNextBlock())
                    {
                        var buffer = clipboardReader.ReadNextBlock();
                        aesStream.Write(buffer, 0, buffer.Length);
                    }
                    aesStream.Position = 0;
                }

            clipboardReader.EndRead();
        }
コード例 #8
0
        void timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            string data = e.SignalTime.ToString("yyyy-MM-dd-hh-mm-ss-ffffzzz").Replace("+", "A").Replace(":", "-");//e.SignalTime.ToLongDateString();

            DataIdentifier dataIdentifier = new DataIdentifier()
            {
                DataUniqueID = Guid.NewGuid().ToString(),
                RawData      = new object[] { data }
            };

            if (!this.isTesting)
            {
                base.Notify(dataIdentifier);
            }

            if (this.TimerCallBack != null)
            {
                this.TimerCallBack(this, new TimerDetectorEventArgs()
                {
                    DataIdentifier = dataIdentifier
                });
            }
            //else
            //{
            //    base.Notify(dataIdentifier);
            //}
        }
コード例 #9
0
ファイル: Packet.cs プロジェクト: TomasVetrik/GDS
 public Packet(DataIdentifier _ID, ComputerDetailsData _computerDetailsData, string _message)
 {
     this.dataIdentifier      = _ID;
     this.computerDetailsData = _computerDetailsData;
     this.IDTime          = DateTime.Now;
     this.clonningMessage = _message;
 }
コード例 #10
0
 private void OnEntitySelected(Data entity)
 {
     this.selectedEntity            = entity;
     this.selectedDataIdentifier    = null;
     this.selectedDataIdentifierKey = null;
     this.wasDataIdentifierSelected = false;
 }
コード例 #11
0
        public void Write(BinaryWriter writer, ModSaveInfo info)
        {
            long start = writer.BaseStream.Position;

            writer.Write(0L);
            IsCustomModel = info.BelongsToMe(data);
            DataIdentifier.Write(writer, dataID);
            writer.Write(IsCustomModel);
            switch (dataID.Type)
            {
            case IdentifierType.ACTOR:
                WriteData <CustomActorData>(writer, info);
                break;

            case IdentifierType.GADGET:
                WriteData <CustomGadgetData>(writer, info);
                break;

            default:
                throw new NotImplementedException();
            }

            long current = writer.BaseStream.Position;

            writer.BaseStream.Seek(start, SeekOrigin.Begin);
            dataLength = current - start;
            writer.Write(dataLength);
            writer.BaseStream.Seek(current, SeekOrigin.Begin);
        }
コード例 #12
0
ファイル: ClipboardService.cs プロジェクト: metaseed/Metakey
        /// <summary>
        /// Write a specified clipboard data from an encrypted file.
        /// </summary>
        /// <param name="clipboardWriter">The <see cref="ClipboardWriter"/> used to write the data.</param>
        /// <param name="identifier">The data identifier.</param>
        /// <param name="clipboardDataPath">The full path to the clipboard data folder.</param>
        private void ReadFileToClipboardData(ClipboardWriter clipboardWriter, DataIdentifier identifier, string
                                             clipboardDataPath)
        {
            Requires.NotNull(clipboardWriter, nameof(clipboardWriter));
            Requires.NotNull(identifier, nameof(identifier));
            Requires.NotNullOrWhiteSpace(clipboardDataPath, nameof(clipboardDataPath));
            var dataFilePath = Path.Combine(clipboardDataPath, $"{identifier.Identifier}.dat");

            if (!File.Exists(dataFilePath))
            {
                return;
            }

            var dataPassword =
                SecurityHelper.ToSecureString(SecurityHelper.EncryptString(SecurityHelper.ToSecureString(
                                                                               identifier.Identifier.ToString(
                                                                                   ))));

            Requires.NotNull(dataPassword, nameof(dataPassword));
            var fileStream = File.OpenRead(dataFilePath);
            var aesStream  = new AesStream(fileStream, dataPassword,
                                           SecurityHelper.GetSaltKeys(dataPassword).GetBytes(16));

            clipboardWriter.AddData(identifier.FormatName, aesStream, fileStream);
        }
コード例 #13
0
        private void SetControls(DataIdentifier identifier)
        {
            if (this.pictureBoxSignalPreview.InvokeRequired)
            {
                SetImageCallBack setImageCallBack = new SetImageCallBack(this.SetControls);

                this.Invoke(setImageCallBack, identifier);
            }
            else
            {
                //this.pictureBoxSignalPreview.Image = ((object[])(identifier.RawData))[0] as Bitmap;

                using (MemoryStream stream = new MemoryStream((((object[])(identifier.RawData))[0]) as byte[]))
                {
                    this.pictureBoxSignalPreview.Image = System.Drawing.Bitmap.FromStream(stream);
                }

                this.pictureBoxSignalPreview.Refresh();
            }

            if (this.listBoxBarCodesExtracted.InvokeRequired)
            {
                SetBarCodeListCallBack setBarCodeListCallBack = new SetBarCodeListCallBack(this.SetControls);

                this.Invoke(setBarCodeListCallBack, identifier);
            }
            else
            {
                this.listBoxBarCodesExtracted.DataSource = ((object[])(identifier.RawData))[1];//new string[] { Identifier.DataUniqueID};
                this.listBoxBarCodesExtracted.Refresh();
            }
        }
コード例 #14
0
        public Packet(byte[] dataStream)
        {
            // Read the data identifier from the beginning of the stream (4 bytes)
            this.dataIdentifier = (DataIdentifier)BitConverter.ToInt32(dataStream, 0);

            // Read the length of the name (4 bytes)
            int nameLength = BitConverter.ToInt32(dataStream, 4);

            // Read the length of the message (4 bytes)
            int msgLength = BitConverter.ToInt32(dataStream, 8);

            // Read the name field
            if (nameLength > 0)
            {
                this.name = Encoding.UTF8.GetString(dataStream, 12, nameLength);
            }
            else
            {
                this.name = null;
            }

            // Read the message field
            if (msgLength > 0)
            {
                this.message = Encoding.UTF8.GetString(dataStream, 12 + nameLength, msgLength);
            }
            else
            {
                this.message = null;
            }
        }
コード例 #15
0
        public void WriteData(BinaryWriter writer)
        {
            writer.Write(ammoDataEntries.Count);
            foreach (var entry in ammoDataEntries)
            {
                entry.Write(writer);
            }
            writer.Write(segments.Count);
            foreach (var mod in segments)
            {
                mod.Write(writer);
                Debug.Log($"Saving mod {mod.modid} which is {mod.byteLength} bytes long");
            }

            enumTranslator.Write(writer);

            writer.Write(partialData.Count);

            foreach (var pair in partialData)
            {
                DataIdentifier.Write(writer, pair.Key);
                pair.Value.Write(writer);
            }

            appearancesData.Write(writer);
        }
コード例 #16
0
 public static GameObject InstantiateActorWithData(long actorId, GameObject prefab, RegionRegistry.RegionSetId id, Vector3 pos, Quaternion rot, CompoundDataPiece data)
 {
     preparedData.Add(DataIdentifier.GetActorIdentifier(actorId), new PreparedData()
     {
         Data = data, SourceType = PreparedData.PreparationSource.SPAWN
     });
     return(SceneContext.Instance.GameModel.InstantiateActor(actorId, prefab, id, pos, rot, false, false));
 }
コード例 #17
0
 public Packet(string friendName)
 {
     dataIdentifier = DataIdentifier.Null;
     message        = null;
     senderName     = null;
     recipientName  = friendName;
     seqNumber      = 0;
 }
コード例 #18
0
 //Default Constructor
 public Packet()
 {
     dataIdentifier = DataIdentifier.Null;
     message        = null;
     senderName     = null;
     recipientName  = null;
     seqNumber      = 0;
 }
コード例 #19
0
        private DataPair doCorrelation(DataIdentifier identifier, DataItem item)
        {
            if (this.correlator == null)
            {
                this.correlator = new Correlator();
            }

            return(this.correlator.Correlate(identifier, item));
        }
コード例 #20
0
        /// <summary>
        /// Delete a data from the server
        /// </summary>
        /// <param name="cloudFolder">The <see cref="CloudFolder"/> that contains informations about the application folder.</param>
        /// <param name="dataIdentifier">The data identifier used to determines which file will be uploaded.</param>
        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
        private async Task DeleteFileAsync(CloudFolder cloudFolder, DataIdentifier dataIdentifier)
        {
            var fileName          = $"{dataIdentifier.Identifier}.dat";
            var cloudDataFilePath = Path.Combine(cloudFolder.FullPath, fileName);

            if (cloudFolder.Files.Any(file => file.FullPath == cloudDataFilePath))
            {
                await CurrentCloudStorageProvider.DeleteFileAsync(cloudDataFilePath);
            }
        }
コード例 #21
0
        //private void setDeviceInstance()
        //{
        //    object deviceInstance = this.detector.GetDeviceInstance();

        //    byte[] deviceInstanceBytes = CommonUtility.BinarySerialize(deviceInstance);

        //    string deviceInstanceStateLocation = ConfigurationManager.AppSettings.Get("DeviceInstanceStateLocation");

        //    deviceInstanceStateLocation = deviceInstanceStateLocation.EndsWith("\\") ? deviceInstanceStateLocation.Substring(0, (deviceInstanceStateLocation.Length - 1)) : deviceInstanceStateLocation;

        //    if (!Directory.Exists(deviceInstanceStateLocation))
        //    {
        //        Directory.CreateDirectory(deviceInstanceStateLocation);
        //    }

        //    string deviceInstanceStateResourceName = ConfigurationManager.AppSettings.Get("DefaultDeviceInstanceStateResourceName");

        //    string filePath = String.Format("{0}\\{1}", deviceInstanceStateLocation, deviceInstanceStateResourceName);

        //    using (FileStream fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Write))
        //    {
        //        fileStream.Write(deviceInstanceBytes, 0, deviceInstanceBytes.Length);
        //    }
        //}

        void detector_CallBack(DataIdentifier Identifier)
        {
            //this.pictureBoxSignalPreview.Image = ((object[])(Identifier.RawData))[0] as Bitmap;
            //this.pictureBoxSignalPreview.Refresh();
            //this.listBoxBarCodesExtracted.DataSource = ((object[])(Identifier.RawData))[1];//new string[] { Identifier.DataUniqueID};
            //this.listBoxBarCodesExtracted.Refresh();

            Thread thread = new Thread(this.threadProcSafe);

            thread.Start(Identifier);
        }
コード例 #22
0
 static IEnumerable <KeyValuePair <DataIdentifier, CompoundDataPiece> > GetAllData(GameModel model)
 {
     foreach (var v in model.actors)
     {
         if (v.Value?.transform == null)
         {
             continue;
         }
         yield return(new KeyValuePair <DataIdentifier, CompoundDataPiece>(DataIdentifier.GetActorIdentifier(v.Key), ReadDataFromGameObject(v.Value.transform.gameObject)));
     }
 }
コード例 #23
0
        public static void Prefix(GameModel __instance, long actorId, GameObject gameObj, bool skipNotify)
        {
            var potentialTag = PersistentAmmoManager.GetPotentialDataTag(gameObj);

            if (potentialTag != null)
            {
                ExtendedData.preparedData[DataIdentifier.GetActorIdentifier(actorId)] = new ExtendedData.PreparedData()
                {
                    SourceType = ExtendedData.PreparedData.PreparationSource.AMMO, Data = potentialTag
                };
            }
        }
コード例 #24
0
        private void OnDataIdentifierEntitySelected(DataIdentifier dataIdentifier, string key)
        {
            Assert.IsNotNull(dataIdentifier);
            Assert.IsFalse(string.IsNullOrEmpty(key));
            Assert.IsNotNull(dataIdentifier.Links);
            Assert.IsTrue(dataIdentifier.Links.ContainsKey(key));

            this.selectedEntity            = null;
            this.selectedDataIdentifier    = dataIdentifier;
            this.selectedDataIdentifierKey = key;
            this.wasDataIdentifierSelected = true;
        }
コード例 #25
0
 public override DataIdentifier[] GenerateIdentifiers()
 {
     if (DataIdentifier != null || IsFrozen)
     {
         throw new InvalidOperationException("GenerateIdentifiers should only be called by FeatureWorld");
     }
     DataIdentifier = new DataIdentifier(this, 0, (int)Math.Ceiling(Math.Log(Count + IdOffset, 2)), WorldType);
     foreach (var feature in Features)
     {
         feature.DataIdentifier = DataIdentifier;
     }
     return(new[] { DataIdentifier });
 }
コード例 #26
0
ファイル: EntityLink.cs プロジェクト: youarebritish/FoxKit
        public void SetDataIdentifier(DataIdentifier dataIdentifier, string key)
        {
            Assert.IsNotNull(dataIdentifier);
            Assert.IsFalse(string.IsNullOrEmpty(key));
            Assert.IsNotNull(dataIdentifier.Links);
            Assert.IsTrue(dataIdentifier.Links.ContainsKey(key));

            this.dataIdentifier = dataIdentifier;
            this.Entity         = dataIdentifier.Links[key].Entity;
            this.address        = this.Entity.Address;
            this.packagePath    = "DATA_IDENTIFIER";
            this.archivePath    = dataIdentifier.Identifier;
            this.nameInArchive  = key;
        }
コード例 #27
0
 public override DataIdentifier[] GenerateIdentifiers()
 {
     if (_identifiers != null || IsFrozen)
     {
         throw new InvalidOperationException("GenerateIdentifiers should only be called by FeatureWorld");
     }
     _identifiers = new DataIdentifier[Count];
     for (var i = 0; i < Features.Count; i++)
     {
         _identifiers[i]            = new DataIdentifier(this, Features[i], i, 1, WorldType);
         Features[i].DataIdentifier = _identifiers[i];
     }
     return(_identifiers);
 }
コード例 #28
0
        //private object getDeviceInstance()
        //{
        //    object deviceInstance = null;

        //    byte[] deviceInstanceBytes = null;

        //    string deviceInstanceStateLocation = ConfigurationManager.AppSettings.Get("DeviceInstanceStateLocation");

        //    deviceInstanceStateLocation = deviceInstanceStateLocation.EndsWith("\\") ? deviceInstanceStateLocation.Substring(0, (deviceInstanceStateLocation.Length - 1)) : deviceInstanceStateLocation;

        //    if (!Directory.Exists(deviceInstanceStateLocation))
        //    {
        //        Directory.CreateDirectory(deviceInstanceStateLocation);
        //    }

        //    string deviceInstanceStateResourceName = ConfigurationManager.AppSettings.Get("DefaultDeviceInstanceStateResourceName");

        //    string filePath = String.Format("{0}\\{1}", deviceInstanceStateLocation, deviceInstanceStateResourceName);

        //    using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
        //    {
        //        deviceInstanceBytes = new byte[fileStream.Length];
        //        fileStream.Read(deviceInstanceBytes, 0, deviceInstanceBytes.Length);
        //    }

        //    if (deviceInstanceBytes != null)
        //    {
        //        deviceInstance = CommonUtility.BinaryDeserialize(deviceInstanceBytes);
        //    }

        //    return deviceInstance;
        //}

        private DataPair doAcquisition(DataIdentifier identifier)
        {
            DataItem dataItem = this.xiAcquirer.Acquire();

            DataPair pair = new DataPair()
            {
                Identifier = identifier,
                Items      = new List <DataItem>()
                {
                    dataItem
                }
            };

            return(pair);
        }
コード例 #29
0
ファイル: Packet.cs プロジェクト: unixvb/PAINT
        public Packet(byte[] dataStream)
        {
            this.dataIdentifier = (DataIdentifier)BitConverter.ToInt32(dataStream, 0);

            int msgLength = BitConverter.ToInt32(dataStream, 4);

            if (msgLength > 0)
            {
                this.message = Encoding.UTF8.GetString(dataStream, 8, msgLength);
            }
            else
            {
                this.message = null;
            }
        }
コード例 #30
0
 protected internal virtual void PopulateDataIdentifiers()
 {
     DiOwnerId          = new DataIdentifier(this, -1, (int)Math.Ceiling(Math.Log(Register.Max)), WorldTypeBoth);
     DiCivVision        = new DataIdentifier(this, -2, 2, WorldTypeCiv);
     DiCivLastMapUpdate = new DataIdentifier(this, -3, 15, WorldTypeCiv);
     DiBaseVision       = new DataIdentifier[Register.Max];
     Dis = new DataIdentifier[Register.Max + 3];
     for (var i = 0; i < Register.Max; i++)
     {
         DiBaseVision[i] = new DataIdentifier(this, i, 2, WorldTypeBase);
         Dis[i]          = DiBaseVision[i];
     }
     Dis[Register.Max + DiExtraCount + DiOwnerId.Index]          = DiOwnerId;
     Dis[Register.Max + DiExtraCount + DiCivVision.Index]        = DiCivVision;
     Dis[Register.Max + DiExtraCount + DiCivLastMapUpdate.Index] = DiCivLastMapUpdate;
 }
コード例 #31
0
        public Packet(byte[] dataStream)
        {
            // Read the data identifier from the beginning of the stream (4 bytes)
            this.dataIdentifier = (DataIdentifier)BitConverter.ToInt32(dataStream, 0);

            // Read the length of the name (4 bytes)
            int nameLength = BitConverter.ToInt32(dataStream, 4);

            // Read the length of the message (4 bytes)
            int msgLength = BitConverter.ToInt32(dataStream, 8);

            // Read the name field
            if (nameLength > 0)
                this.name = Encoding.UTF8.GetString(dataStream, 12, nameLength);
            else
                this.name = null;

            // Read the message field
            if (msgLength > 0)
                this.message = Encoding.UTF8.GetString(dataStream, 12 + nameLength, msgLength);
            else
                this.message = null;
        }
コード例 #32
0
 // Default Constructor
 public Packet()
 {
     this.dataIdentifier = DataIdentifier.Null;
     this.message = null;
     this.name = null;
 }
コード例 #33
0
		public void Register(DataIdentifier id, Func<EndPoint, ChatPacket, ChatPacket> handler)
		{
			_packetHandlers.Add(id, handler);
		}