Removed AngleSharp and replaced the HTML parser utility with the HTMLAgility Pack. Updated control converter code to be more simple and more robust.

Author: jhannahLCD

…igration/AspxToBlazorControlConverter.cs …Adapters/AspxToBlazorControlConverter.cssrc/WebFormsToBlazorServerCommands/Migration/AspxToBlazorControlConverter.cs renamed to src/WebFormsToBlazorServerCommands/Migration/Adapters/AspxToBlazorControlConverter.cs src/WebFormsToBlazorServerCommands/Migration/AspxToBlazorControlConverter.cs renamed to src/WebFormsToBlazorServerCommands/Migration/Adapters/AspxToBlazorControlConverter.cs

@@ -1,16 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Net.NetworkInformation;
-using System.ServiceModel.Configuration;
-using System.Text;
-using System.Text.RegularExpressions;
 using System.Threading.Tasks;
-using AngleSharp;
-using AngleSharp.Dom;
-using AngleSharp.Html.Parser;
 using CodeFactory.Formatting.CSharp;
-using NLog.Targets.Wrappers;
+using HtmlAgilityPack;
 
 namespace WebFormsToBlazorServerCommands.Migration
 {
@@ -19,8 +12,6 @@ namespace WebFormsToBlazorServerCommands.Migration
     /// </summary>
     public class AspxToBlazorControlConverter : ControlConverterBase
     {
-        private static AngleSharp.IConfiguration _angleSharpConfig = AngleSharp.Configuration.Default;
-        private static AngleSharp.IBrowsingContext _angleSharpContext = null; 
 
         public AspxToBlazorControlConverter(ITagControlConverter adapterHost) : base(adapterHost)
         {
@@ -50,7 +41,6 @@ public AspxToBlazorControlConverter(ITagControlConverter adapterHost) : base(ada
             _TagsICanConvert.Add("asp:datagrid");
             _TagsICanConvert.Add("asp:dropdownlist");
 
-            _angleSharpContext = BrowsingContext.New(_angleSharpConfig);
         }
 
         /// <summary>
@@ -77,6 +67,10 @@ public override async Task<string> ConvertControlTag(string tagName, string tagN
                     _result = await ConvertEditFormControl(tagNodeContent);
                     break;
 
+                case "asp:listview":
+                    _result = await ConvertListViewControl(tagNodeContent);
+                    break;
+
                 default:
                     _result = await ConvertGenericControl(tagNodeContent);
                     break;
@@ -96,6 +90,8 @@ public override async Task<string> ConvertControlTag(string tagName, string tagN
         /// <returns>converted control content</returns>
         private async Task<string> ConvertGenericControl(string nodeContent)
         {
+            var model = new HtmlDocument();
+            model.LoadHtml(nodeContent);
 
             try
             {
@@ -105,7 +101,17 @@ private async Task<string> ConvertGenericControl(string nodeContent)
                     return nodeContent;
                 }
 
-                return nodeContent.Substring(0, pos) + "" + nodeContent.Substring(pos + "asp:".Length);
+                //send any child asp:* controls to be converted by the a call back out to the adapterHosting class.
+                var aspFormTags = model.DocumentNode.Descendants().Where(p => p.Name.ToLower().Contains("asp:")).ToList();
+                foreach (var formObj in aspFormTags)
+                {
+                    var migratedControlText = await _adapterHost.MigrateTagControl(formObj.Name, formObj.OuterHtml);
+                    var tempNode = HtmlNode.CreateNode(migratedControlText);
+
+                    formObj.ParentNode.ReplaceChild(tempNode, formObj);
+                }
+
+                return model.DocumentNode.OuterHtml;
             }
             catch (Exception ex)
             {
@@ -121,36 +127,99 @@ private async Task<string> ConvertGenericControl(string nodeContent)
         /// <returns></returns>
         private async Task<string> ConvertFormViewControl(string nodeContent)
         {
-            var model = await _angleSharpContext.OpenAsync(req => req.Content(nodeContent));
-            var parser = new HtmlParser();
+            var currentModel = new HtmlDocument();
+            var newModel = new HtmlDocument();
+            currentModel.LoadHtml(nodeContent);
 
             try
             {
-                var editFormNode = model.All.Where(p => p.LocalName.ToLower().Equals("asp:formview")).FirstOrDefault();
-                var newNode = parser.ParseFragment($"<EditForm Model={editFormNode.GetAttribute("ItemType")} OnValidSubmit={editFormNode.GetAttribute("SelectMethod")}></EditForm>", editFormNode);
+                var editFormNode = currentModel.DocumentNode.FirstChild;// ("//asp:listview");// model.All.Where(p => p.LocalName.ToLower().Equals("asp:formview")).FirstOrDefault();
 
+                newModel.LoadHtml($"<EditForm Model={editFormNode.GetAttributeValue("ItemType", "")} OnValidSubmit={editFormNode.GetAttributeValue("SelectMethod","")}></EditForm>");
+                var newNode = newModel.DocumentNode.SelectSingleNode("//editform");
                 //this is now a live list having substituted the EditForm control for the old FormView one
-                newNode.First().AppendNodes(editFormNode.ChildNodes.ToArray());
+                newNode.AppendChildren(editFormNode.ChildNodes);
+
+                //deal with itemtemplates... ??
 
-                if (model.All.Any(p => p.TagName.ToLower().Equals("itemtemplate")))
+                //send any child asp:* controls to be converted by the a call back out to the adapterHosting class.
+                var aspFormTags = newModel.DocumentNode.FirstChild.Descendants().Where(p => p.Name.ToLower().Contains("asp:")).ToList();
+                foreach (var formObj in aspFormTags)
                 {
-                    //deal with itemtemplates... ??
+                    var migratedControlText = await _adapterHost.MigrateTagControl(formObj.Name, formObj.OuterHtml);
+                    var tempNode = HtmlNode.CreateNode(migratedControlText);
+
+                    formObj.ParentNode.ReplaceChild(tempNode, formObj);
                 }
 
+                return newModel.DocumentNode.OuterHtml;
+
+                //var editFormNode = model.All.Where(p => p.LocalName.ToLower().Equals("asp:formview")).FirstOrDefault();
+                //var newNode = parser.ParseFragment($"<EditForm Model={editFormNode.GetAttribute("ItemType")} OnValidSubmit={editFormNode.GetAttribute("SelectMethod")}></EditForm>", editFormNode);
+
+                ////this is now a live list having substituted the EditForm control for the old FormView one
+                //newNode.First().AppendNodes(editFormNode.ChildNodes.ToArray());
+
+                //if (model.All.Any(p => p.TagName.ToLower().Equals("itemtemplate")))
+                //{
+                //    //deal with itemtemplates... ??
+                //}
+
+                ////send any child asp:* controls to be converted by the a call back out to the adapterHosting class.
+                //var aspFormTags = newNode.First().Descendents<IElement>().Where(p => p.NodeName.ToLower().Contains("asp:")).ToList();
+                //foreach (var formObj in aspFormTags)
+                //{
+                //    var migratedControlText = await _adapterHost.MigrateTagControl(formObj.NodeName, formObj.OuterHtml);
+                //    var tempNode = parser.ParseFragment(migratedControlText, null);
+
+                //    //ParseFragment always adds on a HTML & BODY tags, at least with this call setup.  We need to pull out *just* the element that we have migrated.
+                //    var appendElement = tempNode.GetElementsByTagName("BODY").First().ChildNodes;
+
+                //    formObj.Replace(appendElement.ToArray());
+                //}
+
+                //return newNode.First().ToHtml();//.OuterHTML; // .ToString();
+            }
+            catch (Exception ex)
+            {
+
+                throw ex;
+            }
+        }
+
+        /// <summary>
+        /// This method understands now to convert an asp:FormView control into a blazor equivalent.
+        /// </summary>
+        /// <param name="nodeContent"></param>
+        /// <returns></returns>
+        private async Task<string> ConvertListViewControl(string nodeContent)
+        {
+            //var model = await _angleSharpContext.OpenAsync(req => req.Content(nodeContent));
+            var currentModel = new HtmlDocument();
+            var newModel = new HtmlDocument();
+            currentModel.LoadHtml(nodeContent);
+            
+
+            try
+            {
+                var listViewNode = currentModel.DocumentNode.FirstChild;// ("//asp:listview");// model.All.Where(p => p.LocalName.ToLower().Equals("asp:formview")).FirstOrDefault();
+                
+                newModel.LoadHtml($"<ListView Model={listViewNode.GetAttributeValue("ItemType","")} OnValidSubmit={listViewNode.GetAttributeValue("SelectMethod","")}></ListView>");
+                var newNode = newModel.DocumentNode.SelectSingleNode("//listview");
+                //this is now a live list having substituted the EditForm control for the old FormView one
+                newNode.AppendChildren(listViewNode.ChildNodes);
+
                 //send any child asp:* controls to be converted by the a call back out to the adapterHosting class.
-                var aspFormTags = newNode.First().Descendents<IElement>().Where(p => p.NodeName.ToLower().Contains("asp:")).ToList();
+                var aspFormTags =  newModel.DocumentNode.FirstChild.Descendants().Where(p => p.Name.ToLower().Contains("asp:")).ToList();
                 foreach (var formObj in aspFormTags)
                 {
-                    var migratedControlText = await _adapterHost.MigrateTagControl(formObj.NodeName, formObj.OuterHtml);
-                    var tempNode = parser.ParseFragment(migratedControlText, null);
-
-                    //ParseFragment always adds on a HTML & BODY tags, at least with this call setup.  We need to pull out *just* the element that we have migrated.
-                    var appendElement = tempNode.GetElementsByTagName("BODY").First().ChildNodes;
+                    var migratedControlText = await _adapterHost.MigrateTagControl(formObj.Name, formObj.OuterHtml);
+                    var tempNode = HtmlNode.CreateNode(migratedControlText);
 
-                    formObj.Replace(appendElement.ToArray());
+                    formObj.ParentNode.ReplaceChild(tempNode, formObj);
                 }
 
-                return newNode.First().ToHtml();//.OuterHTML; // .ToString();
+                return newModel.DocumentNode.OuterHtml;
             }
             catch (Exception ex)
             {
@@ -190,30 +259,26 @@ private async Task<string> ConvertEditFormControl(string nodeContent)
         private async Task<string> ConvertContentControl(string nodeContent)
         {
             string _result = string.Empty;
-            var parser = new HtmlParser();
+            var model = new HtmlDocument();
 
             try
             {
-                var model = await _angleSharpContext.OpenAsync(req => req.Content(nodeContent));
-                var contentControlObj = model.Descendents<Element>().First(c => c.TagName.ToLower().Equals("asp:content"));
+                model.LoadHtml(nodeContent);
+                var contentControlObj = model.DocumentNode.FirstChild;
 
                 //send any child asp:* controls to be converted by the a call back out to the adapterHosting class.
-                var aspFormTags = contentControlObj.Descendents<IElement>().Where(p => p.NodeName.ToLower().Contains("asp:")).ToList();
+                var aspFormTags = contentControlObj.Descendants().Where(p => p.Name.ToLower().Contains("asp:")).ToList();
                 foreach (var formObj in aspFormTags)
                 {
-                    var migratedControlText = await _adapterHost.MigrateTagControl(formObj.NodeName, formObj.OuterHtml);
-                    var tempNode = parser.ParseFragment(migratedControlText, null);
+                    var migratedControlText = await _adapterHost.MigrateTagControl(formObj.Name, formObj.OuterHtml);
+                    var tempNode = HtmlNode.CreateNode(migratedControlText);
 
-                    //ParseFragment always adds on a HTML & BODY tags, at least with this call setup.  We need to pull out *just* the element that we have migrated.
-                    var appendElement = tempNode.GetElementsByTagName("BODY").First().ChildNodes;
-
-                    formObj.Replace(appendElement.ToArray());
+                    formObj.ParentNode.ReplaceChild(tempNode, formObj);
                 }
 
-                //There isn't any asp:content control equivalent in Blazor, so we'll just take the innerHTML
-                _result = contentControlObj.InnerHtml;
-
-                return _result;
+                //There isn't any asp:content control equivalent, so we'll just return the innerHTML
+                return contentControlObj.InnerHtml;
+ 
             }
             catch (Exception ex)
             {

…mmands/Migration/ControlConverterBase.cs …gration/Adapters/ControlConverterBase.cssrc/WebFormsToBlazorServerCommands/Migration/ControlConverterBase.cs renamed to src/WebFormsToBlazorServerCommands/Migration/Adapters/ControlConverterBase.cs src/WebFormsToBlazorServerCommands/Migration/ControlConverterBase.cs renamed to src/WebFormsToBlazorServerCommands/Migration/Adapters/ControlConverterBase.cs

@@ -10,10 +10,9 @@
 using CodeFactory.DotNet.CSharp;
 using CodeFactory.Formatting.CSharp;
 using CodeFactory.SourceCode;
-using AngleSharp.Dom;
-using AngleSharp.Html.Parser;
-using AngleSharp;
+
 using System.ComponentModel.Design;
+using HtmlAgilityPack;
 
 namespace WebFormsToBlazorServerCommands.Migration
 {
@@ -256,21 +255,21 @@ await _statusTracking.UpdateCurrentStatusAsync(MigrationStepEnum.AspxPages,
         /// </summary>
         /// <param name="elementToProcess"></param>
         /// <returns>String</returns>
-        private async Task<string> ProcessSourceElement(Element elementToProcess)
+        private async Task<string> ProcessSourceElement(HtmlNode elementToProcess)
         {
-            Element processedElement = null;
+            HtmlNode processedElement = null;
             StringBuilder processedHTML = new StringBuilder();
             var converterAdapter = new ConverterAdapter();
             converterAdapter.RegisterControlConverter(new AspxToBlazorControlConverter(converterAdapter));
 
-            var htmlParser = new AngleSharp.Html.Parser.HtmlParser();
+            var htmlParser = new HtmlDocument();
 
             try
             {
                 //If this is an ASP:* control then call the migration code, append the *entire* migrated node, and return to the calling method.
-                if (elementToProcess.LocalName.ToLower().Contains("asp:"))
+                if (elementToProcess.Name.ToLower().Contains("asp:"))
                 {
-                    var newNodeText = Task.Run(() => converterAdapter.MigrateTagControl(elementToProcess.LocalName, elementToProcess.OuterHtml)).Result;
+                    var newNodeText = await converterAdapter.MigrateTagControl(elementToProcess.Name, elementToProcess.OuterHtml);
 
                     //We do *not* deal with any children of this element, as that is the responsibility of the MigratTagControl to deal with any children of the ASP control
                     return newNodeText;
@@ -280,26 +279,29 @@ private async Task<string> ProcessSourceElement(Element elementToProcess)
                     //if the current element has children,
                     // - add it to the targetDocumentFragment without the children attached
                     // - recursively call this method to deal with the children, passing in the new appended as the parent element to append children too
-                    if (elementToProcess.ChildElementCount > 0)
+                    if (elementToProcess.ChildNodes.Count > 0)
                     {
-                        processedElement = elementToProcess.Clone(false) as Element;
-                        foreach (Element item in elementToProcess.Children)
+                        //shallow clone
+                        processedElement = elementToProcess.CloneNode(false);
+                        
+                        foreach (var item in elementToProcess.ChildNodes)
                         {
-                            var newElement = htmlParser.ParseFragment(await ProcessSourceElement(item), processedElement);
-                            processedElement.Append(newElement.ToArray());
+                            var migratedValue = await ProcessSourceElement(item);
+                            var migratedChild = HtmlNode.CreateNode( migratedValue.Length > 0 ? migratedValue : " " );
+                            processedElement.AppendChild(migratedChild);
                         }
                         processedHTML.Append(processedElement.OuterHtml);
                     } else
                     {
-                        processedHTML.Append((elementToProcess.Clone(false) as Element).OuterHtml);
+                        processedHTML.Append((elementToProcess.Clone()).OuterHtml);
                     }
-
+                    
                     return processedHTML.ToString();
                 }
             }
-            catch (Exception)
+            catch (Exception ex)
             {
-                throw;
+                throw ex;
             }
         }