Question

因此问题的基本前提是我们有一个文本文件，其中包含可能或可能不是Web服务的数据列表。从文本文件中存在的Web服务列表中，我想解析每个Web服务可用的Web方法，并将此数据发布到Excel工作表。

我将举例说明测试数据的样子：

<Resource Name="APP1">
    <Uri UriType="PAGE" ResourceUri="http://exampleurl/default.aspx" />
</Resource>
<Resource Name="App2">
    <Uri UriType="PAGE" ResourceUri="http://exampleurl2/example.aspx" />
</Resource>
<Resource Name="App3">
    <Uri UriType="PAGE" ResourceUri="http://exampleurl3/exampleapp.asmx" />
</Resource>

基本上，最后一行是我想要使用的行。可用行的另一个例子是

<Resource Name="Example" WSDL="http://example.wsdl">
    <Uri UriType="ASMX" ResourceUri="http://example.asmx" />
</Resource>

所以，我基本上在寻找.asmx和.wsdl个文件。我对此问题的思考方式是将我的输入标准化为仅查找每个Web服务的WSDL，因此对于.asmx的网址，我将添加?wsdl。

现在，我已经实施了一个解决方案。由于源文件中有数千个Web服务，并且可能有n个Web方法，因此我认为执行时间最多需要1-2个小时。我想知道是否可以进一步改进此解决方案以加快运行时间。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Text.RegularExpressions;
using System.Xml;
using System.Net;
using System.Data;
using ClosedXML.Excel;

namespace ParseWebservices
{
    class Program
    {
        static void Main(string[] args)
        {

            var lines = File.ReadAllText(@"PATH\SourceFIle.xml");
            int count = 0;
            string text = "";
            DataTable Webservices= new DataTable();
            Webservices.Columns.Add("Wsdl URL");
            Webservices.Columns.Add("Webservice Name");
            Webservices.Columns.Add("WebMethod");

            Regex r = new Regex("(?<=ResourceUri=\")(.*)(.asmx)(?=\")", RegexOptions.IgnoreCase);
            Match m = r.Match(lines.ToString());
            while (m.Success)
            {


                try
                {

                    string[] test = m.ToString().Split('/');
                    string webservicename = test[test.Length - 1].Replace(".asmx", "");
                    string wsdlurl="";

                    var webClient = new WebClient();
                    string readHtml="";
                    try
                    {
                        readHtml = webClient.DownloadString(wsdlurl);
                    }
                    catch (Exception excxx)
                    {
                        wsdlurl = m.ToString().Replace(".asmx", ".wsdl");
                        readHtml = webClient.DownloadString(wsdlurl);
                    }

                    int count2 = 0;
                    string text2 = "";
                    Regex r2 = new Regex(@"(?<=s:element name\=\"")(.*)(?=Response"")", RegexOptions.IgnoreCase);
                    Match m2 = r2.Match(readHtml);
                    while (m2.Success)
                    {
                        DataRow dr = Webservices.NewRow();

                        dr[0] = wsdlurl;
                        dr[1] = webservicename;
                        dr[2] = m2.ToString();
                        Console.WriteLine(wsdlurl + "\n" + webservicename + "\n" + m2.ToString());
                        Webservices.Rows.Add(dr);
                        count2++;
                        m2 = m2.NextMatch();
                    }
                    count++;
                    m = m.NextMatch();
                }
                catch (Exception ex)
                {
                    m = m.NextMatch();
                }
            }

            XLWorkbook wb = new XLWorkbook();
            wb.Worksheets.Add(Webservices, "Example");
            wb.SaveAs(@"PATH\example.xlsx");
        }
    }
}

我不喜欢这个解决方案的一点是它依赖于异常。因为正则表达式匹配.asmx个字符串，所以我意识到它找不到.wsdl的字符串。但我也注意到，在包含.wsdl的源文本中，.asmx前缀完全相同。所以我为那些测试用例添加了错误处理，但绝对不理想。

无论如何，我很感激有关如何改进并使其更快（更好！）的任何建议。

Answer 1

