Analogy hangs on huge exception messages #1781.

LiorBanai · LiorBanai · commit 3485db2fe0ac · 2023-07-21T20:56:37.000+03:00
diff --git a/Analogy.CommonControls/Tools/JsonTreeUC.cs b/Analogy.CommonControls/Tools/JsonTreeUC.cs
@@ -35,7 +35,7 @@ public JsonTreeUC(string json):this()
             JsonData = json;
             _useRawField = false;
         }
-        private void JsonTreeUC_Load(object sender, EventArgs e)
+        private async void JsonTreeUC_Load(object sender, EventArgs e)
         {
             if (DesignMode)
             {
@@ -51,13 +51,13 @@ private void JsonTreeUC_Load(object sender, EventArgs e)
                 JsonData = Utils.ExtractJsonObject(_useRawField ? Message.RawText : Message.Text);
                 if (!string.IsNullOrEmpty(JsonData))
                 {
-                    _jsonTreeView.ShowJson(JsonData);
+                   await _jsonTreeView.ShowJson(JsonData);
                 }
                 return;
             }
             if (!string.IsNullOrEmpty(JsonData))
             {
-                _jsonTreeView.ShowJson(JsonData);
+               await _jsonTreeView.ShowJson(JsonData);
             }
 
             bbiCopyMessage.ItemClick += (_, _) =>
@@ -66,12 +66,12 @@ private void JsonTreeUC_Load(object sender, EventArgs e)
             };
         }
 
-        public void ShowJson(string json)
+        public async Task ShowJson(string json)
         {
             JsonData = json;
             if (!string.IsNullOrEmpty(JsonData))
             {
-                _jsonTreeView.ShowJson(JsonData);
+              await  _jsonTreeView.ShowJson(JsonData);
             }
         }
 
diff --git a/Analogy.CommonControls/Tools/JsonTreeView.cs b/Analogy.CommonControls/Tools/JsonTreeView.cs
@@ -1,10 +1,14 @@
 ﻿using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Drawing;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
 using System.Windows.Forms;
 using Analogy.CommonControls.Properties;
+using DevExpress.Office.Utils;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
@@ -21,17 +25,19 @@ public class JsonTreeView : TreeView
         private ToolStripMenuItem expandAllMenuItem;
         private StatusStrip statusStrip1;
         private string previouslySelectedNodeText;
+        private CancellationTokenSource cancellationTokenSource;
         public event EventHandler<string> OnNodeChanged;
         public string Message { get; set; }
         public JsonTreeView()
         {
             InitializeComponent();
+            cancellationTokenSource = new CancellationTokenSource();
             AfterSelect += this_AfterSelect;
             DoubleClick += (s, e) =>
             {
                 if (SelectedNode != null)
                 {
-                    Clipboard.SetText(SelectedNode.Text,TextDataFormat.UnicodeText);
+                    Clipboard.SetText(SelectedNode.Text, TextDataFormat.UnicodeText);
                 }
             };
             MouseDown += this_MouseDown;
@@ -113,21 +119,25 @@ private void LoadImageList()
         }
 
         [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
-        private void LoadTree(object jsonData)
+        private List<TreeNode> LoadTree(object jsonData, CancellationToken cancellationToken)
         {
-            Nodes.Clear();
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return new();
+            }
+            List<TreeNode> nodes = new();
             if (jsonData is JArray jsonArray)
             {
                 var rootNode = new JsonTreeNode(JsonNodeType.Object, "(root array)");
                 foreach (JToken jToken in jsonArray)
                 {
                     var node = new JsonTreeNode(JsonNodeType.Array, jToken.Type.ToString());
                     rootNode.Nodes.Add(node);
-                    LoadObject(jToken as JObject, node);
+                    LoadObject(jToken as JObject, node, cancellationToken);
                 }
                 TreeNode[] rootNodeArray = new TreeNode[rootNode.Nodes.Count];
                 rootNode.Nodes.CopyTo(rootNodeArray, 0);
-                Nodes.Add(rootNode);
+                nodes.Add(rootNode);
                 SelectedNode = rootNodeArray.First() as JsonTreeNode;
                 rootNode.ImageKey = rootNode.NodeType.ToString();
                 rootNode.SelectedImageKey = rootNode.ImageKey;
@@ -137,13 +147,15 @@ private void LoadTree(object jsonData)
             if (jsonData is JObject json)
             {
                 var rootNode = new JsonTreeNode(JsonNodeType.Object, "(root)");
-                Nodes.Add(rootNode);
+                nodes.Add(rootNode);
                 SelectedNode = rootNode;
                 rootNode.ImageKey = rootNode.NodeType.ToString();
                 rootNode.SelectedImageKey = rootNode.ImageKey;
-                LoadObject(json, rootNode);
+                LoadObject(json, rootNode, cancellationToken);
                 rootNode.ExpandAll();
             }
+
+            return nodes;
         }
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static bool TryParse(string strInput, out JToken output)
@@ -182,52 +194,66 @@ private static bool TryParse(string strInput, out JToken output)
                 return false;
             }
         }
