WebClient client = new WebClient();
string html = client.DownloadString(@"http://www.table.co.uk");
DataSet dataSet = HtmlTableParser.Parse(html);

/// <summary>
/// HtmlTableParser parses the contents of an html string into a System.Data DataSet or DataTable.
/// </summary>
public class HtmlTableParser
{
    private const RegexOptions ExpressionOptions = RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.IgnoreCase;
 
    private const string CommentPattern = "<!--(.*?)-->";
    private const string TablePattern = "<table[^>]*>(.*?)</table>";
    private const string HeaderPattern = "<th[^>]*>(.*?)</th>";
    private const string RowPattern = "<tr[^>]*>(.*?)</tr>";
    private const string CellPattern = "<td[^>]*>(.*?)</td>";
 
    /// <summary>
    /// Given an HTML string containing n table tables, parse them into a DataSet containing n DataTables.
    /// </summary>
    /// <param name="html">An HTML string containing n HTML tables</param>
    /// <returns>A DataSet containing a DataTable for each HTML table in the input HTML</returns>
    public static DataSet ParseDataSet(string html)
    {
        DataSet dataSet = new DataSet();
        MatchCollection tableMatches = Regex.Matches(
            WithoutComments(html),
            TablePattern,
            ExpressionOptions);
 
        foreach (Match tableMatch in tableMatches)
        {
            dataSet.Tables.Add(ParseTable(tableMatch.Value));
        }
 
        return dataSet;
    }
 
    /// <summary>
    /// Given an HTML string containing a single table, parse that table to form a DataTable.
    /// </summary>
    /// <param name="tableHtml">An HTML string containing a single HTML table</param>
    /// <returns>A DataTable which matches the input HTML table</returns>
    public static DataTable ParseTable(string tableHtml)
    {
        string tableHtmlWithoutComments = WithoutComments(tableHtml);
 
        DataTable dataTable = new DataTable();
 
        MatchCollection rowMatches = Regex.Matches(
            tableHtmlWithoutComments,
            RowPattern,
            ExpressionOptions);
 
        dataTable.Columns.AddRange(tableHtmlWithoutComments.Contains("<th")
                                       ? ParseColumns(tableHtml)
                                       : GenerateColumns(rowMatches));
 
        ParseRows(rowMatches, dataTable);
 
        return dataTable;
    }
 
    /// <summary>
    /// Strip comments from an HTML stirng
    /// </summary>
    /// <param name="html">An HTML string potentially containing comments</param>
    /// <returns>The input HTML string with comments removed</returns>
    private static string WithoutComments(string html)
    {
        return Regex.Replace(html, CommentPattern, string.Empty, ExpressionOptions);
    }
 
    /// <summary>
    /// Add a row to the input DataTable for each row match in the input MatchCollection
    /// </summary>
    /// <param name="rowMatches">A collection of all the rows to add to the DataTable</param>
    /// <param name="dataTable">The DataTable to which we add rows</param>
    private static void ParseRows(MatchCollection rowMatches, DataTable dataTable)
    {
        foreach (Match rowMatch in rowMatches)
        {
            // if the row contains header tags don't use it - it is a header not a row
            if (!rowMatch.Value.Contains("<th"))
            {
                DataRow dataRow = dataTable.NewRow();
 
                MatchCollection cellMatches = Regex.Matches(
                    rowMatch.Value,
                    CellPattern,
                    ExpressionOptions);
 
                for (int columnIndex = 0; columnIndex < cellMatches.Count; columnIndex++)
                {
                    dataRow[columnIndex] = cellMatches[columnIndex].Groups[1].ToString();
                }
 
                dataTable.Rows.Add(dataRow);
            }
        }
    }
 
