Wpf работа с excel

Spreadsheets are the heart of data analysis and storage. Almost everyone uses spreadsheets at some point, for personal use or for business.

Our Syncfusion WPF Spreadsheet is an Excel-inspired control that allows you to create, view, edit, and format Microsoft Excel files without having Microsoft Excel installed. It provides an integrated ribbon to cover any possible business scenario. In addition, this control supports a built-in calculation engine with more than 400 widely used formulas. It was built with the .NET Excel Library (Essential XlsIO), which features a full-fledged object model similar to the Microsoft Office automation libraries.

In this blog, I will explain how to create, read, and edit an Excel file using our Syncfusion WPF Spreadsheet control.

Note: If you are new to our Spreadsheet control, then please read the Getting Started with WPF Spreadsheet documentation before proceeding.

Create a simple Spreadsheet project

The following steps illustrate how to create a simple Spreadsheet project in WPF:

1. First, open Visual Studio and select Create a New Project.
2. Then, the New Project dialog will open. Choose WPF Application from the dropdown list and provide a name for your application. Refer to the following screenshot.
3. Now, install the Syncfusion.SfSpreadsheet.WPF NuGet package as a reference to your .NET Framework app from Nuget.org.

   The spreadsheet is available in the namespace Syncfusion.UI.Xaml.Spreadsheet and you can create it programmatically either by using the XAML or C# code.

1. Next, add the SpreadsheetRibbon and bind the Spreadsheet as the DataContext to the SpreadsheetRibbon to make an interaction between the ribbon items and Spreadsheet.

1. To add the SpreadsheetRibbon to your application, use the RibbonWindow since the backstage of the ribbon will open only when the ribbon is loaded under the RibbonWindow.
   Refer to the following code.

   <syncfusion:RibbonWindow x:Class="SpreadsheetDemo.MainWindow"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
   xmlns:mc="http://schemas.openxmlformats.org/markup- compatibility/2006"
   xmlns:syncfusion="http://schemas.syncfusion.com/wpf"
   mc:Ignorable="d">
   <syncfusion:SfSpreadsheetRibbon DataContext= "{Binding ElementName=spreadsheet}"  />
   <syncfusion:SfSpreadsheet x:Name="spreadsheet"/>
   </ syncfusion:RibbonWindow >
   

Now, we have created a simple WPF Spreadsheet project.

Create a new Excel workbook

You can create a new workbook by using the Create method. By default, a workbook will be created with a single worksheet. Use the following code to load the Spreadsheet workbook with a specified number of worksheets.

spreadsheetControl.Create(2);

Also, you can add new worksheets on-demand in the WPF Spreadsheet control by clicking the AddNew button. Refer to the following screenshot.

View the existing Excel sheet

The following code snippet illustrates how to view Excel files using the WPF Spreadsheet control.

/// View the Excel file.
spreadsheetControl.Open (@"....DataGettingStarted.xlsx");
                   (or)
ExcelEngine excelEngine = new ExcelEngine();
IWorkbook workbook = excelEngine.Excel.Workbooks.Open(@"....DataGettingStarted.xlsx");
spreadsheetControl.Open(workbook);
                   (or)