-        private void AddNode(JsonTreeNode parentNode, string property, JToken item)
+        private void AddNode(JsonTreeNode parentNode, string property, JToken item, CancellationToken cancellationToken)
         {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
+
             var node = JsonTreeNodeCreator.CreateNode(property, item);
             parentNode.Nodes.Add(node);
             if (item.Type == JTokenType.Array)
             {
-                LoadArray(item, node);
+                LoadArray(item, node, cancellationToken);
             }
 
             else if (item.Type == JTokenType.Object)
             {
-                LoadObject(item as JObject, node);
+                LoadObject(item as JObject, node, cancellationToken);
             }
             else if (TryParse(item.ToString(), out var token))
             {
                 node.Text = property;
                 if (token.Type == JTokenType.Array)
                 {
-                    LoadArray(token, node);
+                    LoadArray(token, node, cancellationToken);
                 }
 
                 else if (token.Type == JTokenType.Object)
                 {
-                    LoadObject(token as JObject, node);
+                    LoadObject(token as JObject, node, cancellationToken);
                 }
             }
         }
 
-        private void LoadArray(JToken value, JsonTreeNode node)
+        private void LoadArray(JToken value, JsonTreeNode node, CancellationToken cancellationToken)
         {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
             foreach (var item in value)
             {
-                AddNode(node, null, item);
+                AddNode(node, null, item, cancellationToken);
             }
         }
 
-        private void LoadObject(JObject obj, JsonTreeNode node)
+        private void LoadObject(JObject obj, JsonTreeNode node, CancellationToken cancellationToken)
         {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
+
             if (obj is null)
             {
                 return;
             }
 
             foreach (var item in obj)
             {
-                AddNode(node, item.Key, item.Value);
+                AddNode(node, item.Key, item.Value, cancellationToken);
             }
         }
 
@@ -280,7 +306,7 @@ private void InitializeComponent()
             get => base.SelectedNode as JsonTreeNode;
             set => base.SelectedNode = value;
         }
-        
+
         private void this_AfterSelect(object sender, TreeViewEventArgs e)
         {
             // restore previous seelcted node text and store the next
@@ -292,9 +318,9 @@ private void this_AfterSelect(object sender, TreeViewEventArgs e)
             previouslySelectedNodeText = e.Node.Text;
 
             e.Node.Text = ((JsonTreeNode)e.Node).TextWhenSelected;
-            OnNodeChanged?.Invoke(this,e.Node.Text);
+            OnNodeChanged?.Invoke(this, e.Node.Text);
         }