    /// <summary>
    /// Given a string containing an HTML table, parse the header cells to create a set of DataColumns
    /// which define the columns in a DataTable.
    /// </summary>
    /// <param name="tableHtml">An HTML string containing a single HTML table</param>
    /// <returns>A set of DataColumns based on the HTML table header cells</returns>
    private static DataColumn[] ParseColumns(string tableHtml)
    {
        MatchCollection headerMatches = Regex.Matches(
            tableHtml,
            HeaderPattern,
            ExpressionOptions);
 
        return (from Match headerMatch in headerMatches
                select new DataColumn(headerMatch.Groups[1].ToString())).ToArray();
    }
 
    /// <summary>
    /// For tables which do not specify header cells we must generate DataColumns based on the number
    /// of cells in a row (we assume all rows have the same number of cells).
    /// </summary>
    /// <param name="rowMatches">A collection of all the rows in the HTML table we wish to generate columns for</param>
    /// <returns>A set of DataColumns based on the number of celss in the first row of the input HTML table</returns>
    private static DataColumn[] GenerateColumns(MatchCollection rowMatches)
    {
        int columnCount = Regex.Matches(
            rowMatches[0].ToString(),
            CellPattern,
            ExpressionOptions).Count;
 
        return (from index in Enumerable.Range(0, columnCount)
                select new DataColumn("Column " + Convert.ToString(index))).ToArray();
    }
}

/// <summary>
/// Tests for the HtmlTableParser class
/// </summary>
[TestClass]
public class ParserTest
{
    private TestContext testContextInstance;
 
    /// <summary>
    /// Verify that HtmlTableParser can parse an HTML file containing a single table. The
    /// test file includes a commented out table which should be ignored. Note some tags use
    /// attributes (we test we can parse tags with and without attributes).
    /// </summary>
    [TestMethod]
    [DeploymentItem(@"data\singleTable.txt")]
    public void TestParseSingleTable()
    {
        string html = File.ReadAllText("singleTable.txt");
        DataTable table = HtmlTableParser.ParseTable(html);
 
        AssertTable(GetExpectedData(), table);
    }
 
    /// <summary>
    /// Verify that HtmlTableParser can parse an HTML file containing multiple tables. The
    /// test file includes a commented out table which should be ignored. The test file
    /// contains tables both with and without headers.
    /// </summary>
    [TestMethod]
    [DeploymentItem(@"data\multipleTables.txt")]
    public void TestParseMultipleTables()
    {
        string html = File.ReadAllText("multipleTables.txt");
        DataSet dataSet = HtmlTableParser.ParseDataSet(html);
        Assert.AreEqual(3, dataSet.Tables.Count);
 
        var expected = GetExpectedData();
 
        foreach (DataTable table in dataSet.Tables)
        {
            AssertTable(expected, table);
        }
    }
 
    private static string[][] GetExpectedData()
    {
        return new[]
        {
            new[] { "row 1, cell 1", "row 1, cell 2" },
            new[] { "row 2, cell 1", "row 2, cell 2" }
        };
    }
 
    private static void AssertTable(string[][] expected, DataTable table)
    {
        Assert.AreEqual(expected.Count(), table.Rows.Count, "Table did not contain the expected number of rows");
 
        for (int i = 0; i < expected.Count(); i++)
        {
            for (int j = 0; j < expected[i].Count(); j++)
            {
                string actualElement = (table.Rows[i][j] as string).Trim();
                string expectedElement = expected[i][j];
 
                Assert.AreEqual<string>(expectedElement, actualElement, "Table did not contain the expected element");
            }
        }
    }
}

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
      <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
    <meta name="robots" content="all" />
      <title>Title</title>
</head>
 
<body>
      <!-- This table is commented out, so it shouldn't be parsed.
      <table border="1">
            <tr  border="1">
                  <th>Commented Heading 1</th>
                  <th>Commented Heading 2</th>
            </tr>
            <tr  border="1">
                  <td>Commented row 1, cell 1</td>
                  <td>Commented row 1, cell 2</td>
            </tr>
            <tr  border="1">
                  <td>Commented row 2, cell 1</td>
                  <td>Commented row 2, cell 2</td>
            </tr>
      </table>
      -->
 
      <!-- The parser should ignore the border attributes -->
      <table border="1">
            <tr  border="1">
                  <th>Heading 1</th>
                  <th>Heading 2</th>
            </tr>
            <tr>
                  <td border="1">row 1, cell 1</td>
                  <td>row 1, cell 2</td>
            </tr>
            <tr  border="1">
                  <td>row 2, cell 1</td>
                  <td>row 2, cell 2</td>
            </tr>
      </table> 