using (FileStream fileStream = new FileStream(@"....Data GettingStarted.xlsx”, FileMode.Open))
{
     spreadsheetControl.Open(fileStream);
}

Also, you can open the existing Excel files by clicking Open in the SpreadsheetRibbon backstage, like in the following screenshot.

Edit the values in an Excel file

The Spreadsheet provides support for editing, so you can modify and commit the cell values in a workbook. The following code snippet illustrates how to edit data in an Excel file using the WPF Spreadsheet control.

/// Editing a specific cell value.
var range = spreadsheetControl.ActiveSheet.Range[2,2];
spreadsheetControl.ActiveGrid.SetCellValue(range, "Syncfusion");
spreadsheetControl.ActiveGrid.InvalidateCell(2,2);

Refer to the following screenshot.

Saving an Excel sheet

You can save Excel workbooks using the Save() method. If the workbook already exists in the system drive, then it will be saved in the same location. Otherwise, the Save dialog box will open to let you save the workbook in a specified location.

Refer to the following code snippet.

/// Save the changes made in the file. If the file is not created yet, then it prompts to enter the filename to save.
spreadsheetControl.Save();

/// Save the changes made in the file using the SaveFileDialog.
spreadsheetControl.SaveAs();

Also, you can save the Excel files using Save or SaveAs in the ribbon backstage.

GitHub reference

You can download the complete sample from Create, View, Edit, and Save Excel Files Using WPF Spreadsheet demo.

Conclusion

Thanks for reading! In this blog post, we gave a quick overview of how to create, view, edit, and save  Excel files using the Syncfusion WPF Spreadsheet control. This control also supports hyperlinks, bookmarks, encryption, localization, cell formatting, and more. Try out these versatile features and share your feedback in the comments section of this blog post!

The Spreadsheet control is also available in our ASP.NET (Core, MVC, Web Forms), JavaScript, Angular, React, Vue, UWP, WinForms, and WPF platforms.

If you are an existing Syncfusion user, please download the latest version from the License and Downloads page and try the new features for yourself. Also, our NuGet packages are available on NuGet.org.

If you aren’t a customer yet, you can try our 30-day free trial to check out these features. Also, try our other demos from this GitHub repository.

You can also contact us through our support forums, Direct-Trac, or feedback portal. We are always happy to assist you!

Related blogs

• How to Interact with the WPF Scheduler Using a Keyboard
• Enjoy 30+ New, Elegant Palettes in WPF Theme Studio
• Add, Edit, and Delete Cloud Shapes in PDF Files with Ease in WPF
• Simple Steps to Design a Temperature Monitor Using WPF Radial Gauge

Вообще такие вопросы нужно закрывать как слишком общие, всеми моими уговорами вы так и не разбили задачу на части и не написали, что конкретно в каждой маленькой части задачи у вас не получается. Я рискну вам ответить и расписать как разбить задачу на части и реализовать каждую часть.

Итак, для начала махом задача делится на две поменьше:

1. Чтение данных из Excel
2. Отображение данных в GUI

1. Чтение данных из Excel

Для удобства и ускорения отладки этой части проще сначала создать консольный проект, а не WPF. Именно так я и поступлю.

Первым делом вам необходимо создать модельные классы, экземпляры которых вы будете создавать на основе данных с листа Excel-книги. Я предположу, что у вас одна строка в таблице представляет собой один некий объект (если это не так — вы должны создать другие классы и структуры данных, более подходящие по смыслу):

public class Metric
{
    public int Alpha { get; set; }
    public int Beta { get; set; }
    public int Gamma { get; set; }
    public int Delta { get; set; }
}

Далее необходимо создать метод, который загрузит данные из Excel и вернет коллекцию экземпляров Metric. Нам нужен инструмент, для работы с Excel, я надеюсь, что вы используете более новый xlsx-формат книг, поэтому опишу как можно работать с ним. Я подключил из NuGet пакет ClosedXml (документация и примеры к нему лежат где-то здесь) и написал такой метод:

using ClosedXML.Excel;
using System.Collections.Generic;

...

static IEnumerable<Metric> EnumerateMetrics(string xlsxpath)
{
    // Открываем книгу
    using (var workbook = new XLWorkbook(xlsxpath))
    // Берем в ней первый лист
    using (var worksheet = workbook.Worksheets.Worksheet(1))
    {
        // Перебираем диапазон нужных строк
        for (int row = 2; row <= 3; ++row)
        {
            // По каждой строке формируем объект
            var metric = new Metric
            {
                Alpha = worksheet.Cell(row, 1).GetValue<int>(),
                Beta = worksheet.Cell(row, 2).GetValue<int>(),
                Gamma = worksheet.Cell(row, 3).GetValue<int>(),
                Delta = worksheet.Cell(row, 4).GetValue<int>(),
            };
            // И возвращаем его
            yield return metric;
        }
    }
}

Возможно вам потребуется помимо пути к файлу передавать в метод EnumerateMetrics также номер листа и координаты ячеек из которых нужно загрузить данные, я пока это всё «захардкодил».

Отлично, тестируем метод:

static void Main(string[] args)
{
    var metrics = EnumerateMetrics("Data.xlsx");
    foreach (var m in metrics)
        Console.WriteLine("Альфа: {0}; Бета: {1}; Гамма: {2}; Дельта: {3}",
            m.Alpha, m.Beta, m.Gamma, m.Delta);
    Console.ReadKey();
}

Ура! Эта часть работает нормально!

2. Отображение данных в GUI

Теперь можно наконец создать WPF проект и разметить главное окно. Я вас прошу, не нужно «рисовать контролы мышкой», пишите разметку вручную, от этого она будет лаконичнее, гибче, да и вам это пойдет на пользу — быстрее поймете смысл всего этого. Итак, нам нужен Grid с двумя колонками, в первую мы поместим DataGrid, а во вторую Button. Я не буду вам сейчас «забивать голову» MVVM и прочим, поэтому просто зададим контролам имена в разметке и подпишемся на событие клика по кнопке:

<Grid Margin="5">
    <Grid.ColumnDefinitions>
        <ColumnDefinition/>
        <ColumnDefinition Width="100"/>
    </Grid.ColumnDefinitions>

    <DataGrid Name="MetricsDataGrid" Margin="0,0,5,0"/>

    <Button Grid.Column="1" VerticalAlignment="Top"
            Padding="10,5" Click="Button_Click">
        <TextBlock TextAlignment="Center" TextWrapping="Wrap"
                   Text="Загрузить таблицу"/>
    </Button>
</Grid>

Вроде хорошо выглядит.

Теперь из прошлого проекта копируем в этот наш класс Metric и метод EnumerateMetrics, но, так как он не может существовать сам по себе, давайте создадим класс, например XlsxHelper и поместим этот метод в него и сделаем его публичным. Ну и не забудьте, конечно, подключить пакет ClosedXml.

Остается только воспользоваться ранее написанным кодом в обработчике клика по кнопке:

private void Button_Click(object sender, RoutedEventArgs e)
{
    var metrics = XlsxHelper.EnumerateMetrics("Data.xlsx").ToList();
    MetricsDataGrid.ItemsSource = metrics;
}

Ну и, чтобы колонки в DataGrid выглядели симпатичнее, отключим автогенерацию и создадим их вручную:

<DataGrid Name="MetricsDataGrid" Margin="0,0,5,0"
          AutoGenerateColumns="False">
    <DataGrid.Columns>
        <DataGridTextColumn Header="Альфа" Binding="{Binding Alpha}"/>
        <DataGridTextColumn Header="Бета" Binding="{Binding Beta}"/>
        <DataGridTextColumn Header="Гамма" Binding="{Binding Gamma}"/>
        <DataGridTextColumn Header="Дельта" Binding="{Binding Delta}"/>
    </DataGrid.Columns>
</DataGrid>

Microsoft Excel is an electronic spreadsheet that has become one of the most important and widely used software for storing, organizing and manipulating data. Be it a small medical store or the accounts department of a big enterprise, everybody uses Excel. Recently I came across a requirement where a customer had to programmatically read/write data to and from an Excel workbook file. In .NET, there are multiple ways to do so, right from using an interop assembly to using an OleDb connection API to read/write from and to Excel files.

To use an OLEDB connection in a WPF .NET app, the Office System Driver for Data Connectivity must be installed on your machine. The driver can be downloaded from here. If the .NET application uses an OleDb provider ‘Microsoft.ACE.OLEDB.12.0’ without installing this driver, the application will throw ‘the ‘microsoft.ace.oledb.12.0’ provider is not registered on the local machine’ exception.

Another important point to note is that, since the .NET application will read the data from Excel workbook which is managed by the Operating System filesystem, the workbook must be closed in order to successfully read or write data from it, else the .NET application throws an exception. If you want to keep the workbook open and yet want the .NET application to read the data from it, then the workbook must configured as a shared workbook.

For our demo, create an Excel File (2010/2013) with the following Structure:

Make the workgroup shared as shown here:

The Sharing options are as follows:

The Sharing options must be set to synchronize changes from the Excel Worksheet to the .NET client application.

Step 1: Open Visual Studio 2012/2013 and create a new WPF application targeted to using the .NET 4.5 framework. Name the app as ‘WPF_Excel_Reader_Writer’. In the MainWindow.xaml add a DataGrid and a Button as shown here:

<Grid>
<Grid.RowDefinitions>
    <RowDefinition Height=»272*»/>
    <RowDefinition Height=»71*»/>
</Grid.RowDefinitions>
<Button Content=»Synchronize»
        Name=»btnsync» Grid.Row=»1″
        FontSize=»40″ FontFamily=»Times New Roman»
        FontWeight=»ExtraBold»
         />
<DataGrid Name=»dgEmp» AutoGenerateColumns=»False» ColumnWidth=»*»
           >
    <DataGrid.Columns>
        <DataGridTextColumn Header=»EmpNo» Binding=»{Binding EmpNo}»></DataGridTextColumn>
        <DataGridTextColumn Header=»EmpName» Binding=»{Binding EmpName}»></DataGridTextColumn>
        <DataGridTextColumn Header=»Salary» Binding=»{Binding Salary}»></DataGridTextColumn>
        <DataGridTextColumn Header=»DeptName» Binding=»{Binding DeptName}»></DataGridTextColumn>
    </DataGrid.Columns>
</DataGrid>

</Grid>

Step 2: To the project, add a new class file and name it as ‘DataAccess.cs’. Add the following code in it:

using System;
using System.Threading.Tasks;

using System.Data.OleDb;
using System.Collections.ObjectModel;

namespace WPF_Excel_Reader_Writer
{

public class Employee
{
public int EmpNo { get;set; }
public string EmpName { get; set; }
public int Salary { get; set; }
public string DeptName { get; set; }
}
public class DataAccess
{
OleDbConnection Conn;
OleDbCommand Cmd;

public DataAccess()
{
    Conn = new OleDbConnection(«Provider=Microsoft.ACE.OLEDB.12.0;Data Source=F:\FromC\VS2013\WPF_45_DEMOS\Employee.xlsx;Extended Properties=»Excel 12.0 Xml;HDR=YES;»»);
}

/// <summary>
/// Method to Get All the Records from Excel
/// </summary>
/// <returns></returns>
public async Task<ObservableCollection<Employee>> GetDataFormExcelAsync()
{
    ObservableCollection<Employee> Employees = new ObservableCollection<Employee>();
    await Conn.OpenAsync();
    Cmd = new OleDbCommand();
    Cmd.Connection = Conn;
    Cmd.CommandText = «Select * from [Sheet1$]»;
    var Reader = await Cmd.ExecuteReaderAsync();
    while (Reader.Read())
    {
        Employees.Add(new Employee() {
            EmpNo = Convert.ToInt32(Reader[«EmpNo»]),
            EmpName = Reader[«EmpName»].ToString(),
            DeptName = Reader[«DeptName»].ToString(),
            Salary = Convert.ToInt32(Reader[«Salary»])
        });
    }
    Reader.Close();
    Conn.Close();
    return Employees;
}

/// <summary>
/// Method to Insert Record in the Excel
/// S1. If the EmpNo =0, then the Operation is Skipped.
/// S2. If the Employee is already exist, then it is taken for Update
/// </summary>
/// <param name=»Emp»></param>
public async Task<bool> InsertOrUpdateRowInExcelAsync(Employee Emp)
{
    bool IsSave = false;
    //S1
    if (Emp.EmpNo != 0)
    {
        await Conn.OpenAsync();
        Cmd = new OleDbCommand();
        Cmd.Connection = Conn;
        Cmd.Parameters.AddWithValue(«@EmpNo», Emp.EmpNo);
        Cmd.Parameters.AddWithValue(«@EmpName», Emp.EmpName);
        Cmd.Parameters.AddWithValue(«@Salary», Emp.Salary);
        Cmd.Parameters.AddWithValue(«@DeptName», Emp.DeptName);
        //S2
        if (!CheckIfRecordExistAsync(Emp).Result)
        {
            Cmd.CommandText = «Insert into [Sheet1$] values (@EmpNo,@EmpName,@Salary,@DeptName)»;
        }
        else
        {
            if (Emp.EmpName != String.Empty || Emp.DeptName != String.Empty)
            {
                Cmd.CommandText = «Update [Sheet1$] set EmpNo=@EmpNo,EmpName=@EmpName,Salary=@Salary,DeptName=@DeptName where EmpNo=@EmpNo»;
            }
        }
        int result = await Cmd.ExecuteNonQueryAsync();
        if (result > 0)
        {
            IsSave = true;
        }
        Conn.Close();
    }
    return IsSave;

}

/// <summary>
/// The method to check if the record is already available
/// in the workgroup
/// </summary>
/// <param name=»emp»></param>
/// <returns></returns>
private async Task<bool> CheckIfRecordExistAsync(Employee emp)
{
    bool IsRecordExist = false;
    Cmd.CommandText = «Select * from [Sheet1$] where EmpNo=@EmpNo»;
    var Reader = await Cmd.ExecuteReaderAsync();
    if (Reader.HasRows)
    {
        IsRecordExist = true;
    }

    
    Reader.Close();
    return IsRecordExist;
}
}

}

The code we just saw does the following:

-The Employee class is used to define attributes for the Employee object.

-The class DataAccess is used to interact with the Excel file using the following declarations:

• The connection and command objects are defined using OleDbConnection and OleDbCommand respectively.
• The constructor defines a connection string for the Excel file using Mictosoft.ACE.OLEDB.12.0 provider. Here the path of the Excel file passed to the connection string need to be changed as per the location of the Excel file.
• All methods are defined as async to make Async calls.
• The GetDataFromExcelAsync() method opens connection to the Excel file and reads data from the Worksheet with the name Sheet1. This methods returns an ObservableCollection.
• The method InsertOrUpdateRowInExcelAsync() method accepts an Employee objects. If the EmpNo from this object is zero(0) then the execution of the rest of the code of this method is skipped. This is just a simple check and you can customize is as per your business needs. This method calls the CheckIfRecordExistAsync() method which is responsible to check if the Employee record already exists. If yes, then the record is accepted for update, else a new record is created.

Step 3: We will now subscribe to the following events:

• Loaded event of the Window
• Click event of the button
• CellEditEnding, RowEditEnding and SelectionChanged events of the DataGrid

Step 4: Add the following code in the MainWindow.xaml.cs:

public partial class MainWindow : Window
{
//The object of the DataAccess class
DataAccess objDs;
public MainWindow()
{
    InitializeComponent();
}

//The Employee Object for Edit
Employee emp = new Employee();
/// <summary>
/// On Load get data from the Excel
/// </summary>
/// <param name=»sender»></param>
/// <param name=»e»></param>
private void Window_Loaded(object sender, RoutedEventArgs e)
{
    objDs = new DataAccess();
    try
    {
            dgEmp.ItemsSource = objDs.GetDataFormExcelAsync().Result;
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}
/// <summary>
/// TO Synchronize the Excel Workbook with the Application
/// </summary>
/// <param name=»sender»></param>
/// <param name=»e»></param>
private   void btnsync_Click(object sender, RoutedEventArgs e)
{
    try
    {
       dgEmp.ItemsSource =   objDs.GetDataFormExcelAsync().Result;
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}
/// <summary>
/// Read Data entered in each Cell
/// </summary>
/// <param name=»sender»></param>
/// <param name=»e»></param>
private void dgEmp_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
{
    try
    {
            FrameworkElement eleEno = dgEmp.Columns[0].GetCellContent(e.Row);
            if (eleEno.GetType() == typeof(TextBox))
            {
                emp.EmpNo = Convert.ToInt32(((TextBox)eleEno).Text);
            }

            FrameworkElement eleEname = dgEmp.Columns[1].GetCellContent(e.Row);
            if (eleEname.GetType() == typeof(TextBox))
            {
                emp.EmpName = ((TextBox)eleEname).Text;
            }

            FrameworkElement eleSal = dgEmp.Columns[2].GetCellContent(e.Row);
            if (eleSal.GetType() == typeof(TextBox))
            {
                emp.Salary = Convert.ToInt32(((TextBox)eleSal).Text);
            }

            FrameworkElement eleDname = dgEmp.Columns[3].GetCellContent(e.Row);
            if (eleDname.GetType() == typeof(TextBox))
            {
                emp.DeptName = ((TextBox)eleDname).Text;
            }

    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}
/// <summary>
/// Get the Complete row
/// </summary>
/// <param name=»sender»></param>
/// <param name=»e»></param>
private void dgEmp_RowEditEnding(object sender, DataGridRowEditEndingEventArgs e)
{
    try
    {
      bool IsSave = objDs.InsertOrUpdateRowInExcelAsync(emp).Result;
      if (IsSave)
      {
          MessageBox.Show(«Record Saved Successfully»);
      }
      else
      {
          MessageBox.Show(«Problem Occured»);
      }
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }

   
}
/// <summary>
/// Select the Recod for the Update
/// </summary>
/// <param name=»sender»></param>
/// <param name=»e»></param>
private void dgEmp_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    emp = dgEmp.SelectedItem as Employee;
}
}

The code has the following specifications:

• The Loaded event makes call to GetDataFromExcelAsync() method from the DataAccess class. The result returned from the method is then displayed in the DataGrid using ItemsSource property
• In the SelectionChanged implementation, the Employee object is generated which will be used for update
• The CellEditEnding implementation is used to read the cell value entered in the specific row of the DataGrid. These values will be put in the Employee object. This object will then be used to insert or update in the Excel Worksheet
• The RowEditEnding implementation will make a call to the InsertOrUpdateRowInExcelAsync() method and pass an Employee to it for inserting or updating
• Clicking the button will retrieve the latest data from the worksheet and display it in the DataGrid

Step 5: Run the application. You will see the following:

To test synchronization, add a new record in Excel and click on the ‘Synchronize’ button. The newly added record will be as shown below:

(that’s the best straight row highlighting I could do after 3 attempts )

Since the Workbook is shared, the data entered in the worksheet of the workbook can be directly synchronized even when the workbook is open.

Similarly enter a record in the DataGrid Row. When you click on the next row or the current row loses focus, the record will be saved in the Worksheet as shown here.

To verify, close the application and reopen the Excel file. The newly added record will be displayed in Excel as shown here:

And that’s how using WPF, we can Read and Write Data to Excel files.

Conclusion: We just saw that if Excel files are used as a data store, using OleDb features the data from the Workgroup can be read and manipulated in a WPF .NET application.

Download the entire source code of this article (Github)

This article has been editorially reviewed by Suprotim Agarwal.

In the current article I proudly present a simple application, which creates a simple Excel file from XAML. In the example I present I am using Excel 2010 as this is my current version. In order to be able to create an excel application from WPF, we should enable the usage of some COM libraries . This is done through the following steps:

1. Go to “References” and click the right button -> Add Reference;

2. In the menu which appears, select “Microsoft Excel 14.0 Object Library” (the library can vary depending on your excel version. Excel 14.0 is for Excel 2010. Here you may find the other excel versions. As you see – Excel 2007 is version 12.0, Excel 2013 is version 15.

3. Simply click “OK”.

After adding the COM library you get access to a few nice features. The XAML code of our application is simple – it is just a button with method. Anyway, here it comes:

With the code behind, taking care for the execution of the program, the code looks as follows:

What do we have here? From the beginning, a new namespace:

Then in the method for file generation we have something familiar for those who have code experience with VBA for Excel. With the first three lines we create an Excel application, make it visible and we maximize it. Then we create a workbook and we name it in the same line. The first worksheet of the workbook is also named. Thus, so far we have named the excel application (app), the workbook (wb) and the first worksheet (ws). Then we create a variable of type DateTime, naming it currentDate. Using the “ws.Range[“”] we set values for the different excel boxes. We use formulas and even a loop. At the end we save everything in the path “CTemp and the file is named “vitoshacademy.xlsx”. The usage of double slash (“\”) is needed, because the single one acts as a comment in C#, and the double one neutralizes it.

In short, that is it. If you want to see this example, you may try it out here – ExcelInWPF.