Wie kann ich dynamisch generierten HTML-Code mit .NET ohne Einschränkungen abrufen?

Wie generiert man dynamisch HTML-Code mit dem WebBrowser von .NET oder mshtml.HTMLDocument?

Einführung

HTML-Code dynamisch abrufen Von Webseiten generierte Daten sind eine häufige Aufgabe in Webautomatisierungs- und Scraping-Szenarien. .NET bietet hierfür zwei Möglichkeiten: die Klasse System.Windows.Forms.WebBrowser und die Schnittstelle mshtml.HTMLDocument. Ihre effektive Verwendung kann jedoch eine Herausforderung sein.

Die WebBrowser-Klasse

Die System.Windows.Forms.WebBrowser-Klasse dient zum Einbetten von Webseiten in Ihre Anwendung. Es unterstützt zwar benutzerdefinierte Navigations- und Dokumentereignisse, ist jedoch in seiner Fähigkeit, dynamisch generiertes HTML zu erfassen, eingeschränkt.

Der folgende Codeausschnitt veranschaulicht die Verwendung von WebBrowser:

<code class="csharp">using System.Windows.Forms;
using mshtml;

namespace WebBrowserTest
{
    public class Program
    {
        public static void Main()
        {
            WebBrowser wb = new WebBrowser();
            wb.Navigate("https://www.google.com/#q=where+am+i");

            wb.DocumentCompleted += delegate(object sender, WebBrowserDocumentCompletedEventArgs e)
            {
                mshtml.IHTMLDocument2 doc = (mshtml.IHTMLDocument2)wb.Document.DomDocument;
                foreach (IHTMLElement element in doc.all)
                {
                    System.Diagnostics.Debug.WriteLine(element.outerHTML);
                }
            };
            Form f = new Form();
            f.Controls.Add(wb);
            Application.Run(f);
        }
    }
}</code>

Das mshtml.HTMLDocument Schnittstelle

Die mshtml.HTMLDocument-Schnittstelle bietet direkten Zugriff auf das zugrunde liegende HTML-Dokumentobjekt. Es erfordert jedoch manuelle Navigation und Rendering, was es für dynamisch generierte Inhalte weniger praktisch macht.

Der folgende Codeausschnitt veranschaulicht die Verwendung von mshtml.HTMLDocument:

<code class="csharp">using mshtml;

namespace HTMLDocumentTest
{
    public class Program
    {
        public static void Main()
        {
            mshtml.IHTMLDocument2 doc = (mshtml.IHTMLDocument2)new mshtml.HTMLDocument();
            doc.write(new System.Net.WebClient().DownloadString("https://www.google.com/#q=where+am+i"));

            foreach (IHTMLElement e in doc.all)
            {
                System.Diagnostics.Debug.WriteLine(e.outerHTML);
            }
        }
    }
}</code>

Ein robusterer Ansatz

Um die Einschränkungen von WebBrowser und mshtml.HTMLDocument zu überwinden, können Sie den folgenden Ansatz verwenden:

1. Erstellen Sie ein WebBrowser-Steuerelement.
2. Navigieren Sie zu Ziel-URL und verarbeiten Sie das DocumentCompleted-Ereignis, um das zugrunde liegende mshtml.HTMLDocument2-Objekt abzurufen.
3. Verwenden Sie eine Kombination aus Abfrage und Überprüfung von WebBrowser.IsBusy, um zu erkennen, wann die Seite mit dem Rendern fertig ist.
4. Rufen Sie das Stammverzeichnis ab Element und fragen Sie seine OuterHtml-Eigenschaft ab, bis es stabil wird.

Beispielcode

Der folgende C#-Code veranschaulicht diesen Ansatz:

<code class="csharp">using System;
using System.ComponentModel;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using mshtml;

namespace DynamicHTMLFetcher
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
            this.webBrowser.DocumentCompleted += WebBrowser_DocumentCompleted;
            this.Load += MainForm_Load;
        }

        private async void MainForm_Load(object sender, EventArgs e)
        {
            try
            {
                var cts = new CancellationTokenSource(10000); // cancel in 10s
                var html = await LoadDynamicPage("https://www.google.com/#q=where+am+i", cts.Token);
                MessageBox.Show(html.Substring(0, 1024) + "..."); // it's too long!
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private async Task<string> LoadDynamicPage(string url, CancellationToken token)
        {
            var tcs = new TaskCompletionSource<bool>();
            WebBrowserDocumentCompletedEventHandler handler = (s, arg) => tcs.TrySetResult(true);

            using (token.Register(() => tcs.TrySetCanceled(), useSynchronizationContext: true))
            {
                this.webBrowser.DocumentCompleted += handler;
                try
                {
                    this.webBrowser.Navigate(url);
                    await tcs.Task; // wait for DocumentCompleted
                }
                finally
                {
                    this.webBrowser.DocumentCompleted -= handler;
                }
            }

            var documentElement = this.webBrowser.Document.GetElementsByTagName("html")[0];
            var html = documentElement.OuterHtml;
            while (true)
            {
                await Task.Delay(500, token);
                if (this.webBrowser.IsBusy)
                    continue;
                var htmlNow = documentElement.OuterHtml;
                if (html == htmlNow)
                    break; // no changes detected, end the poll loop
                html = htmlNow;
            }

            token.ThrowIfCancellationRequested();
            return html;
        }

        private void WebBrowser_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e)
        {
            // Intentional no-op handler, we receive the DocumentCompleted event in the calling method.
        }
    }
}</code>

Dieser Ansatz stellt sicher, dass Sie den vollständig gerenderten HTML-Code erhalten, auch wenn dieser dynamisch generiert wird.

Das obige ist der detaillierte Inhalt vonWie kann ich dynamisch generierten HTML-Code mit .NET ohne Einschränkungen abrufen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!