À l'aide de SeleniumDriver d'extraire toutes les lignes et les colonnes étant donné un élément de tableau

Plutôt que d'utiliser le sélénium pour parser le HTML, j'utilise Jsoup. Alors que le Sélénium fournit des fonctionnalités pour voyager à travers une table, Jsoup est beaucoup plus efficace. J'ai décidé d'utiliser le Sélénium seulement de la page web de l'automatisation, et de déléguer toutes les tâches analyse de Jsoup.

Mon approche est la suivante

1. Obtenir le source HTML de l'élément requis
2. Pass qu'à Jsoup comme une chaîne de caractères à analyser

Le code que j'ai fini par écrire était très semblable à du sélénium version

String source = "<table>" + driver.findElement(By.xpath(locator)).getAttribute("innerHTML") + "<table>";
Document doc = Jsoup.parse(source, "UTF-8");
for (Element rowElmt : doc.getElementsByTag("tr"))
{
    Elements cols = rowElmt.getElementsByTag("th");
    if (cols.size() == 0 )
        cols = rowElmt.getElementsByTag("td");

    rowTxt = new String[cols.size()];
    for (int i = 0; i < rowTxt.length; i++)
    {
        rowTxt[i] = cols.get(i).text();
    }
    csv.add(rowTxt);
}

Le Sélénium analyseur prend 5 minutes pour lire un 1000 ligne de la table, tandis que le Jsoup analyseur prend moins de 10 secondes. Alors que je n'ai pas passer beaucoup de temps sur le benchmarking, je suis assez satisfait des résultats.

Je suis en utilisant HtmlAgilityPack installé en tant que Nuget pour analyser les dynamiques des tables html. ses très rapide et comme par cette réponse vous pouvez interroger les résultats à l'aide de linq. J'ai utilisé ceci pour stocker le résultat comme un DataTable. Voici les publics de la méthode d'extension de la classe:-

public static class HtmlTableExtensions
{
    private static readonly ILog Log = LogManager.GetLogger(typeof(HtmlTableExtensions));

    ///<summary>
    ///    based on an idea from https://stackoverflow.com/questions/655603/html-agility-pack-parsing-tables
    ///</summary>
    ///<param name="tableBy"></param>
    ///<param name="driver"></param>
    ///<returns></returns>
    public static HtmlTableData GetTableData(this By tableBy, IWebdriverCore driver)
    {
        try
        {
            var doc = tableBy.GetTableHtmlAsDoc(driver);
            var columns = doc.GetHtmlColumnNames();
            return doc.GetHtmlTableCellData(columns);
        }
        catch (Exception e)
        {
            Log.Warn(String.Format("unable to get table data from {0} using driver {1} ",tableBy ,driver),e);
            return null;
        }
    }

    ///<summary>
    ///    Take an HtmlTableData object and convert it into an untyped data table,
    ///    assume that the row key is the sole primary key for the table,
    ///    and the key in each of the rows is the column header
    ///    Hopefully this will make more sense when its written!
    ///    Expecting overloads for swichting column and headers,
    ///    multiple primary keys, non standard format html tables etc
    ///</summary>
    ///<param name="htmlTableData"></param>
    ///<param name="primaryKey"></param>
    ///<param name="tableName"></param>
    ///<returns></returns>
    public static DataTable ConvertHtmlTableDataToDataTable(this HtmlTableData htmlTableData,
        string primaryKey = null, string tableName = null)
    {
        if (htmlTableData == null) return null;
        var table = new DataTable(tableName);

        foreach (var colName in htmlTableData.Values.First().Keys)
        {
            table.Columns.Add(new DataColumn(colName, typeof (string)));
        }
        table.SetPrimaryKey(new[] { primaryKey });
        foreach (var values in htmlTableData
            .Select(row => row.Value.Values.ToArray<object>()))
        {
            table.Rows.Add(values);
        }

        return table;
    }


    private static HtmlTableData GetHtmlTableCellData(this HtmlDocument doc, IReadOnlyList<string> columns)
    {
        var data = new HtmlTableData();
        foreach (
            var rowData in doc.DocumentNode.SelectNodes(XmlExpressions.AllDescendants + HtmlAttributes.TableRow)
                .Skip(1)
                .Select(row => row.SelectNodes(HtmlAttributes.TableCell)
                    .Select(n => WebUtility.HtmlDecode(n.InnerText)).ToList()))
        {
            data[rowData.First()] = new Dictionary<string, string>();
            for (var i = 0; i < columns.Count; i++)
            {
                data[rowData.First()].Add(columns[i], rowData[i]);
            }
        }
        return data;
    }

    private static List<string> GetHtmlColumnNames(this HtmlDocument doc)
    {
        var columns =
            doc.DocumentNode.SelectNodes(XmlExpressions.AllDescendants + HtmlAttributes.TableRow)
                .First()
                .SelectNodes(XmlExpressions.AllDescendants + HtmlAttributes.TableHeader)
                .Select(n => WebUtility.HtmlDecode(n.InnerText).Trim())
                .ToList();
        return columns;
    }

    private static HtmlDocument GetTableHtmlAsDoc(this By tableBy, IWebdriverCore driver)
    {
        var webTable = driver.FindElement(tableBy);
        var doc = new HtmlDocument();
        doc.LoadHtml(webTable.GetAttribute(HtmlAttributes.InnerHtml));
        return doc;
    }
}

Le code html de l'objet de données est simplement une extension de dictionnaire:-

public class HtmlTableData : Dictionary<string,Dictionary<string,string>>
{

}

IWebdriverCore pilote est un wrapper sur IWebDriver ou IRemoteWebdriver qui expose l'une de ces interfaces comme une propriété en lecture seule, mais vous pourriez tout simplement la remplacer avec IWebDriver.

HtmlAttributes est statique lass holding const valeurs communes pour les attributs html pour économiser sur les fautes de frappe lorsque l'on se réfère à des éléments html/attributs/tags etc. dans le code c#: -

///<summary>
///config class holding common Html Attributes and tag names etc
///</summary>
public static class HtmlAttributes
{
    public const string InnerHtml = "innerHTML";
    public const string TableRow = "tr";
    public const string TableHeader = "th";
    public const string TableCell = "th|td";
    public const string Class = "class";

...
}

et SetPrimaryKey est une extension de la DataTable qui permet le réglage facile de la clé primaire d'une table de données:-

    public static void SetPrimaryKey(this DataTable table,string[] primaryKeyColumns)
    {
        int size = primaryKeyColumns.Length;
        var keyColumns = new DataColumn[size];
        for (int i = 0; i < size; i++)
        {
            keyColumns[i] = table.Columns[primaryKeyColumns[i]];
        }
        table.PrimaryKey = keyColumns;
    }

J'ai trouvé que c'était assez performant - < 2 ms pour analyser un 30*80 table, et son un doddle à utiliser.