private void LoadPacketCommandExecute(object param)
        {
            string fileName = null;

            if (param != null)
            {
                var data = (param as IDataObject);
                if (data.GetDataPresent(DataFormats.FileDrop))
                {
                    fileName = (data.GetData(DataFormats.FileDrop) as string[])[0];
                }
            }

            if (string.IsNullOrEmpty(fileName))
            {
                OpenFileDialog dialog = new OpenFileDialog();

                var result = dialog.ShowDialog().GetValueOrDefault(false);
                if (!result)
                {
                    return;
                }

                fileName = dialog.FileName;
            }

            Task.Run(() =>
            {
                Stopwatch watch = new Stopwatch();
                watch.Start();

                IsLoading         = true;
                IsLoadingInfoText = Properties.Resources.STR_Loading;

                PacketDefinitions.Clear();

                LinkedList <PacketDefinition> definitions = new LinkedList <PacketDefinition>();

                try
                {
                    int counter = 0;
                    using (var stream = File.Open(fileName, FileMode.Open))
                    {
                        using (var reader = new StreamReader(stream))
                        {
                            var definition            = new PacketDefinition();
                            StreamMode mode           = StreamMode.Header;
                            StringBuilder dataBuilder = new StringBuilder();

                            while (!reader.EndOfStream)
                            {
                                var line = reader.ReadLine();

                                if (line.StartsWith("#"))
                                {
                                    continue;
                                }

                                if (mode == StreamMode.Header && line.IsEmptyOrWhiteSpace())
                                {
                                    continue;
                                }

                                if (line.StartsWith("ServerToClient") || line.StartsWith("ClientToServer"))
                                {
                                    definition.PacketData = dataBuilder.ToString();
                                    dataBuilder.Clear();

                                    if (definition.PacketName.IsNotEmptyOrWhiteSpace())
                                    {
                                        definitions.AddLast(definition);

                                        if (++counter >= 2500)
                                        {
                                            IsLoadingInfoText = string.Format("{0}: {1}", Properties.Resources.STR_Loading, definitions.Count);
                                            counter           = 0;
                                        }
                                    }

                                    definition = new PacketDefinition();
                                    mode       = StreamMode.Header;
                                }

                                switch (mode)
                                {
                                case StreamMode.Header:
                                    {
                                        var data              = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                                        definition.Direction  = data[0].Trim(':') == "ServerToClient" ? PacketDirection.ServerToClient : PacketDirection.ClientToServer;
                                        definition.PacketName = data[1];
                                        definition.PacketHash = data[2].Trim('(').Trim(')');
                                        definition.Length     = int.Parse(data[4]);
                                        definition.ConnIdx    = int.Parse(data[6]);
                                        definition.Time       = DateTime.ParseExact(data[8], "mm/dd/yyyy", System.Globalization.CultureInfo.InvariantCulture) + TimeSpan.Parse(data[9]);
                                        definition.Number     = int.Parse(data[11]);
                                        mode = StreamMode.Data;
                                        break;
                                    }

                                case StreamMode.Data:
                                    {
                                        dataBuilder.AppendLine(line);
                                        break;
                                    }
                                }
                            }

                            IsLoadingInfoText = string.Format("{0}: {1}", Properties.Resources.STR_Loaded, definitions.Count);
                        }
                    }

                    IsLoadingInfoText = Properties.Resources.STR_PreparingView;
                    PacketDefinitions.ReplaceAll(definitions);
                    definitions.Clear();
                    watch.Stop();
                }
                catch (Exception)
                {
                }
                finally
                {
                    IsLoading = false;
                }
            });
        }
Esempio n. 2
0
 protected virtual PacketDefinitions GetPacketDefinitions()
 {
     return(PacketDefinitions.GetDBCFile());
 }