</body>
</html>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
      <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
    <meta name="robots" content="all" />
      <title>Title</title>
</head>
 
<body>
      <!-- The parser should ignore the border attributes -->
      <table border="1">
            <tr  border="1">
                  <td>row 1, cell 1</td>
                  <td>row 1, cell 2</td>
            </tr>
            <tr  border="1">
                  <td>row 2, cell 1</td>
                  <td>row 2, cell 2</td>
            </tr>
      </table> 
      <!-- This table is commented out, so it shouldn't be parsed.
      <table border="1">
            <tr  border="1">
                  <th>Commented Heading 1</th>
                  <th>Commented Heading 2</th>
            </tr>
            <tr  border="1">
                  <td>Commented row 1, cell 1</td>
                  <td>Commented row 1, cell 2</td>
            </tr>
            <tr  border="1">
                  <td>Commented row 2, cell 1</td>
                  <td>Commented row 2, cell 2</td>
            </tr>
      </table>
      -->
      <table border="1">
            <tr  border="1">
                  <th>Heading 1</th>
                  <th>Heading 2</th>
            </tr>
            <tr  border="1">
                  <td>row 1, cell 1</td>
                  <td>row 1, cell 2</td>
            </tr>
            <tr  border="1">
                  <td>row 2, cell 1</td>
                  <td>row 2, cell 2</td>
            </tr>
      </table> 
      <table>
            <tr>
                  <td>row 1, cell 1</td>
                  <td>row 1, cell 2</td>
            </tr>
            <tr  border="1">
                  <td>row 2, cell 1</td>
                  <td border="1">row 2, cell 2</td>
            </tr>
      </table> 
</body>
</html>

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <!-- most of the project file omitted for brevity -->
  <Target Name="BeforeBuild" DependsOnTargets="GenerateDbClasses;"> </Target>
  <Target Name="GenerateDbClasses" Inputs="Prebuild\Configuration.xml;Prebuild\DbmlPruner.xslt;Prebuild\GenerateTestTypes.xslt" Outputs="MasterDb.Generated.cs;TestMasterDbTypes.cs">
    <Exec Command="$(ProjectDir)Prebuild\generate.bat $(ProjectDir) $(TargetName) master.dbml prunedmaster.dbml TestMasterDbTypes.cs MasterDb Configuration.xml master" />
  </Target>
</Project>

<?xml version="1.0" encoding="utf-8"?>
<!-- This configuration is used to specify which tables should generate linq to SQL classes, 
  and to generate a sanity check class which verifies all the expected types exist in the 
  generated code.
  -->
<Configuration Name="Master Tables" SourceXml="master.dbml" Namespace="Master.Data.Linq" TestClassName="TestMasterTypes">
  <Table SqlName="dbo.TestTable" DataContextPropertyName="TestTable" ClassName="TestTableRow"/>
</Configuration>

<?xml version="1.0" encoding="utf-8"?>
<!-- ===========================================================
  Generate a C# class with members corresponding to all the linq
  to SQL tables specified in the input file.
================================================================ -->
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
  <xsl:output method="text" />
  <xsl:template match="/">
//-----------------------------------------------------------------------
// <![CDATA[<auto-generated>]]>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost 
//     if the code is regenerated.
// <![CDATA[</auto-generated>]]>
//-----------------------------------------------------------------------
 
// Disable warning CS0169: The private field 'foo' is never used. This is 
// by design.
#pragma warning disable 0169
 