这很慢，因为它都是在一个线程上完成的！（无论是xml还是正则表达式都与缓慢有关：它是所有内联网请求真的让你失望）

如果没有源文件，很难做一个工作示例，所以我编写了一个辅助扩展来异步加载Urls列表 - 你显然需要在它周围填写你的代码。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Text.RegularExpressions;
using System.Xml;
using System.Net;
using System.Data;
using System.Collections.Concurrent;

using System.Threading.Tasks;

namespace ParseWebservices
{
    static class UrlLoaderExtension
    {
    public static async Task<ConcurrentDictionary<string, string>> LoadUrls(this IEnumerable<string> urls)
    {
        var result = new ConcurrentDictionary<string,string>();                
        Task[] tasks = urls.Select(url => {
            return Task.Run(async () =>
            {
                using (WebClient wc = new WebClient())
                {
                    // Console.WriteLine("Thread: " + System.Threading.Thread.CurrentThread.ManagedThreadId);
                    try
                    {
                        var r = await wc.DownloadStringTaskAsync(url);
                        result[url] = r;
                    }
                    catch (Exception err)
                    {
                        result[url] = err.Message;
                    }
                }
            });
        }).ToArray();                
        await Task.WhenAll(tasks);
        return result;
    }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var requests = new ConcurrentDictionary<string,string>();

            // load desired urls into the structure
            requests["http://www.microsoft.com"] = null;
            requests["http://www.google.com"] = null;
            requests["http://www.google.com/asdfdsaf"] = null;

            try
            {
                Task.Run(async () =>
                {
                    requests = await requests.Keys.LoadUrls();
                }).GetAwaiter().GetResult();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: " + ex.Message);
                Console.ReadLine();
                return;
            }

            Console.WriteLine("Finished loading data concurrently");
            Console.ReadLine();

            // this part is synchronous (it's not waiting for IO)
            foreach(var url in requests.Keys)
            {
                var response = requests[url];
                Console.WriteLine(response); // 
                Console.WriteLine("Response from " + url);
                Console.ReadLine();
            }



            Console.Write("DONE");
            Console.ReadLine();
        }
    }
}

我建议你把你的网址放到这个演示中，以了解你能加载数据的速度有多快：它告诉你它完成加载的时间点就是它收集了所有的响应。

然后，在你确定了（非常！）这么快之后，你就会有动力去填补你周围的其他逻辑：）

希望它有所帮助！

Answer 2

与评论建议一样，如果您的示例是有效的XML，我怀疑XML解析解决方案可能比Regex更容易使用和更快。你可以尝试类似的东西：

var files = XElement.Parse(xmlString)
    .Descendants("Resource").SelectMany(resource =>
    {
        XAttribute wsdlAttribute = resource.Attribute("WSDL");
        XAttribute resourceUriAttribute = resource.Element("Uri").Attribute("ResourceUri");
        if (wsdlAttribute != null)
            return new[] { wsdlAttribute.Value, resourceUriAttribute.Value };
        else
            return new[] { resourceUriAttribute.Value };
    }).Select(uri => Path.GetFileName(uri));

返回：

default.aspx
example.aspx
exampleapp.asmx
example.wsdl
example.asmx

使用我在帖子中创建的测试xml字符串：

        string xmlString = 
@"<Root>
    <Resource Name=""APP1"">
        <Uri UriType=""PAGE"" ResourceUri=""http://exampleurl/default.aspx"" />
    </Resource>
    <Resource Name=""App2"">
        <Uri UriType=""PAGE"" ResourceUri=""http://exampleurl2/example.aspx"" />
    </Resource>
    <Resource Name=""App3"">
        <Uri UriType=""PAGE"" ResourceUri=""http://exampleurl3/exampleapp.asmx"" />
    </Resource>
    <Resource Name=""Example"" WSDL=""http://example.wsdl"">
        <Uri UriType=""ASMX"" ResourceUri=""http://example.asmx"" />
    </Resource>
</Root>";

我不能保证会比你的解决方案更快，但我们非常欢迎你来测试它！如果要处理多个文件，也可以对此进行处理。

改进解析解决方案

2 个答案: