Запрос ole db в excel

Microsoft SQL Server 2005 Standard Edition Microsoft SQL Server 2005 Enterprise Edition Microsoft SQL Server 2005 Developer Edition Microsoft SQL Server 2005 Workgroup Edition Еще…Меньше

DECLARE @RC int
DECLARE @server nvarchar(128)
DECLARE @srvproduct nvarchar(128)
DECLARE @provider nvarchar(128)
DECLARE @datasrc nvarchar(4000)
DECLARE @location nvarchar(4000)
DECLARE @provstr nvarchar(4000)
DECLARE @catalog nvarchar(128)
-- Set parameter values
SET @server = 'XLTEST_SP'
SET @srvproduct = 'Excel'
SET @provider = 'Microsoft.Jet.OLEDB.4.0'
SET @datasrc = 'c:book1.xls'
SET @provstr = 'Excel 8.0'
EXEC @RC = [master].[dbo].[sp_addlinkedserver] @server, @srvproduct, @provider, 
@datasrc, @location, @provstr, @catalog

Private Sub Command1_Click()
    Dim s As SQLDMO.SQLServer
    Dim ls As SQLDMO.LinkedServer
    Set s = New SQLDMO.SQLServer
    s.Connect "(local)", "sa", "password"
    Set ls = New SQLDMO.LinkedServer
    With ls
        .Name = "XLTEST_DMO"
        .ProviderName = "Microsoft.Jet.OLEDB.4.0"
        .DataSource = "c:book1.xls"
        .ProviderString = "Excel 8.0"
    End With
    s.LinkedServers.Add ls
    s.Close
End Sub

Imports Microsoft.SqlServer.Management.Smo
Imports Microsoft.SqlServer.Management.Common
Public Class Form1
    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        Dim s As Server
        Dim conn As ServerConnection
        Dim ls As LinkedServer
        conn = New ServerConnection("ServerNameInstanceName", "YourUesrName", "YourPassword")
        s = New Server(conn)
        Try
            ls = New LinkedServer(s, "XLTEST_DMO")
            With ls
                .ProviderName = "Microsoft.Jet.OLEDB.4.0"
                .ProductName = "Excel"
                .DataSource = "c:book1.xls"
                .ProviderString = "Excel 8.0"
            End With
            ls.Create()
            MessageBox.Show("New linked Server has been created.")
        Catch ex As SmoException
            MessageBox.Show(ex.Message)
        Finally
            ls = Nothing
            If s.ConnectionContext.IsOpen = True Then
                s.ConnectionContext.Disconnect()
            End If
        End Try
    End Sub
End Class

SELECT * FROM XLTEST_DMO...Sheet1$

SELECT * FROM OPENQUERY(XLTEST_DMO, 'SELECT * FROM [Sheet1$]')

EXECUTE SP_TABLES_EX 'XLTEST_DMO'

SELECT * FROM OPENDATASOURCE('Microsoft.Jet.OLEDB.4.0',
   'Data Source=c:book1.xls;Extended Properties=Excel 8.0')...Sheet1$

SELECT * FROM OPENROWSET('Microsoft.Jet.OLEDB.4.0', 
   'Excel 8.0;Database=c:book1.xls', Sheet1$)

SELECT * FROM OPENROWSET('Microsoft.Jet.OLEDB.4.0', 
   'Data Source=c:book1.xls;Extended Properties=Excel 8.0', Sheet1$)

SELECT * FROM OPENROWSET('Microsoft.Jet.OLEDB.4.0', 'DataSource=c:book1.xls;Extended Properties=Excel 8.0', Sheet1$) 

Нужна дополнительная помощь?

Table of Contents

• Introduction
• Building the Sample
• Source code
• Description
• Common operations:
  • Microsoft PIA
  • OleDb option for exporting
    • Extended properties
  • Using OpenXML
  • Exception Handling
  • Location of excel operations
• Conclusions
• Special Note
• See also

using
Excel = Microsoft.Office.Interop.Excel;

private
void
btnExportExcel_Click(object
sender, EventArgs e)

{


    try

    {


        Microsoft.Office.Interop.Excel.Application excel =
new
Microsoft.Office.Interop.Excel.Application();

        excel.Visible =
true;


        Microsoft.Office.Interop.Excel.Workbook workbook = excel.Workbooks.Add(System.Reflection.Missing.Value);


        Microsoft.Office.Interop.Excel.Worksheet sheet1 = (Microsoft.Office.Interop.Excel.Worksheet)workbook.Sheets[1];


        int
StartCol = 1;

        int
StartRow = 1;

        int
j = 0, i = 0;

        //Write Headers


        for
(j = 0; j < dgvSource.Columns.Count; j++)

        {


            Microsoft.Office.Interop.Excel.Range myRange = (Microsoft.Office.Interop.Excel.Range)sheet1.Cells[StartRow, StartCol +
j];

            myRange.Value2 = dgvSource.Columns[j].HeaderText;


        }


        StartRow++;


        //Write datagridview content


        for
(i = 0; i < dgvSource.Rows.Count; i++)

        {


            for
(j = 0; j < dgvSource.Columns.Count; j++)

            {


                try

                {


                    Microsoft.Office.Interop.Excel.Range myRange = (Microsoft.Office.Interop.Excel.Range)sheet1.Cells[StartRow + i,
StartCol + j];

                    myRange.Value2 = dgvSource[j, i].Value ==
null
? "" : dgvSource[j, i].Value;


                }


                catch

                {


                    ;


                }


            }


        }


    }


    catch
(Exception ex)

    {


        MessageBox.Show(ex.ToString());


    }


}

using
System; 

using
System.Data; 

using
System.IO; 

using
System.Linq; 

using
System.Windows.Forms; 

namespace
UtilityLibrary 

{ 


    public
static
class DataGridViewExtensionMethods 

    { 


        /// <summary> 


        /// Given a DataGridView populates without a data source, 


        /// create a DataTable, populate from rows/cells from the 


        /// DataGridView with an option to include/exclude column names. 


        /// </summary> 


        /// <param name="pDataGridView"></param> 


        /// <param name="pColumnNames"></param> 


        /// <returns></returns> 


        /// <remarks> 


        /// There is no attempt made to figure out data types coming 


        /// from data in the DataGridView 


        /// </remarks> 


        public
static
DataTable GetDataTable(this
DataGridView pDataGridView, bool
pColumnNames = true) 


        { 


            DataTable dt =
new
DataTable(); 

            foreach
(DataGridViewColumn column in
pDataGridView.Columns) 

            { 


                if
(column.Visible) 

                { 


                    if
(pColumnNames) 

                    { 


                        dt.Columns.Add(new
DataColumn() { ColumnName = column.Name }); 

                    } 


                    else 

                    { 


                        dt.Columns.Add(); 


                    } 


                } 


            } 


            object[] cellValues =
new
object[pDataGridView.Columns.Count]; 

            foreach
(DataGridViewRow row in
pDataGridView.Rows) 

            { 


                if
(!row.IsNewRow) 

                { 


                    for
(int
i = 0; i < row.Cells.Count; i++) 

                    { 


                        cellValues[i] = row.Cells[i].Value; 


                    } 


                    dt.Rows.Add(cellValues); 


                } 


            } 


            return
dt; 

        } 


        /// <summary> 


        /// Generates comma delimited rows into a string array. 


        /// </summary> 


        /// <param name="sender"></param> 


        /// <returns></returns> 


        /// <remarks></remarks> 


        public
static
string[] CommaDelimitedRows(this
DataGridView sender) 

        { 


            return
( 

                from row
in
sender.Rows.Cast<DataGridViewRow>() 

                where !((DataGridViewRow)row).IsNewRow 


                let RowItem =
string.Join(",", Array.ConvertAll(((DataGridViewRow)row).Cells.Cast<DataGridViewCell>().ToArray(), (DataGridViewCell
c) => ((c.Value == null) ?
"" : c.Value.ToString()))) 


                select RowItem).ToArray(); 


        } 


        public
static
void ExportToCommandDelimitedFile(this
DataGridView pSender, string
pFileName) 

        { 


            File.WriteAllLines(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, pFileName), pSender.CommaDelimitedRows()); 


        } 


        public
static
void ExpandColumns(this
DataGridView sender) 

        { 


            foreach
(DataGridViewColumn col in
sender.Columns) 

            { 


                col.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells; 


            } 


        } 


    } 


}

using
System; 

using
System.Data; 

using
SpreadsheetLight; 

using
DocumentFormat.OpenXml.Spreadsheet; 

using
SysDraw = System.Drawing; 

using
System.IO; 

namespace
SpreadSheetLightLibrary 

{ 


    public
class
ExcelOperations 

    { 


        /// <summary> 


        /// True if last operation had a runtime exception 


        /// </summary> 


        /// <returns></returns> 


        public
bool
HasException { get;
set; } 


        /// <summary> 


        /// Exception of last operation ran that throw an exception 


        /// </summary> 


        /// <returns></returns> 


        public
Exception Exception { get;
set; } 


        /// <summary> 


        /// Wraps Exception message 


        /// </summary> 


        /// <returns></returns> 


        public
string
ExceptionMessage 

        { 


            get 

            { 


                if
(HasException) 

                { 


                    return
Exception.Message; 

                } 


                else 

                { 


                    return
"None"; 

                } 


            } 


        } 


        /// <summary> 


        /// Export DataTable to a new Excel file 


        /// </summary> 


        /// <param name="pFileName">Path and Excel file name</param> 


        /// <param name="pSheetName">Sheet name to place data</param> 


        /// <param name="pDataTable">DataTable to import into pSheetName</param> 


        /// <param name="pColumnHeaders">Include or exclude columns</param> 


        /// <returns></returns> 


        public
bool
SimpleExport(string
pFileName, string
pSheetName, DataTable pDataTable, bool
pColumnHeaders) 

        { 


            try 

            { 


                if
(File.Exists(pFileName)) 

                { 


                    File.Delete(pFileName); 


                } 


                using
(SLDocument doc = new
SLDocument()) 

                { 


                    doc.SelectWorksheet(pSheetName); 


                    if
(pSheetName != "Sheet1") 


                    { 


                        doc.AddWorksheet(pSheetName); 


                        doc.DeleteWorksheet("Sheet1"); 


                    } 


                    // start at row 1, column A 


                    // SLConvert.ToColumnIndex("A") is kind of overkill but it exposes you to the convert class 


                    doc.ImportDataTable(1, SLConvert.ToColumnIndex("A"),
pDataTable, pColumnHeaders); 

                    if
(pColumnHeaders) 

                    { 


                        var headerSyle = doc.CreateStyle(); 


                        headerSyle.Font.FontColor = SysDraw.Color.White; 


                        headerSyle.Font.Strike =
false; 


                        headerSyle.Fill.SetPattern(PatternValues.Solid, SysDraw.Color.Green, SysDraw.Color.White); 


                        headerSyle.Font.Underline = UnderlineValues.None; 


                        headerSyle.Font.Bold =
true; 


                        headerSyle.Font.Italic =
false; 


                        doc.SetCellStyle(1, 1, 1, pDataTable.Columns.Count, headerSyle); 


                    } 


                    doc.AutoFitColumn(1, pDataTable.Columns.Count); 


                    doc.SaveAs(pFileName); 


                } 


                return
true; 


            } 


            catch
(Exception ex) 

            { 


                HasException =
true; 


                Exception = ex; 


                return
false; 


            } 


        } 


        /// <summary> 


        /// This represents the bare amount of code to import 


        /// a DataTable into a new Excel file. Please note if 


        /// there are dates they need to be format using a style. 


        ///  


        /// For an example of date styling/formatting 


        /// Class project ExcelBackend, Operations class method ImportDataTable2  


        /// where I setup a style for a date as mm-dd-yyyy 


        ///  


        /// Formatting is beyond this code sample as this code sample is meant 


        /// to be a generic method to take a DataGridView into a DataTable then 


        /// use the DataTable to import into a WorkSheet. I could had done dates 


        /// and other types but that is more specific to your data and as mentioned 


        /// the link above is my code sample that shows formatting/styling. 


        ///  


        /// </summary> 


        /// <param name="pFileName"></param> 


        /// <param name="pSheetName"></param> 


        /// <param name="pDataTable"></param> 


        /// <param name="pColumnHeaders"></param> 


        public
void
SimpleExportRaw(string
pFileName, string
pSheetName, DataTable pDataTable, bool
pColumnHeaders) 

        { 


            using
(SLDocument doc = new
SLDocument()) 

            { 


                doc.SelectWorksheet(pSheetName); 


                if
(pSheetName != "Sheet1") 


                { 


                    doc.AddWorksheet(pSheetName); 


                    doc.DeleteWorksheet("Sheet1"); 


                } 


                doc.ImportDataTable(1, SLConvert.ToColumnIndex("A"),
pDataTable, pColumnHeaders); 

                doc.SaveAs(pFileName); 


            } 


        } 


    } 


}

public
class
ExaminerEventArgs : EventArgs

{


    public
ExaminerEventArgs(string
message)

    {


        StatusMessage = message;


    }


    public
string
StatusMessage { get;
set; }


}


public
EventHandler<ExaminerEventArgs> ProgressUpdated;

private
void
OnProgressUpdated(string
message)

{


    ProgressUpdated?.Invoke(this,
new
ExaminerEventArgs(message));

}

xlWorkBooks = xlApp.Workbooks;


xlWorkBook = xlWorkBooks.Open(fileName);


OnProgressUpdated("Opened");


#region Timer logic


private
bool
IsExcelInMemory()

{


    return
Process.GetProcesses().Any(p => p.ProcessName.Contains("EXCEL"));


}


private
void
timer1_Tick(object
sender, EventArgs e)

{


    if
(IsExcelInMemory())

    {


        toolStripStatusLabel1.Image = Properties.Resources.ExcelInMemory;


    }


    else

    {


        toolStripStatusLabel1.Image = Properties.Resources.ExcelNotInMemory;


    }


    toolStripStatusLabel1.Invalidate();


}


#endregion

public
void
ReadCells(string
pFileName, string
pSheetName)

{


    void
ReleaseComObject(object
pComObject)

    {


        try

        {


            Marshal.ReleaseComObject(pComObject);


            pComObject =
null;


        }


        catch
(Exception)

        {


            pComObject =
null;


        }


    }


    var annihilationList =
new
List<object>();


    var proceed =
false;


    Excel.Application xlApp =
null;


    Excel.Workbooks xlWorkBooks =
null;


    Excel.Workbook xlWorkBook =
null;


    Excel.Worksheet xlWorkSheet =
null;


    Excel.Sheets xlWorkSheets =
null;


    Excel.Range xlCells =
null;


    xlApp =
new
Excel.Application();

    annihilationList.Add(xlApp);


    xlApp.DisplayAlerts =
false;


    xlWorkBooks = xlApp.Workbooks;


    annihilationList.Add(xlWorkBooks);


    xlWorkBook = xlWorkBooks.Open(pFileName);


    annihilationList.Add(xlWorkBook);


    xlApp.Visible =
false;


    xlWorkSheets = xlWorkBook.Sheets;


    annihilationList.Add(xlWorkSheets);


    for
(var intSheet = 1; intSheet <= xlWorkSheets.Count; intSheet++)


    {


        try

        {


            xlWorkSheet = (Excel.Worksheet)xlWorkSheets[intSheet];


            if
(xlWorkSheet.Name == pSheetName)

            {


                proceed =
true;


                break;


            }


            else

            {


                ReleaseComObject(xlWorkSheet);


            }


        }


        catch
(Exception ex)

        {


            HasErrors =
true;


            ExceptionInfo.UnKnownException =
true;


            ExceptionInfo.Message = $"Error finding sheet: '{ex.Message}'";


            ExceptionInfo.FileNotFound =
false;


            ExceptionInfo.SheetNotFound =
false;


            proceed =
false;


            annihilationList.Add(xlWorkSheet);


        }


    }


    if
(!proceed)

    {


        var firstSheet = (Excel.Worksheet)xlWorkSheets[1];


        xlWorkSheet = xlWorkSheets.Add(firstSheet);


        xlWorkSheet.Name = pSheetName;


        annihilationList.Add(firstSheet);


        annihilationList.Add(xlWorkSheet);


        xlWorkSheet.Name = pSheetName;


        proceed =
true;


        ExceptionInfo.CreatedSheet =
true;


    }


    else

    {


        if
(!annihilationList.Contains(xlWorkSheet))

        {


            annihilationList.Add(xlWorkSheet);


        }


    }


    if
(proceed)

    {


        if
(!annihilationList.Contains(xlWorkSheet))

        {


            annihilationList.Add(xlWorkSheet);


        }


        foreach
(var key in
ReturnDictionary.Keys.ToArray())

        {


            try

            {


                xlCells = xlWorkSheet.Range[key];


                ReturnDictionary[key] = xlCells.Value;


                annihilationList.Add(xlCells);


            }


            catch
(Exception e)

            {


                HasErrors =
true;


                ExceptionInfo.Message = $"Error reading cell [{key}]: '{e.Message}'";


                ExceptionInfo.FileNotFound =
false;


                ExceptionInfo.SheetNotFound =
false;


                annihilationList.Add(xlCells);


                xlWorkBook.Close();


                xlApp.UserControl =
true;


                xlApp.Quit();


                annihilationList.Add(xlCells);


                return;


            }


        }


    }


    else

    {


        /*


            * Send information back to caller why we failed


            */

        HasErrors =
true;


        ExceptionInfo.SheetNotFound =
true;


        ExceptionInfo.FileNotFound =
false;


    }


    // this is debatable, should we save the file after adding a non-existing sheet?


    if
(ExceptionInfo.CreatedSheet)

    {


        xlWorkSheet?.SaveAs(pFileName);


    }


    xlWorkBook.Close();


    xlApp.UserControl =
true;


    xlApp.Quit();


    ReleaseObjects(annihilationList);


}
public
void ReadCells(string
pFileName, string
pSheetName)

{


    void
ReleaseComObject(object
pComObject)

    {


        try

        {


            Marshal.ReleaseComObject(pComObject);


            pComObject =
null;


        }


        catch
(Exception)

        {


            pComObject =
null;


        }


    }


    var annihilationList =
new
List<object>();


    var proceed =
false;


    Excel.Application xlApp =
null;


    Excel.Workbooks xlWorkBooks =
null;


    Excel.Workbook xlWorkBook =
null;


    Excel.Worksheet xlWorkSheet =
null;


    Excel.Sheets xlWorkSheets =
null;


    Excel.Range xlCells =
null;


    xlApp =
new
Excel.Application();

    annihilationList.Add(xlApp);


    xlApp.DisplayAlerts =
false;


    xlWorkBooks = xlApp.Workbooks;


    annihilationList.Add(xlWorkBooks);


    xlWorkBook = xlWorkBooks.Open(pFileName);


    annihilationList.Add(xlWorkBook);


    xlApp.Visible =
false;


    xlWorkSheets = xlWorkBook.Sheets;


    annihilationList.Add(xlWorkSheets);


    for
(var intSheet = 1; intSheet <= xlWorkSheets.Count; intSheet++)


    {


        try

        {


            xlWorkSheet = (Excel.Worksheet)xlWorkSheets[intSheet];


            if
(xlWorkSheet.Name == pSheetName)

            {


                proceed =
true;


                break;


            }


            else

            {


                ReleaseComObject(xlWorkSheet);


            }


        }


        catch
(Exception ex)

        {


            HasErrors =
true;


            ExceptionInfo.UnKnownException =
true;


            ExceptionInfo.Message = $"Error finding sheet: '{ex.Message}'";


            ExceptionInfo.FileNotFound =
false;


            ExceptionInfo.SheetNotFound =
false;


            proceed =
false;


            annihilationList.Add(xlWorkSheet);


        }


    }


    if
(!proceed)

    {


        var firstSheet = (Excel.Worksheet)xlWorkSheets[1];


        xlWorkSheet = xlWorkSheets.Add(firstSheet);


        xlWorkSheet.Name = pSheetName;


        annihilationList.Add(firstSheet);


        annihilationList.Add(xlWorkSheet);


        xlWorkSheet.Name = pSheetName;


        proceed =
true;


        ExceptionInfo.CreatedSheet =
true;


    }


    else

    {


        if
(!annihilationList.Contains(xlWorkSheet))

        {


            annihilationList.Add(xlWorkSheet);


        }


    }


    if
(proceed)

    {


        if
(!annihilationList.Contains(xlWorkSheet))

        {


            annihilationList.Add(xlWorkSheet);


        }


        foreach
(var key in
ReturnDictionary.Keys.ToArray())

        {


            try

            {


                xlCells = xlWorkSheet.Range[key];


                ReturnDictionary[key] = xlCells.Value;


                annihilationList.Add(xlCells);


            }


            catch
(Exception e)

            {


                HasErrors =
true;


                ExceptionInfo.Message = $"Error reading cell [{key}]: '{e.Message}'";


                ExceptionInfo.FileNotFound =
false;


                ExceptionInfo.SheetNotFound =
false;


                annihilationList.Add(xlCells);


                xlWorkBook.Close();


                xlApp.UserControl =
true;


                xlApp.Quit();


                annihilationList.Add(xlCells);


                return;


            }


        }


    }


    else

    {


        /*


            * Send information back to caller why we failed


            */

        HasErrors =
true;


        ExceptionInfo.SheetNotFound =
true;


        ExceptionInfo.FileNotFound =
false;


    }


    // this is debatable, should we save the file after adding a non-existing sheet?


    if
(ExceptionInfo.CreatedSheet)

    {


        xlWorkSheet?.SaveAs(pFileName);


    }


    xlWorkBook.Close();


    xlApp.UserControl =
true;


    xlApp.Quit();


    ReleaseObjects(annihilationList);


}

public
void
ReleaseObjects(List<object> pAnnihilationList)


{


    for
(var indexer = 0; indexer < pAnnihilationList.Count; indexer++)


    {


        try

        {


            if
(pAnnihilationList[indexer] != null)


            {


                Marshal.ReleaseComObject(pAnnihilationList[indexer]);


                pAnnihilationList[indexer] =
null;


            }


        }


        catch
(Exception)

        {


            pAnnihilationList[indexer] =
null;


        }


    }


}

private
void
KillSpecificExcelFileProcess(string
excelFileName)

{


        var processes = from p
in
Process.GetProcessesByName("EXCEL")


                        select p;


        foreach
(var process in
processes)

        {


            if
(process.MainWindowTitle == "Microsoft Excel - "
+ excelFileName)

                process.Kill();


        }


}

GC.Collect();


GC.WaitForPendingFinalizers();


GC.Collect();


GC.WaitForPendingFinalizers();

public
void
ExportToDelimited_1()

{


    Excel.Application xlApp =
new
Excel.Application();

    Excel.Workbook xlWorkBook =
null;


    string
exportFileName = null;


    xlApp.Visible =
false;


    xlWorkBook = xlApp.Workbooks.Open(Path.Combine(


        AppDomain.CurrentDomain.BaseDirectory,
"People.xlsx"));


    exportFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
"People.csv");


    xlWorkBook.SaveAs(exportFileName, Excel.XlFileFormat.xlCSV);


    xlWorkBook =
null;


    xlApp.Quit();


}

public
void
ExportToDelimited_2()

{


    void
ReleaseComObject(object
pComObject)

    {


        try

        {


            Marshal.ReleaseComObject(pComObject);


            pComObject =
null;


        }


        catch
(Exception)

        {


            pComObject =
null;


        }


    }


    Excel.Application xlApp =
null;


    Excel.Workbooks xlWorkBooks =
null;


    Excel.Workbook xlWorkBook =
null;


    Excel.Worksheet xlWorkSheet =
null;


    xlApp =
new
Excel.Application();

    xlApp.DisplayAlerts =
false;


    xlWorkBooks = xlApp.Workbooks;


    xlWorkBook = xlWorkBooks.Open(Path.Combine(


        AppDomain.CurrentDomain.BaseDirectory,
"People.xlsx"));


    xlWorkSheet = (Excel.Worksheet)xlWorkBook.ActiveSheet;


    xlWorkBook.SaveAs(Path.Combine(AppDomain.CurrentDomain.BaseDirectory,


            "People.csv"),


        FileFormat: Excel.XlFileFormat.xlCSVWindows);


    xlWorkBook.Close();


    xlApp.UserControl =
true;


    xlApp.Quit();


    ReleaseComObject(xlWorkSheet);


    ReleaseComObject(xlWorkBook);


    ReleaseComObject(xlWorkBooks);


    ReleaseComObject(xlApp);


}

string
connectionstring = "Provider=Microsoft.Jet.OLEDB.4.0;   Data Source=c:\testexcel.xls; Extended Properties"Excel 8.0;HDR=YES"";

namespace
ExcelOperations.OleDbWork