-        
+
         private void this_MouseDown(object sender, MouseEventArgs e)
         {
             if (e.Button == MouseButtons.Right)
@@ -330,13 +356,23 @@ public void ClearList()
         {
             Nodes.Clear();
         }
-        public void ShowJson(string jsonString)
+        public async Task ShowJson(string jsonString)
         {
             Message = jsonString;
             try
             {
+                BeginUpdate();
+                Nodes.Clear();
+                cancellationTokenSource?.Cancel();
+                cancellationTokenSource = new CancellationTokenSource();
+                var token = cancellationTokenSource.Token;
                 object json = JsonConvert.DeserializeObject(jsonString);
-                LoadTree(json);
+                var nodes = await Task.Run(() => LoadTree(json, token));
+                if (!token.IsCancellationRequested)
+                {
+                    Nodes.AddRange(nodes.ToArray());
+                }
+                EndUpdate();
             }
             catch (Exception e)
             {
diff --git a/Analogy.CommonControls/Tools/JsonViewerForm.cs b/Analogy.CommonControls/Tools/JsonViewerForm.cs
@@ -33,7 +33,7 @@ public JsonViewerForm(string json, IUserSettingsManager settings) : this(setting
             JsonData = json;
             _useRawField = false;
         }
-        private void JsonViewerForm_Load(object sender, EventArgs e)
+        private async void JsonViewerForm_Load(object sender, EventArgs e)
         {
             if (DesignMode)
             {
@@ -52,22 +52,22 @@ private void JsonViewerForm_Load(object sender, EventArgs e)
             if (!string.IsNullOrEmpty(JsonData))
             {
                 memoEdit1.Text = JsonData;
-                _jsonTreeView.ShowJson(JsonData);
+                await _jsonTreeView.ShowJson(JsonData);
             }
             else if (Message != null)
             {
                 memoEdit1.Text = _useRawField ? Message.RawText : Message.Text;
                 JsonData = Utils.ExtractJsonObject(_useRawField ? Message.RawText : Message.Text);
                 if (!string.IsNullOrEmpty(JsonData))
                 {
-                    _jsonTreeView.ShowJson(JsonData);
+                    await _jsonTreeView.ShowJson(JsonData);
                 }
             }
         }
 
-        private void sbtnLoad_Click(object sender, EventArgs e)
+        private async void sbtnLoad_Click(object sender, EventArgs e)
         {
-            _jsonTreeView.ShowJson(memoEdit1.Text);
+            await _jsonTreeView.ShowJson(memoEdit1.Text);
         }
     }
 }
diff --git a/Analogy.CommonControls/UserControls/LogMessagesUC.cs b/Analogy.CommonControls/UserControls/LogMessagesUC.cs
@@ -3304,7 +3304,7 @@ private void bBtnSaveEntireLog_ItemClick(object sender, ItemClickEventArgs e)
             SaveMessagesToLog(FileDataProvider, messages);
         }
 
-        private void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)
+        private async void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)
         {
             int row = e.FocusedRowHandle;
 
@@ -3321,12 +3321,12 @@ private void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs
                 if (useSpecificColumnForJson)
                 {
                     var specific = LogGrid.GetRowCellValue(e.FocusedRowHandle, jsonColumnForInlineJsonViewer).ToString();
-                    JsonTreeView.ShowJson(specific);
+                   await JsonTreeView.ShowJson(specific);
 
                 }
                 else if (focusedMassage.RawTextType == AnalogyRowTextType.JSON)
                 {
-                    JsonTreeView.ShowJson(focusedMassage.RawText);
+                   await JsonTreeView.ShowJson(focusedMassage.RawText);
                 }
             }
 
diff --git a/Analogy.CommonControls/UserControls/MessageDetailsUC.cs b/Analogy.CommonControls/UserControls/MessageDetailsUC.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using System.Windows.Forms;
 using Analogy.Common;
 using Analogy.Common.Interfaces;
@@ -32,7 +33,7 @@ public MessageDetailsUC(AnalogyLogMessage msg, List<IAnalogyLogMessage> messages
             DataSource = dataSource;
         }
 
