Выгрузка в .txt путем sql запроса

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
 
using System.Data.OracleClient;
using System.IO;
 
using SpreadsheetGear;
using SpreadsheetGear.Advanced.Cells;
 
using System.Threading;
 
namespace QueryDataToExcel
{
    public partial class Form1 : Form
    {
        private string path;
        private string fileNameBase;
        private string fileNameExt;
        private string connectionString;
        private string sqlCommand;
        private Int32 maxRowsOnFile;
        private bool showHeader;
 
        private string message = "";
        private string errMessage = "";
        private string errMessageFull = "";
 
        private Thread thread = null;
        private System.Windows.Forms.Timer timer = null;
 
        private const Int32 MaxRowsOnXLSXFile = 1000000;
        private const Int32 MaxRowsOnXLSFile = 65000;
 
        public Form1()
        {
            InitializeComponent();
 
            ExportFileTypeDropDownList.Items.Add(".xlsx");
            ExportFileTypeDropDownList.Items.Add(".xls");
            ExportFileTypeDropDownList.Items.Add(".txt");
            ExportFileTypeDropDownList.SelectedIndex = 0;
 
            timer = new System.Windows.Forms.Timer();
            timer.Tick += new EventHandler(Checker);
            timer.Interval = 100;
            timer.Start();
        }
 
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            timer.Stop();
            timer.Dispose();
        }
 
        private void Checker(object sender, EventArgs e)
        {
            if (thread != null &&
                (thread.ThreadState == ThreadState.Running || thread.ThreadState == ThreadState.Background))
            {
                StartButton.Enabled = false;
                StatusLabel.Text = message;
            }
            else
            {
                StartButton.Enabled = true;
                StatusLabel.Text = "Завершено";
            }
        }
 
        private void StartButton_Click(object sender, EventArgs e)
        {
            StartButton.Enabled = false;
 
            try
            {
                #region "Инициализация параметров"
 
                if (String.IsNullOrEmpty(ExportPathTextBox.Text.Trim()))
                    path = AppDomain.CurrentDomain.BaseDirectory;
                else
                    path = ExportPathTextBox.Text.Trim();
 
                if (String.IsNullOrEmpty(ExportFileNameBaseTextBox.Text.Trim()))
                    fileNameBase = "file";
                else
                    fileNameBase = ExportFileNameBaseTextBox.Text.Trim();
 
                fileNameExt = ExportFileTypeDropDownList.Items[ExportFileTypeDropDownList.SelectedIndex].ToString();
 
                // example - "User Id=RSYST; Password=111; Data Source=REPTST"
                connectionString =
                    "User Id=" + ExportDBLoginTextBox.Text.Trim() + "; " +
                    "Password=" + ExportDBPasswordTextBox.Text.Trim() + "; " +
                    "Data Source=" + ExportDBDatabaseTextBox.Text.Trim();
 
                sqlCommand = ExportSQLCommandRichTextBox.Text.Trim().Trim(";".ToCharArray());
                maxRowsOnFile = Convert.ToInt32(ExportMaxRowsOnFileUpDown.Value);
                showHeader = ExportShowHeaderCheckBox.Checked;
 
                #endregion
 
                thread = new Thread(new ThreadStart(Export));
                thread.IsBackground = true;
                thread.Name = "Export thread";
                thread.Start();
            }
            catch (Exception ex)
            {
                StartButton.Enabled = true;
                MessageBox.Show(ex.ToString());
            }
        }
 