{


    public
enum
ExcelHeader

    {


        Yes,


        No


    }


    public
class
SmartConnection

    {


        public
string
ConnectionString(string
pFileName, int
pImex = 1, ExcelHeader pHeader = ExcelHeader.No)

        {


            OleDbConnectionStringBuilder builder =
new
OleDbConnectionStringBuilder();

            if
(System.IO.Path.GetExtension(pFileName)?.ToUpper() ==
".XLS")

            {


                builder.Provider =
"Microsoft.Jet.OLEDB.4.0";


                builder.Add("Extended Properties", $"Excel
8.0;IMEX={pImex};HDR={pHeader.ToString()};");


            }


            else

            {


                builder.Provider =
"Microsoft.ACE.OLEDB.12.0";


                builder.Add("Extended Properties", $"Excel
12.0;IMEX={pImex};HDR={pHeader.ToString()};");


            }


            builder.DataSource = pFileName;


            return
builder.ConnectionString;

        }


    }


}

public
void
ExportDataTableToExcel(string
pFileName, DataTable pDataTable)

{


    mHasException =
false;


       /*


        * Create field names for the create table (worksheet)


        */

    var columnsPartsForCreateSheet = pDataTable.Columns.OfType<DataColumn>()


        .Select(col => $"{col.ColumnName.Replace("Column",
"")} CHAR(255)")


        .ToArray();


       /*


        * Turn column name and type into a delimited string for the actual create statement


        * below.


        */

    var columnsForCreateSheet =
string.Join(",", columnsPartsForCreateSheet);


    /*


        * Full SQL INSERT statement


        */

    var createStatement = $"CREATE TABLE {pDataTable.TableName} ({columnsForCreateSheet})";


       /*


        * Column names for the INSERT SQL staetment.


        */

    var columnsPartsForInsert = pDataTable.Columns.OfType<DataColumn>()


        .Select(col => col.ColumnName.Replace("Column",""))


        .ToArray();


       /*


        * Create named parameters for the insert statement. Note that OleDb


        * does not 'use' named parameters so we could had used a question mark


        * for each parameter name as OleDb parameters are done in ordinal position


        * which the parameters are anyways. The idea is for developers to get


        * use to named parameters as when moving to SQL-Server named parameters


        * allow parameters to be set out of order


        */

    var paramsForInsert = pDataTable.Columns.OfType<DataColumn>()


        .Select(col =>
"@" + col.ColumnName.Replace("Column",""))


        .ToArray();


       /*


        * Insert statement for populating rows in the WorkSheet.


        */

    var insertStatement =


        $"INSERT INTO {pDataTable.TableName} ({string.Join(",",
columnsPartsForInsert)}) + " +

        $"VALUES ({string.Join(",",
paramsForInsert)})";

    try

    {


        var con =
new
SmartConnection();

           /*


            * IMPORTANT: In the connection string, second parameter must be IMEX = 0 for this to work.


            */

        using
(var cn = new
OleDbConnection(con.ConnectionString(pFileName,0, ExcelHeader.Yes)))


        {


            using
(var cmd = new
OleDbCommand { Connection = cn })

            {


                cmd.CommandText = createStatement;


                cn.Open();


                   /*


                    * Create the WorkSheet


                    */

                cmd.ExecuteNonQuery();


                   /*


                    * Change our commandText for the INSERT


                    */

                cmd.CommandText = insertStatement;


                   /*


                    * Create parameters once rather than creating them for each


                    * iteration of an insert, clearing or re-creating the parameters.


                    */

                foreach
(var pName in
paramsForInsert)

                {


                    cmd.Parameters.Add(pName, OleDbType.VarWChar);


                }


                   /*


                    * Insert row into the WorkSheet.


                    */

                for
(int
rowIndex = 0; rowIndex < pDataTable.Rows.Count ; rowIndex++)


                {


                    for
(int
colIndex = 0; colIndex < pDataTable.Columns.Count ; colIndex++)


                    {


                           /*


                            * Set each parameter's value


                            */

                        cmd.Parameters[colIndex]


                            .Value = pDataTable.Rows[rowIndex]


                            .Field<string>(pDataTable.Columns.IndexOf(pDataTable.Columns[colIndex]));


                    }


                    cmd.ExecuteNonQuery();


                }


            }


        }


    }


    catch
(Exception e)

    {


        mHasException =
true;


        mLastException = e;


    }


}


/// <summary>


/// Get WorkSheet names for a specific Excel file


/// </summary>


/// <param name="pFileName"></param>


/// <returns></returns>


public
List<string> SheetNames(string
pFileName)

{


    mHasException =
false;


    var names =
new
List<string>();


    var con =
new
SmartConnection();

    try

    {


        using
(var cn = new
OleDbConnection(con.ConnectionString(pFileName)))

        {


            cn.Open();


            var dt = cn.GetSchema("Tables",
new
string[] { null,
null,
null,
"Table" });

            foreach
(DataRow row in
dt.Rows)

            {


                names.Add(row.Field<string>("Table_Name").Replace("$",
""));

            }


        }


    }


    catch
(Exception ex)

    {


        mHasException =
true;


        mLastException = ex;


    }


    return
names.Distinct().ToList(); 

}

public
void
ReadPeopleNoHeaderRow(string
pFileName, string
pSheetName) 

