Stampa di un DataTable di testo/file di testo in .NET

Question

v'è un predefinito o un metodo "facile" di scrivere un DataTable in un file di testo o controllo TextBox (con font a spaziatura fissa), come DataTable.Print():

 
Column1| Column2| 
--------|--------| 
     v1|  v2| 
     v3|  v4| 
     v5|  v6| 

Modifica

Ecco una prima versione (vb.net) - nel caso in cui qualcuno è interessato o vuole costruire la propria:

Public Function BuildTable(ByVal dt As DataTable) As String 

    Dim result As New StringBuilder 
    Dim widths As New List(Of Integer) 
    Const ColumnSeparator As Char = "|"c 
    Const HeadingUnderline As Char = "-"c 

    ' determine width of each column based on widest of either column heading or values in that column 
    For Each col As DataColumn In dt.Columns 
     Dim colWidth As Integer = Integer.MinValue 
     For Each row As DataRow In dt.Rows 
      Dim len As Integer = row(col.ColumnName).ToString.Length 
      If len > colWidth Then 
       colWidth = len 
      End If 
     Next 
     widths.Add(CInt(IIf(colWidth < col.ColumnName.Length, col.ColumnName.Length + 1, colWidth + 1))) 
    Next 

    ' write column headers 
    For Each col As DataColumn In dt.Columns 
     result.Append(col.ColumnName.PadLeft(widths(col.Ordinal))) 
     result.Append(ColumnSeparator) 
    Next 
    result.AppendLine() 

    ' write heading underline 
    For Each col As DataColumn In dt.Columns 
     Dim horizontal As String = New String(HeadingUnderline, widths(col.Ordinal)) 
     result.Append(horizontal.PadLeft(widths(col.Ordinal))) 
     result.Append(ColumnSeparator) 
    Next 
    result.AppendLine() 

    ' write each row 
    For Each row As DataRow In dt.Rows 
     For Each col As DataColumn In dt.Columns 
      result.Append(row(col.ColumnName).ToString.PadLeft(widths(col.Ordinal))) 
      result.Append(ColumnSeparator) 
     Next 
     result.AppendLine() 
    Next 

    Return result.ToString() 

End Function 

Answer 1

No, là isn 'T. Dovrai fare da solo la formattazione, o trovare una libreria di terze parti che faccia da te.

Answer 2

si potrebbe usare un DataTableReader:

public static string PrintTable(this DataTable dt) 
{ 
    DataTableReader dtReader = dt.CreateDataReader(); 
    StringBuilder result = new StringBuilder(); 
    while (dtReader.Read()) 
    { 
     for (int i = 0; i < dtReader.FieldCount; i++) 
     { 
      result.AppendFormat("{0} = {1}", 
       dtReader.GetName(i).Trim(), 
       dtReader.GetValue(i).ToString().Trim()); 
     } 
     result.AppendLine(); 
    } 
    dtReader.Close(); 
    return result.ToString(); 
} 

Answer 3

vi consiglio di controllare il mio articolo DataTable Formatter.
La classe My DataTableFormatter contiene metodi per la formattazione di DataTable come tabelle basate sui caratteri (requisiti), tabelle HTML o tabelle del documento di flusso.

È possibile scaricare il progetto contenente la classe dal mio sito Web, ma per praticità posterò il codice qui.

/// <summary> 
/// Gets a string representation of the <see cref="System.Data.DataTable" />. 
/// </summary> 
/// <remarks>The string representation should be displayed with a monospaced font.</remarks> 
public static string GetStringRepresentation(DataTable dataTable) 
{ 
    if (dataTable == null) 
     throw new ArgumentNullException("'dataTable' cannot be null."); 

    StringWriter representationWriter = new StringWriter(); 

    // First, set the width of every column to the length of its largest element. 
    int[] columnWidths = new int[dataTable.Columns.Count]; 
    for (int columnIndex = 0; columnIndex < dataTable.Columns.Count; columnIndex++) 
    { 
     int headerWidth = dataTable.Columns[columnIndex].ColumnName.Length; 
     int longestElementWidth = dataTable.AsEnumerable() 
      .Select((row) => row[columnIndex].ToString().Length) 
      .Max(); 
     columnWidths[columnIndex] = Math.Max(headerWidth, longestElementWidth); 
    } 

    // Next, write the table 
    // Write a horizontal line. 
    representationWriter.Write("+-"); 
    for (int columnIndex = 0; columnIndex < dataTable.Columns.Count; columnIndex++) 
    { 
     for (int i = 0; i < columnWidths[columnIndex]; i++) 
      representationWriter.Write("-"); 
     representationWriter.Write("-+"); 
     if (columnIndex != dataTable.Columns.Count - 1) 
      representationWriter.Write("-"); 
    } 
    representationWriter.WriteLine(" "); 
    // Print the headers 
    representationWriter.Write("| "); 
    for (int columnIndex = 0; columnIndex < dataTable.Columns.Count; columnIndex++) 
    { 
     string header = dataTable.Columns[columnIndex].ColumnName; 
     representationWriter.Write(header); 
     for (int blanks = columnWidths[columnIndex] - header.Length; blanks > 0; blanks--) 
      representationWriter.Write(" "); 
     representationWriter.Write(" | "); 
    } 
    representationWriter.WriteLine(); 
    // Print another horizontal line. 
    representationWriter.Write("+-"); 
    for (int columnIndex = 0; columnIndex < dataTable.Columns.Count; columnIndex++) 
    { 
     for (int i = 0; i < columnWidths[columnIndex]; i++) 
      representationWriter.Write("-"); 
     representationWriter.Write("-+"); 
     if (columnIndex != dataTable.Columns.Count - 1) 
      representationWriter.Write("-"); 
    } 
    representationWriter.WriteLine(" "); 

    // Print the contents of the table. 
    for (int row = 0; row < dataTable.Rows.Count; row++) 
    { 
     representationWriter.Write("| "); 
     for (int column = 0; column < dataTable.Columns.Count; column++) 
     { 
      representationWriter.Write(dataTable.Rows[row][column]); 
      for (int blanks = columnWidths[column] - dataTable.Rows[row][column].ToString().Length; 
       blanks > 0; blanks--) 
       representationWriter.Write(" "); 
      representationWriter.Write(" | "); 
     } 
     representationWriter.WriteLine(); 
    } 

    // Print a final horizontal line. 
    representationWriter.Write("+-"); 
    for (int column = 0; column < dataTable.Columns.Count; column++) 
    { 
     for (int i = 0; i < columnWidths[column]; i++) 
      representationWriter.Write("-"); 
     representationWriter.Write("-+"); 
     if (column != dataTable.Columns.Count - 1) 
      representationWriter.Write("-"); 
    } 
    representationWriter.WriteLine(" "); 

    return representationWriter.ToString(); 
} 

Il metodo GetStringRepresentation (DataTable) dà risultati come questo

 

    +------------------+----------------+-------------------+ 
    | Item    | Units in Stock | Unit Price  | 
    +------------------+----------------+-------------------+ 
    | Drilling machine | 1000   | $1,000,000  | 
    | Backpack   | 320   | $24    | 
    | Chocolate bar | 100000   | $2.00000000000000 | 
    +------------------+----------------+-------------------+ 

dovrei ammettere che questo stile tabella viene truffato dal client a riga di comando di MySQL.