-        private void UCMessageDetails_Load(object sender, EventArgs e)
+        private async void UCMessageDetails_Load(object sender, EventArgs e)
         {
             if (DesignMode)
             {
@@ -46,7 +47,7 @@ private void UCMessageDetails_Load(object sender, EventArgs e)
             _jsonTreeView = new JsonTreeUC();
             splitContainerControl1.Panel2.Controls.Add(_jsonTreeView);
             _jsonTreeView.Dock = DockStyle.Fill;
-            LoadMessage();
+            await LoadMessage();
         }
         protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
         {
@@ -66,7 +67,7 @@ protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
 
         }
 
-        public void LoadMessage()
+        public async Task LoadMessage()
         {
             if (Message == null)
             {
@@ -105,7 +106,7 @@ public void LoadMessage()
                 _jsonTreeView.ClearList();
                 if (!string.IsNullOrEmpty(json))
                 {
-                    _jsonTreeView.ShowJson(json);
+                  await  _jsonTreeView.ShowJson(json);
                 }
 
                 splitContainerControl1.PanelVisibility = SplitPanelVisibility.Both;
@@ -122,25 +123,25 @@ private void btnNext_Click(object sender, EventArgs e)
             LoadNextMessage();
         }
 
-        private void LoadPreviousMessage()
+        private async void LoadPreviousMessage()
         {
             if (Messages.First() == Message)
             {
                 return;
             }
 
             Message = Messages[Messages.IndexOf(Message) - 1];
-            LoadMessage();
+            await LoadMessage();
         }
-        private void LoadNextMessage()
+        private async void LoadNextMessage()
         {
             if (Messages.Last() == Message)
             {
                 return;
             }
 
             Message = Messages[Messages.IndexOf(Message) + 1];
-            LoadMessage();
+            await LoadMessage();
         }
         private void btnPrev_Click(object sender, EventArgs e)
         {
diff --git a/Analogy.CommonControls/UserControls/ServerSideLogMessagesUC.cs b/Analogy.CommonControls/UserControls/ServerSideLogMessagesUC.cs
@@ -3067,7 +3067,7 @@ private void bBtnSaveEntireLog_ItemClick(object sender, ItemClickEventArgs e)
             SaveMessagesToLog(FileDataProvider, messages);
         }
 
-        private void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)
+        private async void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)
         {
             int row = e.FocusedRowHandle;
 
@@ -3081,7 +3081,7 @@ private void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs
             LoadTextBoxes(focusedMassage);
             if (Settings.InlineJsonViewer && focusedMassage.RawTextType == AnalogyRowTextType.JSON)
             {
-                JsonTreeView.ShowJson(focusedMassage.RawText);
+               await JsonTreeView.ShowJson(focusedMassage.RawText);
             }
             string dataProvider = (string)LogGrid.GetRowCellValue(e.FocusedRowHandle, "DataProvider");
             if (!LoadingInProgress)

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public JsonTreeUC(string json):this()`
`35`	`35`	`JsonData = json;`
`36`	`36`	`_useRawField = false;`
`37`	`37`	`}`
`38`		`- private void JsonTreeUC_Load(object sender, EventArgs e)`
	`38`	`+ private async void JsonTreeUC_Load(object sender, EventArgs e)`
`39`	`39`	`{`
`40`	`40`	`if (DesignMode)`
`41`	`41`	`{`
`@@ -51,13 +51,13 @@ private void JsonTreeUC_Load(object sender, EventArgs e)`
`51`	`51`	`JsonData = Utils.ExtractJsonObject(_useRawField ? Message.RawText : Message.Text);`
`52`	`52`	`if (!string.IsNullOrEmpty(JsonData))`
`53`	`53`	`{`
`54`		`- _jsonTreeView.ShowJson(JsonData);`
	`54`	`+ await _jsonTreeView.ShowJson(JsonData);`
`55`	`55`	`}`
`56`	`56`	`return;`
`57`	`57`	`}`
`58`	`58`	`if (!string.IsNullOrEmpty(JsonData))`
`59`	`59`	`{`
`60`		`- _jsonTreeView.ShowJson(JsonData);`
	`60`	`+ await _jsonTreeView.ShowJson(JsonData);`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`bbiCopyMessage.ItemClick += (_, _) =>`
`@@ -66,12 +66,12 @@ private void JsonTreeUC_Load(object sender, EventArgs e)`
`66`	`66`	`};`
`67`	`67`	`}`
`68`	`68`
`69`		`- public void ShowJson(string json)`
	`69`	`+ public async Task ShowJson(string json)`
`70`	`70`	`{`
`71`	`71`	`JsonData = json;`
`72`	`72`	`if (!string.IsNullOrEmpty(JsonData))`
`73`	`73`	`{`
`74`		`- _jsonTreeView.ShowJson(JsonData);`
	`74`	`+ await _jsonTreeView.ShowJson(JsonData);`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,14 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Collections.Generic;`
`2`	`3`	`using System.ComponentModel;`
`3`	`4`	`using System.Drawing;`
`4`	`5`	`using System.Linq;`
`5`	`6`	`using System.Runtime.CompilerServices;`
	`7`	`+using System.Threading;`
	`8`	`+using System.Threading.Tasks;`
`6`	`9`	`using System.Windows.Forms;`
`7`	`10`	`using Analogy.CommonControls.Properties;`
	`11`	`+using DevExpress.Office.Utils;`
`8`	`12`	`using Newtonsoft.Json;`
`9`	`13`	`using Newtonsoft.Json.Linq;`
`10`	`14`
`@@ -21,17 +25,19 @@ public class JsonTreeView : TreeView`
`21`	`25`	`private ToolStripMenuItem expandAllMenuItem;`
`22`	`26`	`private StatusStrip statusStrip1;`
`23`	`27`	`private string previouslySelectedNodeText;`
	`28`	`+ private CancellationTokenSource cancellationTokenSource;`
`24`	`29`	`public event EventHandler<string> OnNodeChanged;`
`25`	`30`	`public string Message { get; set; }`
`26`	`31`	`public JsonTreeView()`
`27`	`32`	`{`
`28`	`33`	`InitializeComponent();`
	`34`	`+ cancellationTokenSource = new CancellationTokenSource();`
`29`	`35`	`AfterSelect += this_AfterSelect;`
`30`	`36`	`DoubleClick += (s, e) =>`
`31`	`37`	`{`
`32`	`38`	`if (SelectedNode != null)`
`33`	`39`	`{`
`34`		`- Clipboard.SetText(SelectedNode.Text,TextDataFormat.UnicodeText);`
	`40`	`+ Clipboard.SetText(SelectedNode.Text, TextDataFormat.UnicodeText);`
`35`	`41`	`}`
`36`	`42`	`};`
`37`	`43`	`MouseDown += this_MouseDown;`
`@@ -113,21 +119,25 @@ private void LoadImageList()`
`113`	`119`	`}`
`114`	`120`
`115`	`121`	`[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]`
`116`		`- private void LoadTree(object jsonData)`
	`122`	`+ private List<TreeNode> LoadTree(object jsonData, CancellationToken cancellationToken)`
`117`	`123`	`{`
`118`		`- Nodes.Clear();`
	`124`	`+ if (cancellationToken.IsCancellationRequested)`
	`125`	`+ {`
	`126`	`+ return new();`
	`127`	`+ }`
	`128`	`+ List<TreeNode> nodes = new();`
`119`	`129`	`if (jsonData is JArray jsonArray)`
`120`	`130`	`{`
`121`	`131`	`var rootNode = new JsonTreeNode(JsonNodeType.Object, "(root array)");`
`122`	`132`	`foreach (JToken jToken in jsonArray)`
`123`	`133`	`{`
`124`	`134`	`var node = new JsonTreeNode(JsonNodeType.Array, jToken.Type.ToString());`
`125`	`135`	`rootNode.Nodes.Add(node);`
`126`		`- LoadObject(jToken as JObject, node);`
	`136`	`+ LoadObject(jToken as JObject, node, cancellationToken);`
`127`	`137`	`}`
`128`	`138`	`TreeNode[] rootNodeArray = new TreeNode[rootNode.Nodes.Count];`
`129`	`139`	`rootNode.Nodes.CopyTo(rootNodeArray, 0);`
`130`		`- Nodes.Add(rootNode);`
	`140`	`+ nodes.Add(rootNode);`
`131`	`141`	`SelectedNode = rootNodeArray.First() as JsonTreeNode;`
`132`	`142`	`rootNode.ImageKey = rootNode.NodeType.ToString();`
`133`	`143`	`rootNode.SelectedImageKey = rootNode.ImageKey;`
`@@ -137,13 +147,15 @@ private void LoadTree(object jsonData)`
`137`	`147`	`if (jsonData is JObject json)`
`138`	`148`	`{`
`139`	`149`	`var rootNode = new JsonTreeNode(JsonNodeType.Object, "(root)");`
`140`		`- Nodes.Add(rootNode);`
	`150`	`+ nodes.Add(rootNode);`
`141`	`151`	`SelectedNode = rootNode;`
`142`	`152`	`rootNode.ImageKey = rootNode.NodeType.ToString();`
`143`	`153`	`rootNode.SelectedImageKey = rootNode.ImageKey;`
`144`		`- LoadObject(json, rootNode);`
	`154`	`+ LoadObject(json, rootNode, cancellationToken);`
`145`	`155`	`rootNode.ExpandAll();`
`146`	`156`	`}`
	`157`	`+`
	`158`	`+ return nodes;`
`147`	`159`	`}`
`148`	`160`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`149`	`161`	`private static bool TryParse(string strInput, out JToken output)`
`@@ -182,52 +194,66 @@ private static bool TryParse(string strInput, out JToken output)`
`182`	`194`	`return false;`
`183`	`195`	`}`
`184`	`196`	`}`
`185`		`- private void AddNode(JsonTreeNode parentNode, string property, JToken item)`
	`197`	`+ private void AddNode(JsonTreeNode parentNode, string property, JToken item, CancellationToken cancellationToken)`
`186`	`198`	`{`
	`199`	`+ if (cancellationToken.IsCancellationRequested)`
	`200`	`+ {`
	`201`	`+ return;`
	`202`	`+ }`
	`203`	`+`
`187`	`204`	`var node = JsonTreeNodeCreator.CreateNode(property, item);`
`188`	`205`	`parentNode.Nodes.Add(node);`
`189`	`206`	`if (item.Type == JTokenType.Array)`
`190`	`207`	`{`
`191`		`- LoadArray(item, node);`
	`208`	`+ LoadArray(item, node, cancellationToken);`
`192`	`209`	`}`
`193`	`210`
`194`	`211`	`else if (item.Type == JTokenType.Object)`
`195`	`212`	`{`
`196`		`- LoadObject(item as JObject, node);`
	`213`	`+ LoadObject(item as JObject, node, cancellationToken);`
`197`	`214`	`}`
`198`	`215`	`else if (TryParse(item.ToString(), out var token))`
`199`	`216`	`{`
`200`	`217`	`node.Text = property;`
`201`	`218`	`if (token.Type == JTokenType.Array)`
`202`	`219`	`{`
`203`		`- LoadArray(token, node);`
	`220`	`+ LoadArray(token, node, cancellationToken);`
`204`	`221`	`}`
`205`	`222`
`206`	`223`	`else if (token.Type == JTokenType.Object)`
`207`	`224`	`{`
`208`		`- LoadObject(token as JObject, node);`
	`225`	`+ LoadObject(token as JObject, node, cancellationToken);`
`209`	`226`	`}`
`210`	`227`	`}`
`211`	`228`	`}`
`212`	`229`
`213`		`- private void LoadArray(JToken value, JsonTreeNode node)`
	`230`	`+ private void LoadArray(JToken value, JsonTreeNode node, CancellationToken cancellationToken)`
`214`	`231`	`{`
	`232`	`+ if (cancellationToken.IsCancellationRequested)`
	`233`	`+ {`
	`234`	`+ return;`
	`235`	`+ }`
`215`	`236`	`foreach (var item in value)`
`216`	`237`	`{`
`217`		`- AddNode(node, null, item);`
	`238`	`+ AddNode(node, null, item, cancellationToken);`
`218`	`239`	`}`
`219`	`240`	`}`
`220`	`241`
`221`		`- private void LoadObject(JObject obj, JsonTreeNode node)`
	`242`	`+ private void LoadObject(JObject obj, JsonTreeNode node, CancellationToken cancellationToken)`
`222`	`243`	`{`
	`244`	`+ if (cancellationToken.IsCancellationRequested)`
	`245`	`+ {`
	`246`	`+ return;`
	`247`	`+ }`
	`248`	`+`
`223`	`249`	`if (obj is null)`
`224`	`250`	`{`
`225`	`251`	`return;`
`226`	`252`	`}`
`227`	`253`
`228`	`254`	`foreach (var item in obj)`
`229`	`255`	`{`
`230`		`- AddNode(node, item.Key, item.Value);`
	`256`	`+ AddNode(node, item.Key, item.Value, cancellationToken);`
`231`	`257`	`}`
`232`	`258`	`}`
`233`	`259`
`@@ -280,7 +306,7 @@ private void InitializeComponent()`
`280`	`306`	`get => base.SelectedNode as JsonTreeNode;`
`281`	`307`	`set => base.SelectedNode = value;`
`282`	`308`	`}`
`283`		`-`
	`309`	`+`
`284`	`310`	`private void this_AfterSelect(object sender, TreeViewEventArgs e)`
`285`	`311`	`{`
`286`	`312`	`// restore previous seelcted node text and store the next`
`@@ -292,9 +318,9 @@ private void this_AfterSelect(object sender, TreeViewEventArgs e)`
`292`	`318`	`previouslySelectedNodeText = e.Node.Text;`
`293`	`319`
`294`	`320`	`e.Node.Text = ((JsonTreeNode)e.Node).TextWhenSelected;`
`295`		`- OnNodeChanged?.Invoke(this,e.Node.Text);`
	`321`	`+ OnNodeChanged?.Invoke(this, e.Node.Text);`
`296`	`322`	`}`
`297`		`-`
	`323`	`+`
`298`	`324`	`private void this_MouseDown(object sender, MouseEventArgs e)`
`299`	`325`	`{`
`300`	`326`	`if (e.Button == MouseButtons.Right)`
`@@ -330,13 +356,23 @@ public void ClearList()`
`330`	`356`	`{`
`331`	`357`	`Nodes.Clear();`
`332`	`358`	`}`
`333`		`- public void ShowJson(string jsonString)`
	`359`	`+ public async Task ShowJson(string jsonString)`
`334`	`360`	`{`
`335`	`361`	`Message = jsonString;`
`336`	`362`	`try`
`337`	`363`	`{`
	`364`	`+ BeginUpdate();`
	`365`	`+ Nodes.Clear();`
	`366`	`+ cancellationTokenSource?.Cancel();`
	`367`	`+ cancellationTokenSource = new CancellationTokenSource();`
	`368`	`+ var token = cancellationTokenSource.Token;`
`338`	`369`	`object json = JsonConvert.DeserializeObject(jsonString);`
`339`		`- LoadTree(json);`
	`370`	`+ var nodes = await Task.Run(() => LoadTree(json, token));`
	`371`	`+ if (!token.IsCancellationRequested)`
	`372`	`+ {`
	`373`	`+ Nodes.AddRange(nodes.ToArray());`
	`374`	`+ }`
	`375`	`+ EndUpdate();`
`340`	`376`	`}`
`341`	`377`	`catch (Exception e)`
`342`	`378`	`{`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public JsonViewerForm(string json, IUserSettingsManager settings) : this(setting`
`33`	`33`	`JsonData = json;`
`34`	`34`	`_useRawField = false;`
`35`	`35`	`}`
`36`		`- private void JsonViewerForm_Load(object sender, EventArgs e)`
	`36`	`+ private async void JsonViewerForm_Load(object sender, EventArgs e)`
`37`	`37`	`{`
`38`	`38`	`if (DesignMode)`
`39`	`39`	`{`
`@@ -52,22 +52,22 @@ private void JsonViewerForm_Load(object sender, EventArgs e)`
`52`	`52`	`if (!string.IsNullOrEmpty(JsonData))`
`53`	`53`	`{`
`54`	`54`	`memoEdit1.Text = JsonData;`
`55`		`- _jsonTreeView.ShowJson(JsonData);`
	`55`	`+ await _jsonTreeView.ShowJson(JsonData);`
`56`	`56`	`}`
`57`	`57`	`else if (Message != null)`
`58`	`58`	`{`
`59`	`59`	`memoEdit1.Text = _useRawField ? Message.RawText : Message.Text;`
`60`	`60`	`JsonData = Utils.ExtractJsonObject(_useRawField ? Message.RawText : Message.Text);`
`61`	`61`	`if (!string.IsNullOrEmpty(JsonData))`
`62`	`62`	`{`
`63`		`- _jsonTreeView.ShowJson(JsonData);`
	`63`	`+ await _jsonTreeView.ShowJson(JsonData);`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`68`		`- private void sbtnLoad_Click(object sender, EventArgs e)`
	`68`	`+ private async void sbtnLoad_Click(object sender, EventArgs e)`
`69`	`69`	`{`
`70`		`- _jsonTreeView.ShowJson(memoEdit1.Text);`
	`70`	`+ await _jsonTreeView.ShowJson(memoEdit1.Text);`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3304,7 +3304,7 @@ private void bBtnSaveEntireLog_ItemClick(object sender, ItemClickEventArgs e)`
`3304`	`3304`	`SaveMessagesToLog(FileDataProvider, messages);`
`3305`	`3305`	`}`
`3306`	`3306`
`3307`		`- private void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)`
	`3307`	`+ private async void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)`
`3308`	`3308`	`{`
`3309`	`3309`	`int row = e.FocusedRowHandle;`
`3310`	`3310`
`@@ -3321,12 +3321,12 @@ private void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs`
`3321`	`3321`	`if (useSpecificColumnForJson)`
`3322`	`3322`	`{`
`3323`	`3323`	`var specific = LogGrid.GetRowCellValue(e.FocusedRowHandle, jsonColumnForInlineJsonViewer).ToString();`
`3324`		`- JsonTreeView.ShowJson(specific);`
	`3324`	`+ await JsonTreeView.ShowJson(specific);`
`3325`	`3325`
`3326`	`3326`	`}`
`3327`	`3327`	`else if (focusedMassage.RawTextType == AnalogyRowTextType.JSON)`
`3328`	`3328`	`{`
`3329`		`- JsonTreeView.ShowJson(focusedMassage.RawText);`
	`3329`	`+ await JsonTreeView.ShowJson(focusedMassage.RawText);`
`3330`	`3330`	`}`
`3331`	`3331`	`}`
`3332`	`3332`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.Linq;`
	`4`	`+using System.Threading.Tasks;`
`4`	`5`	`using System.Windows.Forms;`
`5`	`6`	`using Analogy.Common;`
`6`	`7`	`using Analogy.Common.Interfaces;`
`@@ -32,7 +33,7 @@ public MessageDetailsUC(AnalogyLogMessage msg, List<IAnalogyLogMessage> messages`
`32`	`33`	`DataSource = dataSource;`
`33`	`34`	`}`
`34`	`35`
`35`		`- private void UCMessageDetails_Load(object sender, EventArgs e)`
	`36`	`+ private async void UCMessageDetails_Load(object sender, EventArgs e)`
`36`	`37`	`{`
`37`	`38`	`if (DesignMode)`
`38`	`39`	`{`
`@@ -46,7 +47,7 @@ private void UCMessageDetails_Load(object sender, EventArgs e)`
`46`	`47`	`_jsonTreeView = new JsonTreeUC();`
`47`	`48`	`splitContainerControl1.Panel2.Controls.Add(_jsonTreeView);`
`48`	`49`	`_jsonTreeView.Dock = DockStyle.Fill;`
`49`		`- LoadMessage();`
	`50`	`+ await LoadMessage();`
`50`	`51`	`}`
`51`	`52`	`protected override bool ProcessCmdKey(ref Message msg, Keys keyData)`
`52`	`53`	`{`
`@@ -66,7 +67,7 @@ protected override bool ProcessCmdKey(ref Message msg, Keys keyData)`
`66`	`67`
`67`	`68`	`}`
`68`	`69`
`69`		`- public void LoadMessage()`
	`70`	`+ public async Task LoadMessage()`
`70`	`71`	`{`
`71`	`72`	`if (Message == null)`
`72`	`73`	`{`
`@@ -105,7 +106,7 @@ public void LoadMessage()`
`105`	`106`	`_jsonTreeView.ClearList();`
`106`	`107`	`if (!string.IsNullOrEmpty(json))`
`107`	`108`	`{`
`108`		`- _jsonTreeView.ShowJson(json);`
	`109`	`+ await _jsonTreeView.ShowJson(json);`
`109`	`110`	`}`
`110`	`111`
`111`	`112`	`splitContainerControl1.PanelVisibility = SplitPanelVisibility.Both;`
`@@ -122,25 +123,25 @@ private void btnNext_Click(object sender, EventArgs e)`
`122`	`123`	`LoadNextMessage();`
`123`	`124`	`}`
`124`	`125`
`125`		`- private void LoadPreviousMessage()`
	`126`	`+ private async void LoadPreviousMessage()`
`126`	`127`	`{`
`127`	`128`	`if (Messages.First() == Message)`
`128`	`129`	`{`
`129`	`130`	`return;`
`130`	`131`	`}`
`131`	`132`
`132`	`133`	`Message = Messages[Messages.IndexOf(Message) - 1];`
`133`		`- LoadMessage();`
	`134`	`+ await LoadMessage();`
`134`	`135`	`}`
`135`		`- private void LoadNextMessage()`
	`136`	`+ private async void LoadNextMessage()`
`136`	`137`	`{`
`137`	`138`	`if (Messages.Last() == Message)`
`138`	`139`	`{`
`139`	`140`	`return;`
`140`	`141`	`}`
`141`	`142`
`142`	`143`	`Message = Messages[Messages.IndexOf(Message) + 1];`
`143`		`- LoadMessage();`
	`144`	`+ await LoadMessage();`
`144`	`145`	`}`
`145`	`146`	`private void btnPrev_Click(object sender, EventArgs e)`
`146`	`147`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3067,7 +3067,7 @@ private void bBtnSaveEntireLog_ItemClick(object sender, ItemClickEventArgs e)`
`3067`	`3067`	`SaveMessagesToLog(FileDataProvider, messages);`
`3068`	`3068`	`}`
`3069`	`3069`
`3070`		`- private void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)`
	`3070`	`+ private async void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)`
`3071`	`3071`	`{`
`3072`	`3072`	`int row = e.FocusedRowHandle;`
`3073`	`3073`
`@@ -3081,7 +3081,7 @@ private void logGrid_FocusedRowChanged(object sender, FocusedRowChangedEventArgs`
`3081`	`3081`	`LoadTextBoxes(focusedMassage);`
`3082`	`3082`	`if (Settings.InlineJsonViewer && focusedMassage.RawTextType == AnalogyRowTextType.JSON)`
`3083`	`3083`	`{`
`3084`		`- JsonTreeView.ShowJson(focusedMassage.RawText);`
	`3084`	`+ await JsonTreeView.ShowJson(focusedMassage.RawText);`
`3085`	`3085`	`}`
`3086`	`3086`	`string dataProvider = (string)LogGrid.GetRowCellValue(e.FocusedRowHandle, "DataProvider");`
`3087`	`3087`	`if (!LoadingInProgress)`