{


    mHasException =
false;


    List<Person> peopleList =
new
List<Person>();

    var con =
new
SmartConnection();

    var dt =
new
DataTable();

    try

    {


        using
(var cn = new
OleDbConnection { ConnectionString = con.ConnectionString(pFileName, 1, ExcelHeader.No) })


        {


            var selectStatement =
"SELECT F1 AS Identifer, F2 AS FirstName, F3 As LastName, "
+ 

                                            "F4 AS Gender, F5 As BirthDate "
+

                                    $"FROM [{pSheetName}$]";


            using
(var cmd = new
OleDbCommand { Connection = cn, CommandText = selectStatement })


            {


                cn.Open();


                var reader = cmd.ExecuteReader();


                dt.Load(reader);


                reader.Close();


                reader = cmd.ExecuteReader();


                while
(reader != null
&& reader.Read())

                {


                    peopleList.Add(new
Person()

                    {


                        Id = Convert.ToInt32(reader.GetDouble(0)),


                        FirstName = reader.GetString(1),


                        LastName = reader.GetString(2),


                        Gender = Convert.ToInt32(reader.GetDouble(3)),


                        BirthDay = Convert.ToDateTime(reader.GetString(4))


                    });


                }


                reader.Close();


            }


        }


    }


    catch
(Exception ex)

    {


        mHasException =
true;


        mLastException = ex;


    }


    foreach
(DataColumn col in
dt.Columns)

    {


        Console.WriteLine(col.DataType.ToString());


    }


}

public
List<Customer> ReadCustomers(string
pFileName)

{


    mHasException =
false;


    var selectStatement =
"SELECT CompanyName, ContactName,ContactTitle FROM [Customers$]";


    List<Customer> customers =
new
List<Customer>();

    var con =
new
SmartConnection();

    try

    {


        using
(var cn = new
OleDbConnection { ConnectionString = con.ConnectionString(pFileName,1, ExcelHeader.Yes) })


        {


            using
(var cmd = new
OleDbCommand { Connection = cn, CommandText = selectStatement })


            {


                cn.Open();


                var reader = cmd.ExecuteReader();


                while
(reader != null
&& reader.Read())

                {


                    customers.Add(new
Customer()

                    {


                        CompanyName = reader.GetString(0),


                        ContactName = reader.GetString(1),


                        ContactTitle = reader.GetString(2)


                    });


                }


            }


        }


    }


    catch
(Exception ex)

    {


        mHasException =
true;


        mLastException = ex;


    }


    return
customers;

}

public
void
CreateExcelDocPopulateWithPeople(string
pFileName, string
pSheetName, List<Person> pList)

{


    mHasException =
false;


    try

    {


        using
(var document = SpreadsheetDocument.Create(pFileName, SpreadsheetDocumentType.Workbook))


        {


            WorkbookPart wbp = document.AddWorkbookPart();


            wbp.Workbook =
new
Workbook();

            var wsp = wbp.AddNewPart<WorksheetPart>();


            wsp.Worksheet =
new
Worksheet();

            var sheets = wbp.Workbook.AppendChild(new
Sheets());

            var sheet =
new
Sheet()

            {


                Id = wbp.GetIdOfPart(wsp),


                SheetId = 1,


                Name =
"People"

            };


            // ReSharper disable once PossiblyMistakenUseOfParamsMethod


            sheets?.Append(sheet);


            wbp.Workbook.Save();


            WorkbookStylesPart stylePart = wbp.AddNewPart<WorkbookStylesPart>();


            stylePart.Stylesheet = CreateStylesheet();


            stylePart.Stylesheet.Save();


            var sheetData = wsp.Worksheet.AppendChild(new
SheetData());

            var headerRow = sheetData.AppendChild(new
Row());

            headerRow.AppendChild(new
Cell()

            {


                CellValue =
new
CellValue("Id"),


                DataType = CellValues.String,


                StyleIndex = 2


            });


            headerRow.AppendChild(new
Cell()

            {


                CellValue =
new
CellValue("First Name"),


                DataType = CellValues.String,


                StyleIndex = 2


            });


            headerRow.AppendChild(new
Cell()

            {


                CellValue =
new
CellValue("Last Name"),


                DataType = CellValues.String,


                StyleIndex = 2


            });


            headerRow.AppendChild(new
Cell()

            {


                CellValue =
new
CellValue("Gender"),


                DataType = CellValues.String,


                StyleIndex = 2


            });


            headerRow.AppendChild(new
Cell()

            {


                CellValue =
new
CellValue("Birthday"),


                DataType = CellValues.String,


                StyleIndex = 2


            });    


            // insert people data


            foreach
(var person in
pList)

            {


                var row =
new
Row();

                row.Append(


                    ConstructCell(person.Id.ToString(), CellValues.Number),


                    ConstructCell(person.FirstName, CellValues.String),


                    ConstructCell(person.LastName, CellValues.String),


                    ConstructCell(person.Role, CellValues.String),


                    ConstructCell(person.BirthDay.ToString("MM/dd/yyyy"),
CellValues.String));

                sheetData.AppendChild(row);


            }


            wsp.Worksheet.Save();


        }


    }


    catch
(Exception ex)

    {


        mHasException =
true;


        mLastException = ex;


    }


}


private
Stylesheet CreateStylesheet()