        private void Export()
        {
            using (OracleConnection conn = new OracleConnection(connectionString))
            {
                message = "Установка соединения";
                try
                {
                    conn.Open();
                    errMessage = "";
                    errMessageFull = "";
                }
                catch (Exception ex)
                {
                    errMessage = "Не удалось установить соединение с базой";
                    errMessageFull = errMessage + ":" + Environment.NewLine + ex.ToString();
 
                    MessageBox.Show(errMessageFull);
 
                    return;
                }
 
                try
                {
                    using (OracleCommand command = new OracleCommand(sqlCommand, conn))
                    {
                        message = "Выполнение запроса";
                        using (OracleDataReader reader = command.ExecuteReader())
                        {
                            for (int fileNum = 1; ; fileNum++)
                            {
                                message = "Создание файла №" + fileNum.ToString();
                                string fileNameOne = Path.Combine(Path.GetFullPath(path),
                                                                    Path.ChangeExtension(Path.GetFileName(fileNameBase), fileNameExt));
 
                                string fileNameMany = Path.Combine(Path.GetFullPath(path),
                                                                Path.ChangeExtension(Path.GetFileName(fileNameBase) + "_" + fileNum.ToString().PadLeft(5, '0'), fileNameExt));
 
                                if (!ExportOneFile(reader, maxRowsOnFile, fileNameMany, showHeader, fileNameExt))
                                {
                                    if (fileNum == 1 && File.Exists(fileNameMany))
                                    {
                                        if (File.Exists(fileNameOne))
                                            File.Delete(fileNameOne);
 
                                        File.Move(fileNameMany, fileNameOne);
                                    }
 
                                    break;
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
                finally
                {
                    try { conn.Close(); }
                    catch { }
                }
            }
        }
 
        private bool ExportOneFile(OracleDataReader reader, Int32 maxRowsOnFile, string fileName, bool showHeader, string fileNameExt)
        {
            if (fileNameExt == ".txt")
            {
             //ТУТ выгрузку в txt реализовать
            }
 
            IWorkbook workBook = Factory.GetWorkbook();
            IWorksheet workSheet = workBook.Worksheets[0];
 
            Int32 curRow = 0;
 
            Type[] columnType = new Type[reader.FieldCount];
 
 
            for (int i = 0; i < reader.FieldCount; i++)
            {
                columnType[i] = reader.GetFieldType(i);
            }
 
            if (showHeader)
            {
                for (int i = 0; i < reader.FieldCount; i++)
                {
                    workSheet.Cells[curRow, i].Value = reader.GetName(i);
                    workSheet.Cells[curRow, i].NumberFormat = "@";
                }
 
                curRow++;
            }
 
            bool hasData = true;
            int dataRow;
            string messageBase = message;
 
            IValues workSheetValues = workSheet as IValues;
            DateTime excelDateTimeMinValue = new DateTime(1900, 1, 1, 0, 0, 1);
            DateTime excelDateTimeMaxValue = DateTime.MaxValue.AddSeconds(-1);
 
            for (dataRow = 0; dataRow < maxRowsOnFile; dataRow++, curRow++)
            {
                message = messageBase + String.Format(" ({0})", dataRow);
                if (!reader.Read())
                {
                    hasData = false;
                    break;
                }
 
                for (int column = 0; column < reader.FieldCount; column++)
                {
                    try
                    {
 
                        object value = reader.GetValue(column);
 
                        //select * from ybessonov.cdbrep7365_part1
 
                        Type type = columnType[column];
                        if (type == typeof(decimal) ||
                            type == typeof(float) ||
                            type == typeof(double) ||
                            type == typeof(int))
                        {
                            decimal val = 0;
                            if (Decimal.TryParse(
                                value == DBNull.Value || value == null
                                    ? ""
                                    : value.ToString().
                                          Replace(".",
                                                  System.Globalization.NumberFormatInfo.CurrentInfo.
                                                      CurrencyDecimalSeparator).
                                          Replace(",",
                                                  System.Globalization.NumberFormatInfo.CurrentInfo.
                                                      CurrencyDecimalSeparator), out val))
                            {
                                //Пишем как число
                                workSheetValues.SetNumber(curRow, column, (double)val);
                            }
                            else
                            {
                                //Просто как строку пишем
                                workSheetValues.SetText(curRow, column,
                                                        value == DBNull.Value || value == null
                                                            ? ""
                                                            : value.ToString());
                            }
                        }
                        else if (type == typeof(DateTime))
                        {
                            if (value != DBNull.Value && value != null)
                            {
                                if (((DateTime)value) >= excelDateTimeMinValue &&
                                    ((DateTime)value) <= excelDateTimeMaxValue)
                                    workSheetValues.SetNumber(curRow, column,
                                                              workSheet.Workbook.DateTimeToNumber((DateTime)value));
                                else
                                    workSheetValues.SetText(curRow, column,
                                                            ((DateTime)value).ToString("dd.MM.yyyy HH:mm:ss"));
                            }
                        }
                        else
                        {
                            workSheetValues.SetText(curRow, column,
                                                    value == DBNull.Value || value == null
                                                        ? ""
                                                        : value.ToString());
                        }
                    }
                    catch (Exception ex)
                    {
                        string exc = string.Format("Ошибка произошла на строке-{0} в поле-{1}   ", dataRow + 1,
                                                   column + 1);
                        MessageBox.Show(exc + ex.ToString());
                    }
                }
            }
 
            if (dataRow > 0)
            {
                if (File.Exists(fileName))
                    File.Delete(fileName);
 
                workSheet.UsedRange.Columns.AutoFit();
 
                for (int i = 0; i < reader.FieldCount; i++)
                    workSheet.Cells[workSheet.UsedRange.RowCount - dataRow, i, workSheet.UsedRange.RowCount - 1, i].
                        NumberFormat = TypeToNumberFormat(columnType[i]);
 
                workBook.SaveAs(fileName,
                                fileNameExt.ToLower().Contains("xlsx")
                                    ? FileFormat.OpenXMLWorkbook
                                    : FileFormat.Excel8);
            }
 
            workBook.Close();
            return hasData;
        }
 
        private string TypeToNumberFormat(Type type)
        {
            if (type == typeof(int))
                return @"0";
            else if (type == typeof(DateTime))
                return "dd.mm.yyyy";
            else if (type == typeof(float) ||
                type == typeof(double) ||
                type == typeof(decimal))
                return @"0.00";
 
            return "@";
        }
 
        private void FolderBrowseButton_Click(object sender, EventArgs e)
        {
            if (!String.IsNullOrEmpty(ExportPathTextBox.Text))
                folderBrowserDialog.SelectedPath = ExportPathTextBox.Text;
 
            if (folderBrowserDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                ExportPathTextBox.Text = folderBrowserDialog.SelectedPath;
        }
 
        private void ExportFileTypeDropDownList_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (ExportFileTypeDropDownList.Items[ExportFileTypeDropDownList.SelectedIndex].ToString().ToLower().Contains("xlsx"))
                ExportMaxRowsOnFileUpDown.Maximum = MaxRowsOnXLSXFile;
            else
                ExportMaxRowsOnFileUpDown.Maximum = MaxRowsOnXLSFile;
        }
    }
}

if (showHeader)
            {
                string title = string.Empty;
                foreach (var column in columns)
                {
                    title += column + "\t";
                }
                file.WriteLine(title);
            }

while (reader.Read())
                    {
                        string row = string.Empty;
                        foreach (var column in columns)
                        {
                            if (reader[column] == DBNull.Value)
                            {
                                file.Write("\t");
                            }
                            else
                            {
                                file.Write(reader[column]);
                                file.Write("\t");
                            }
                        }
                        file.WriteLine(row);
                    }

row = Thread.CurrentThread.CurrentCulture.NumberFormat.PercentDecimalSeparator;
Thread.CurrentThread.CurrentCulture.NumberFormat.PercentDecimalSeparator = ",";
Thread.CurrentThread.CurrentCulture.NumberFormat.PercentDecimalSeparator = row;

string row = string.Empty;
...
file.WriteLine(row);

while (reader.Read())
                    {
                        foreach (var column in columns)
                        {
                            if (reader[column] == DBNull.Value)
                            {
                                file.Write("\t");
                            }
                            else
                            {
                                file.Write(reader[column]);
                                file.Write("\t");
                            }
                        }
                        file.WriteLine();
                    }

file.WriteLine();

foreach (var column in columns)
                        {
                            if (reader[column] == DBNull.Value)
                            {
                                file.Write("\t");
                            }
                            else
                            {
                                string result = reader[column].ToString();
            result = result.Replace("\r", " ").Replace("\n", " ").Replace("\t", " ");
            file.Write(result);
                                file.Write("\t");
                            }
                        }