Hallo,
Zunächst: Du solltest genauer lesen! Was Du dort zusammeninterpretierst, habe ich so nicht geschrieben.
Damit wir uns nicht theoretischen Diskussionen verlieren, mal ein klein wenig Praxis.
Deine Beschreibung ist nicht gerade hinreichend, aber mit etwas Phantasie (vor allem
auch auf Deine Seite ;-)) solltest Du anhand des folgenden Beispiels sehen,
wie man es machen könnte.
Grundsätzlicher Ablauf ist entsprechend dem, was ich gestern vorgeschlagen hatte:
- Einlesen aller Textdateien, wobei jede Textdatei in eine DataTable kommt.
- Verarbeitung, die sich auf das Feststellen des Datentyps beschränkt und um Deine Anforderung ergänzt werden sollte.
- Ausgabe (Datenbank), wobei die Tabelle erstellt und alle DataTables in eine Tabelle ("Mohrenkopf" übertragen werden.
- Den Teil mit der Ausgabe als erneute Textdatei (oder Anzeige in einem Grid) habe ich ausgelassen.
Der Code hat mehr Löcher als ein Schweizer Käse, aber Deiner Beschreibung war nicht mehr zu entlocken
(und mehr als eine dreiviertel Stunde hatte ich mir eh nicht genehmigt - wegen Fußball u.a.m. ;-)
Getestet ist das ganze für den Pseudo-Input wie im Kopf als Kommentar eingefügt ist.
Da Dein Aufbau mit höchster Wahrscheinlichkeit anders (komplexer) aufgebaut ist,
wirst Du dort anfangen bzw. Deinen bestehenden Code dort einbauen müssen.
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Globalization;
using System.Data;
using System.Data.SqlServerCe;
namespace ElmarBoye.Samples.Code
{
/* 1. Eingabe: Textfile1.txt
Textfile1
A;D;G
12,45;d1;1,0
*/
/* 2. Eingabe: Textfile2.txt
Textfile2
A;C;G;H
345,67;c1;g1;h1
*/
/// <summary>Steuert die Verarbeitung.</summary>
/// <example>
/// var eva = new MohrenkopfEVA(@"F:\TEMP\Mohrenkopf", Properties.Settings.Default.NorthwindConnectionString);
// eva.Ausführen();
/// </example>
public class MohrenkopfEVA
{
// Extended Property als SqlDbType
internal const string DataTypeProperty = "DataType";
private string _verzeichnis; // Verzeichnis mit den Textdateien
private string _connectionString; // Verbindung zur Datenbank
public MohrenkopfEVA(string verzeichnis, string connectionString)
{
this._verzeichnis = verzeichnis;
this._connectionString = connectionString;
}
/// <summary>
/// Steuerung der Verarbeitung.
/// </summary>
public void Ausführen()
{
// Einlesen aller Textdateien in getrennte Tabellen
var dataSet = new MohrenkopfEingabe(this._verzeichnis).Verarbeite();
// Verarbeitet das DataSet
// Hier nur: Überprüfen der Spalten bezüglich des Datentyps
new MohrenkopfVerarbeitung().Verarbeite(dataSet);
new MohrenkopfDatenbank(this._connectionString).Verarbeite(dataSet);
// Weiteres wie eine erneute Ausgabe...
}
}
#region Class MohrenkopfEingabe
/// <summary>
/// Liest alle Textdateien in ein DataSet.
/// </summary>
/// <remarks>
/// Mangels Informationen nur angedeutet.
/// </remarks>
internal class MohrenkopfEingabe
{
string _verzeichnis;
internal MohrenkopfEingabe(string verzeichnis)
{
if (!Directory.Exists(verzeichnis))
throw new ArgumentException("verzeichnis");
this._verzeichnis = verzeichnis;
}
#region Einlesen
internal DataSet Verarbeite()
{
DataSet dataSet = new DataSet("Textdaten");
foreach (var dateiname in Directory.GetFiles(this._verzeichnis, "*.txt"))
{
var table = EinlesenDatei(dateiname);
dataSet.Tables.Add(table);
}
return dataSet;
}
private DataTable EinlesenDatei(string dateiname)
{
DataTable table = null;
using (var reader = new StreamReader(dateiname))
{
var tabelleName = reader.ReadLine();
table = new DataTable(tabelleName);
// Hier kommen irgendwie die Spalten hin...
var zeile = reader.ReadLine();
{
// kann natürlich auch ganz anders aussehen, steht nirgendwo
string[] spalten = zeile.Split(';');
foreach (var spalte in spalten)
table.Columns.Add(spalte, typeof(string));
}
// die Daten...
while ((zeile = reader.ReadLine()) != null)
{
// extrahieren hier via Split
string[] daten = zeile.Split(';');
table.Rows.Add(daten);
}
}
return table;
}
#endregion Einlesen
}
#endregion Class MohrenkopfVerarbeitung
#region Class MohrenkopfVerarbeitung
/// <summary>
/// Verarbeitet die eingelesenen Dateien als DataSet
/// </summary>
/// <remarks>
/// Derzeit nur die Ermitteln des Datentyps, weiteres nach Bedarf
/// </remarks>
internal class MohrenkopfVerarbeitung
{
internal void Verarbeite(DataSet dataSet)
{
foreach (DataTable table in dataSet.Tables)
{
// Ermittelt den Datentyp
DatentypErmitteln(table);
}
}
/// <summary>
/// Legt über eine ExtendedProperty den Datentyp fest, hier: string oder decimal
/// </summary>
/// <remarks>
/// Weitere Analyse ist möglich wie
/// Ermitteln Anzahl Nachkommastellen bei Decimal
/// Ermitteln Maximale Länge der Spalte wenn String
/// Andere Datentypen
/// Die Informationen können über ExtendedProperties abgelegt werden.
/// </remarks>
private void DatentypErmitteln(DataTable table)
{
// Anfangs optimistisch: Alles ist Decimal
foreach (DataColumn column in table.Columns)
{
column.ExtendedProperties.Add(MohrenkopfEVA.DataTypeProperty, SqlDbType.Decimal);
}
foreach (DataRow row in table.Rows)
{
// Bricht Prüfung ab, wenn keine Decimal mehr zu finden sind
bool anyDecimalFound = false;
foreach (DataColumn column in table.Columns)
{
// Nur wenn bisher als Decimal zulässig
if (((SqlDbType)column.ExtendedProperties[MohrenkopfEVA.DataTypeProperty]) == SqlDbType.Decimal)
{
decimal value;
if (!decimal.TryParse((string)row[column], NumberStyles.Number, CultureInfo.CurrentCulture, out value))
{
// Einmal fehlgeschlagen, weiter als Zeichenkette
column.ExtendedProperties[MohrenkopfEVA.DataTypeProperty] = SqlDbType.NVarChar;
}
else
{
anyDecimalFound = true;
}
}
}
// Sind alles String Datenypen, keine weitere Analyse
if (!anyDecimalFound)
break;
}
}
}
#endregion Class MohrenkopfVerarbeitung
#region Class MohrenkopfDatenbank
/// <summary>
/// Übertragung des DataSets in die Datenbank.
/// </summary>
/// <remarks>
/// Legt eine Tabelle für das gesamte DataSet an (Alternativ: Je Tabelle)
/// Der Datentyp wird anhand einer ExtendedProperty ermittelt, siehe Verarbeitung
/// </remarks>
internal class MohrenkopfDatenbank
{
// Name der Tabelle
private const string TabellenName = "Mohrenkopf";
private string _connectionString;
internal MohrenkopfDatenbank(string connectionString)
{
this._connectionString = connectionString;
}
internal void Verarbeite(DataSet dataSet)
{
var columns = SpaltenErmitteln(dataSet);
// Erzeugen der Tabelle
TabelleErstellen(columns);
// Ausgabe in Tabelle
Ausgabe(dataSet, columns);
}
/// <summary>Ausgabe aller Tabellen im DataSet anhander Spaltendefinition.</summary>
private void Ausgabe(DataSet dataSet, List<ColumnDefinition> columns)
{
var insertCommand = BefehlErstellen(columns);
using (var connection = new SqlCeConnection(this._connectionString))
{
connection.Open();
insertCommand.Connection = connection;
foreach (DataTable table in dataSet.Tables)
{
// Nicht verwendete Spalten immer Null
LöscheParameter(insertCommand);
// Ausgabe einer Tabelle
AusgabeTabelle(table, insertCommand);
}
}
}
/// <summary>Überträgt eine Tabelle in die Datenbank.</summary>
private void AusgabeTabelle(DataTable table, SqlCeCommand insertCommand)
{
var parameters = ParameterListe(table, insertCommand);
foreach (DataRow row in table.Rows)
{
// Übertragen der gefunden DataColumns in die Tabelle
foreach (var pair in parameters)
{
SqlCeParameter parameter = pair.Value;
// Konvertieren wenn Decimal, sonst String
string parameterValue = (string)row[pair.Key];
if (pair.Value.SqlDbType == SqlDbType.Decimal)
parameter.Value = decimal.Parse(parameterValue, NumberStyles.Number, CultureInfo.CurrentCulture);
else
parameter.Value = parameterValue;
}
insertCommand.ExecuteNonQuery();
// Erfolgreich geschrieben
row.AcceptChanges();
}
}
/// <summary>Erstellt einen INSERT Befehl der alle Spalten umfasst.</summary>
private SqlCeCommand BefehlErstellen(List<ColumnDefinition> columns)
{
var builder = new StringBuilder(128);
builder.AppendFormat("INSERT INTO [{0}]", TabellenName);
builder.Append(" (");
// Spaltenliste
for (var columnIndex = 0; columnIndex < columns.Count; columnIndex++)
{
if (columnIndex > 0) builder.Append(',');
builder.AppendFormat("[{0}]", columns[columnIndex].ColumnName);
}
builder.Append(") VALUES (");
// Parameterliste
for (var columnIndex = 0; columnIndex < columns.Count; columnIndex++)
{
if (columnIndex > 0) builder.Append(',');
builder.AppendFormat("@p{0}", columnIndex);
}
builder.Append(");");
string commandText = builder.ToString();
System.Diagnostics.Debug.WriteLine(commandText, "INSERT TABLE");
var command = new SqlCeCommand();
command.CommandText = commandText;
// Parameter erstellen
for (var columnIndex = 0; columnIndex < columns.Count; columnIndex++)
{
var parameter = columns[columnIndex].GetParameter(columnIndex);
command.Parameters.Add(parameter);
}
return command;
}
/// <summary>Erstellt die Parameterliste für eine DataTable durch Zuordnung der SourceColumn</summary>
private IDictionary<DataColumn, SqlCeParameter> ParameterListe(DataTable table, SqlCeCommand insertCommand)
{
var parameters = new Dictionary<DataColumn, SqlCeParameter>();
foreach (DataColumn column in table.Columns)
{
foreach (SqlCeParameter parameter in insertCommand.Parameters)
{
if (column.ColumnName.Equals(parameter.SourceColumn, StringComparison.OrdinalIgnoreCase))
{
parameters.Add(column, parameter);
break;
}
}
}
return parameters;
}
/// <summary>Setzt alle Parameterwerte auf DBNull.</summary>
private void LöscheParameter(SqlCeCommand command)
{
foreach (SqlCeParameter parameter in command.Parameters)
parameter.Value = DBNull.Value;
}
#region Tabelle erstellen
/// <summary>Erstellt eine Tabelle anhand des ermittelten Schemas.</summary>
private void TabelleErstellen(List<ColumnDefinition> columns)
{
StringBuilder builder = new StringBuilder(128);
builder.AppendFormat("CREATE TABLE [{0}]", TabellenName);
builder.AppendLine(" (");
builder.AppendLine("\tid int IDENTITY(1, 1) NOT NULL PRIMARY KEY");
foreach (var definition in columns)
{
builder.Append("\t,");
builder.AppendLine(definition.GetDbColumn());
}
builder.AppendLine(");");
string commandText = builder.ToString();
System.Diagnostics.Debug.WriteLine(commandText, "CREATE TABLE");
using (var connection = new SqlCeConnection(this._connectionString))
{
connection.Open();
using (var command = new SqlCeCommand(commandText, connection))
{
// TODO: Alte Tabelle ggf. löschen.
command.ExecuteNonQuery();
}
}
}
#endregion Tabelle erstellen
/// <summary>Ermittelt die Spaltendefinition anhand des DataSets</summary>
private List<ColumnDefinition> SpaltenErmitteln(DataSet dataSet)
{
List<ColumnDefinition> columnList = new List<ColumnDefinition>();
foreach (DataTable table in dataSet.Tables)
{
foreach (DataColumn column in table.Columns)
{
var definition = new ColumnDefinition(
column.ColumnName,
(SqlDbType)column.ExtendedProperties[MohrenkopfEVA.DataTypeProperty]);
int index = columnList.IndexOf(definition);
if (index == -1)
{
columnList.Add(definition);
}
else
{
// Abweichender Typ => String
if (definition.DataType != columnList[index].DataType)
columnList[index].DataType = SqlDbType.NVarChar;
}
}
}
return columnList;
}
#endregion Ausgabe Datenbank
#region ColumnDefinition Class
/// <summary>Definiert das Schema der Tabelle für die weitere Verarbeitung</summary>
internal class ColumnDefinition : IEquatable<ColumnDefinition>
{
internal ColumnDefinition(string columnName, SqlDbType dataType)
{
this.ColumnName = columnName;
this.DataType = dataType;
}
internal string ColumnName;
internal SqlDbType DataType;
internal string GetDbColumn()
{
string dataTypeName = null;
switch (this.DataType)
{
case SqlDbType.Decimal:
dataTypeName = "decimal(18, 2)";
break;
default:
dataTypeName = "nvarchar(255)";
break;
}
// Spalte mit Datentyp und NULL erlaubt
return string.Format("[{0}] {1} NULL", this.ColumnName, dataTypeName);
}
/// <summary>Erstellt einen Parameter aus der Definition.</summary>
internal SqlCeParameter GetParameter(int columnIndex)
{
var parameter = new SqlCeParameter("@p" + columnIndex.ToString(), this.DataType);
switch (this.DataType)
{
case SqlDbType.Decimal:
parameter.Precision = 18;
parameter.Scale = 2;
break;
case SqlDbType.NVarChar:
parameter.Size = 255; // nvarchar(255)
break;
default:
throw new NotSupportedException("DataType");
}
// Wird zur Bestimmung der DataColumn verwendet
parameter.SourceColumn = this.ColumnName;
return parameter;
}
public override string ToString()
{
return this.GetDbColumn();
}
public bool Equals(ColumnDefinition other)
{
// Vergleichen nach Namen ohne Berücksichtigung von Groß/Kleinschreibung
return this.ColumnName.Equals(other.ColumnName, StringComparison.OrdinalIgnoreCase);
}
}
#endregion ColumnDefinition Class
}
}
Gruß Elmar