namespace <xsl:value-of select="/Configuration/@Namespace" />
{
    /// <![CDATA[<summary>]]>
    /// This class is provided as a compile time test for the linq to SQL
    /// classes specified in Prebuild/configuration.xml. It will fail to
    /// compile if one of the dependent classes is not generated (or not
    /// generated with the expected name). This is by design.
    /// <![CDATA[</summary>]]>
    internal class <xsl:value-of select="/Configuration/@TestClassName" />
    {      
<xsl:for-each select="/Configuration/Table"><xsl:text>&#9;</xsl:text><xsl:text>&#9;</xsl:text>private <xsl:value-of select="@ClassName" /> <xsl:value-of select="' '" /> <xsl:value-of select="concat(@ClassName, 'Member')" />;<xsl:text>&#xa;</xsl:text></xsl:for-each><xsl:text>&#9;</xsl:text>}
}
 
#pragma warning restore 0169
  </xsl:template>
</xsl:stylesheet>

<?xml version="1.0" encoding="utf-8"?>
<!-- ===========================================================
  Replicate a .dbml file based on the tables specified in a 
  configuration.
================================================================ -->
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
	 xmlns:sql="http://schemas.microsoft.com/linqtosql/dbml/2007"
     version="1.0" >
  	<xsl:output method="xml" version="1.0" encoding="utf-8" indent="yes"
  	  omit-xml-declaration = "no"/>
 
	<xsl:template match="Configuration">
 
		<!-- load sql metal output as $database -->
		<xsl:variable name="database" select="document(@SourceXml)"/>
    <xsl:variable name="namespace" select="namespace-uri($database/sql:Database)"/>
 
		<xsl:comment> =====================================================================================
  <xsl:value-of select="@Name" /> generated from database <xsl:value-of select="$database/sql:Database/@Name" /> (<xsl:value-of select="@SourceXml" />)
========================================================================================== </xsl:comment>
 
		<!-- Output a tree which replicates @SourceXml but contains only the table nodes in the configuration -->
		<xsl:element name="Database" namespace="{$namespace}">
			<xsl:attribute name="Name">
        		<xsl:value-of select="$database/sql:Database/@Name" />
      		</xsl:attribute>
 
			<xsl:for-each select="/Configuration/Table">
 
				<xsl:variable name="sqlName" select="@SqlName"/>
 
				<!-- only output a table element when the source table exists -->
				<xsl:if test="$database/sql:Database/sql:Table[@Name=$sqlName]">
 
					<!-- Output the table substituting Member and Type for the ClassName in the configuration -->
					<xsl:element name="Table" namespace="{$namespace}">
						<xsl:attribute name="Name">
							<xsl:value-of select="@SqlName"/>
						</xsl:attribute>
						<xsl:attribute name="Member">
							<xsl:value-of select="@DataContextPropertyName"/>
						</xsl:attribute>
 
						<xsl:element name="Type" namespace="{$namespace}">
							<xsl:attribute name="Name">
								<xsl:value-of select="@ClassName"/>
							</xsl:attribute>
 
							<!-- Copy the children (Columns etc) -->
							<xsl:copy-of select="$database/sql:Database/sql:Table[@Name=$sqlName]/sql:Type/*"/>
						</xsl:element>
 
					</xsl:element>
 