{


    Stylesheet styleSheet =
null;


    // 0 is default


    // 1 is header


    var fonts =
new
Fonts(

        new
Font(new
FontSize() { Val = 10 }),

        new
Font(new
FontSize() { Val = 12 },new
Bold(),new
Color() { Rgb = "FFFFFF"
}));

    var fills =
new
Fills(

        new
Fill(new
PatternFill() { PatternType = PatternValues.None }),
// Index 0 - default

        new
Fill(new
PatternFill() { PatternType = PatternValues.Gray125 }),
// Index 1 - default

        new
Fill(new
PatternFill(new
ForegroundColor { Rgb = new
HexBinaryValue() { Value = "000000"
} })

            { PatternType = PatternValues.Solid })
// Index 2 - header

    );


    var borders =
new
Borders(

        new
Border(),

        new
Border(

            new
LeftBorder(new
Color()   { Auto = true
}) { Style = BorderStyleValues.None },

            new
RightBorder(new
Color()  { Auto = true
}) { Style = BorderStyleValues.None },

            new
TopBorder(new
Color()    { Auto = true
}) { Style = BorderStyleValues.Thin },

            new
BottomBorder(new
Color() { Auto = true
}) { Style = BorderStyleValues.Thin },

            new
DiagonalBorder())

    );


    var cellFormats =
new
CellFormats(

        new
CellFormat(), // default


        new
CellFormat { FontId = 0, FillId = 0, BorderId = 1, ApplyBorder =
true
}, // body

        new
CellFormat { FontId = 1, FillId = 2, BorderId = 1, ApplyFill =
true
}    // header

    );


    styleSheet =
new
Stylesheet(fonts, fills, borders, cellFormats);

    return
styleSheet;

}


/// <summary>


/// Construct cell of specific type


/// </summary>


/// <param name="value"></param>


/// <param name="dataType"></param>


/// <returns></returns>


private
Cell ConstructCell(string
value, CellValues dataType)

{


    return
new
Cell()

    {


        CellValue =
new
CellValue(value),

        DataType =
new
EnumValue<CellValues>(dataType)

    };


}

<Worksheet
ss:Name="People">

<Table
ss:ExpandedColumnCount=<%= columnCount %> ss:ExpandedRowCount=<%= customers.Count + 1 %> x:FullColumns="1"

using System;


using System.Data.SqlClient;


namespace ExceptionsLibrary


{


    public class BaseExceptionsHandler


    {


        protected bool mHasException;


        /// <summary>


        /// Indicate the last operation thrown an 


        /// exception or not


        /// </summary>


        /// <returns></returns>


        public bool HasException => mHasException;


        protected Exception mLastException;


        /// <summary>


        /// Provides access to the last exception thrown


        /// </summary>


        /// <returns></returns>


        public Exception LastException => mLastException;


        /// <summary>


        /// Indicates if there was a sql related exception


        /// </summary>


        public bool HasSqlException => mLastException is SqlException;


        /// <summary>


        /// If you don't need the entire exception as in 


        /// LastException this provides just the text of the exception


        /// </summary>


        /// <returns></returns>


        public string LastExceptionMessage => mLastException.Message;


        /// <summary>


        /// Indicate for return of a function if there was an 


        /// exception thrown or not.


        /// </summary>


        /// <returns></returns>


        public bool IsSuccessFul => !mHasException;


    }


}

public
class
OpenXmlExamples : BaseExceptionsHandler

public
void
CreateNewFile(string
pFileName, string
pSheetName)

{


    mHasException =
false;


    try

    {


        using
(var doc = SpreadsheetDocument.Create(pFileName, SpreadsheetDocumentType.Workbook))


        {


            var wbp = doc.AddWorkbookPart();


            wbp.Workbook =
new
Workbook();

            var wsp = wbp.AddNewPart<WorksheetPart>();


            wsp.Worksheet =
new
Worksheet(new
SheetData());

            var sheets = wbp.Workbook.AppendChild(new
Sheets());

            var sheet =
new
Sheet()

            {


                Id = wbp.GetIdOfPart(wsp),


                SheetId = 1,


                Name = pSheetName


            };


            sheets?.Append(sheet);


            wbp.Workbook.Save();


        }


    }


    catch
(Exception ex)

    {


        mHasException =
true;


        mLastException = ex;


    }


}

public
List<string> SheetNames(string
pFileName)

{


    mHasException =
false;


    var names =
new
List<string>();


    var con =
new
SmartConnection();

    try

    {


        using
(var cn = new
OleDbConnection(con.ConnectionString(pFileName)))

        {


            cn.Open();


            var dt = cn.GetSchema("Tables",
new
string[] { null,
null,
null,
"Table" });

            foreach
(DataRow row in
dt.Rows)

            {


                names.Add(row.Field<string>("Table_Name").Replace("$",
""));

            }


        }


    }


    catch
(Exception ex)

    {


        mHasException =
true;


        mLastException = ex;


    }


    return
names.Distinct().ToList(); 

}

private
void
cmdGetSheetNamesAutomation_Click(object
sender, EventArgs e)

{


    var example =
new
ExcelBaseExample();

    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
"Customers.xlsx");


    var sheetNames = example.GetWorkSheetNames(fileName);


    if
(!example.HasErrors)

    {


        sheetNames.Insert(0,
"Select sheet");


        cboSheetNamesAutomation.DataSource = sheetNames;


    }


    else

    {


        // notifiy user


    }


}