				</xsl:if>
			</xsl:for-each>
		</xsl:element>
	</xsl:template>
 
</xsl:stylesheet>

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: Generate LINQ to SQL classes based on tables defined in an xml config
::
 
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
setlocal 
 
set SQLMETAL=<put your path here!>\sdk\Win2008\Bin\sqlmetal.exe
set MSXSL=<put your path here!>\msxsl.exe
 
set PRJDIR=%1%
set PREDIR=%PRJDIR%Prebuild\
 
set NAMESPACE=%2
 
set METALOUT=%PREDIR%%3
set METALIN=%PREDIR%%4
 
set COMPILETESTCLASS=%PRJDIR%%5
set CONTEXTCLASS=%6
set CONTEXTCLASSFILE=%PRJDIR%%CONTEXTCLASS%.Generated.cs
 
set CONFIGPATH=%PREDIR%%7
set DATABASE=%8
 
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
echo ================ Generation of LINQ to SQL classes started ================
echo Using %CONFIGPATH%
 
echo 1. Building %METALOUT% for entire %DATABASE% database 
%SQLMETAL% /conn:"server=localhost; database=%DATABASE%;Integrated Security=SSPI" /dbml:%METALOUT%
if errorlevel 1 goto :Failed
 
echo 2. Generating %COMPILETESTCLASS% to test linq to sql types were generated correctly at compile time
%MSXSL% %CONFIGPATH% %PREDIR%GenerateTestTypes.xslt -o %COMPILETESTCLASS%
if errorlevel 1 goto :Failed
 
echo 3. Building %METALIN% from %CONFIGPATH%
%MSXSL% %CONFIGPATH% %PREDIR%DbmlPruner.xslt -o %METALIN%
if errorlevel 1 goto :Failed
 
echo 4. Generating %CONTEXTCLASSFILE% using %METALIN%
%SQLMETAL% %METALIN% /code:%CONTEXTCLASSFILE% /language:csharp /context:%CONTEXTCLASS% /namespace:%NAMESPACE% /serialization:Unidirectional
if errorlevel 1 goto :Failed
 
echo ======== Generation of LINQ to SQL classes completed successfully =========
endlocal
goto :EOF
 
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:Failed
 
echo Configuration %CONFIG% FAILED
endlocal
exit /B 1

/// <summary>
/// Compute the set of combinations, where a combination is an un-ordered collection 
/// of elements taken from the candidate set. Each element must appear zero or once. 
/// For set [1,2,3], the combinations are [1], [1,2], [1,2,3], [2], [2,3] and [3].
/// </summary>
/// <typeparam name="T">The type of objects whose combinations we evaluate</typeparam>
/// <param name="set">The set from which to combine elements</param>
/// <returns>The set of combinations</returns>
public static IEnumerable<IEnumerable<T>> Combinations<T>(this IEnumerable<T> set)
{
    int n = set.Count();
 
    for (int skip = 0; skip < n; skip++)
    {
        for (int take = 1; take <= n - skip; take++)
        {
            yield return set.Skip(skip).Take(take);
        }
    }
}

[TestMethod]
public void CombinationsOfNone()
{
    var candidates = new List<int>();
    var combinations = new List<List<int>>();
 
    AssertEqualSetsOfSets(combinations, candidates.Combinations());
}
 
[TestMethod]
public void CombinationsOfOne()
{
    var candidates = new List<int>() { 1 };
 
    var combinations = new List<List<int>>() 
    { 
        new List<int>() {1}
    };
 
    AssertEqualSetsOfSets(combinations, candidates.Combinations());
}
 
[TestMethod]
public void CombinationsOfThree()
{
    var candidates = new List<int>() { 1, 2, 3 };
 
    var combinations = new List<List<int>>() 
    { 
        new List<int>() {1}, 
        new List<int>() {1, 2},
        new List<int>() {1, 2, 3},
        new List<int>() {2},
        new List<int>() {2, 3},
        new List<int>() {3}
    };
 
    AssertEqualSetsOfSets(combinations, candidates.Combinations());
}
 
private void AssertEqualSetsOfSets(List<List<int>> expected, IEnumerable<IEnumerable<int>> actual)
{
    Assert.AreEqual<int>(expected.Count, actual.Count());
 
    var expectedIter = expected.GetEnumerator();
    var actualIter = actual.GetEnumerator();
 
    while (expectedIter.MoveNext() && actualIter.MoveNext())
    {
        Assert.IsTrue(OrderIndependentEqual(expectedIter.Current, actualIter.Current));
    }
}
 
public bool OrderIndependentEqual<T>(IEnumerable<T> first, IEnumerable<T> second)
{
    return !first.Except(second).Concat(second.Except(first)).Any();
}