When trying to send an email via SMTP you may get the dreaded “The SMTP server requires a secure connection or the client was not authenticated” error. This error is annoying but is actually really easy to fix!

Why did I receive the SMTP server Authentication error?

This authentication error actually happens because Google is blocking you from signing into your Gmail account. The reason for this used to be a setting called “Allow less secure apps.” but now you will have to generate an App Password and use that in your code.

Google doesn’t initially allow any application to log into your Google account. You will have to give permission for applications to access your Gmail account. This used to require a simple setting change to allow unsecured applications. Google has since changed that policy and you will have to generate a password for your application. I will show you how to do that and include an example code below!

How to fix “The SMTP server requires a secure connection or the client was not authenticated” – Old Method

Previously, To fix this error, we simply need to enable the following setting in your google account: “Allow less secure apps.” You will see this method suggested a lot all over the internet but it does not work anymore. I will provide the new solution below!

Old Method to enable “Allow less secure apps.”:

• Login to your Gmail Account
• Navigate to the security settings for your Google Account
• Navigate to “Less secure App Access” and turn on “Allow less secure apps”

Once you click the toggle switch and it has been enabled, your app should now be working, or at least… It would have before the latest Google update! Previously this would have fixed your authentication issue but now you just receive this error message.

Google has actually disabled this super easy fix as of May 30th 2022. Now we have to generate a unique password for our application, which is thankfully really easy to do!

How to fix “The SMTP server requires a secure connection or the client was not authenticated” – after May 30th 2022

Google has now disabled the ability to enable the use of less secure applications. Instead, we will be getting an App Password and using that in our application. Follow the steps below to get your app password and then we will discuss how to use it in your application with an example.

Example code to send an email using the new app password:

using System;
using System.Net;
using System.Net.Mail;

namespace GmailSmtpConsoleApp
{
    class Program
    {
        private const string ToAddress = "testemail@testing.com";
        private const string FromAddress = "testemail@testing.com";
        
        private const string GoogleAppPassword = "XXXXXXXX";
        
        private const string EmailSubject = "Test email!!";
        private const string EmailBody = "<h1>Hi</h1>";
        
        
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            
            var smtpClient = new SmtpClient("smtp.gmail.com")
            {
                Port = 587,
                Credentials = new NetworkCredential(FromAddress , GoogleAppPassword),
                EnableSsl = true,
            };
            var mailMessage = new MailMessage
            {
                From = new MailAddress(FromAddress),
                Subject = EmailSubject,
                Body = EmailBody,
                IsBodyHtml = true,
            };
            mailMessage.To.Add(ToAddress);

            smtpClient.Send(mailMessage);
        }
    }
}

This code should be pretty straightforward, we are just passing our application password to the Network Credential object that we made. We then pass that NetworkCredential object off to Gmail when we send our message.

Thanks for reading and I hope this helped you fix your “The SMTP server requires a secure connection or the client was not authenticated” error message! If you are still having problems, feel free to ask any questions in the comments below and I would be happy to help!

We are going to be writing data to Excel files using C#. Writing code to add data to an Excel sheet in C# is really easy! You can write to Xlsx, Xlsm and Xls formats all in the same way! We will go over how to do that step by step! Follow along and you will be able to write values to excel files with ease!

I’ve also created a video guide on how to do this that is embedded below and that will show you the entire process! If you would like to learn how to write to excel files from a text-based format though, read on!

Include the Required Assembly File

The first thing we need to do is include the Microsoft.Office.Interop.Excel assembly. This will contain all of the functions we will be using to write an excel document out using C#.

To include that assembly we will need to do two things, the first of which is add it to the references section.

Add the using statement

Next, we are going to add the Using statement to the top of our class. This will look like the code below.

using Microsoft.Office.Interop.Excel;

Create a button to write to Excel

Next, head over to your designer and add a button. This new button will be named “CmdWrite” and when pressed is going to call our write excel code. After dragging the new button from our toolbox, renaming it “CmdWrite” and then changing its text to “Write”, it’s time to double-click it to get back to the code screen.

Call our WriteExcel function

In our Form1.cs code behind the designer class, we are only going to have one line of code. This line of code will call our writeExcel function inside of our WriteExcel class. I’ll write out the code below to make it easy to copy/paste.

private void CmdWrite_Click(object sender, EventArgs e) {
     WriteExcel.writeExcel();
}

Create a new Class with a writeExcel function

Create a new file in your solution explorer called “writeExcel.cs” This new class needs to be a “code file” and it will be .cs because we are writing in C#. Once you create that file, you need to add a static void function called writeExcel. I’ll write the class out below.

class WriteExcel
{
     public static void writeExcel()
     {
      
     }
}

Create an Excel application and declare our file path

First, we are going to declare our filePath variable, to keep track of where our excel file will be saved. Next, we are going to create a new Excel Application and then declare a worksheet and a workbook. I’ll

public static void writeExcel {
     {
         string filePath = "c:\\Simple\\ExcelTest.xlsx";
         Microsoft.Office.Interop.Excel.Application excel = new Microsoft.Office.Interop.Excel.Application();
         Workbook wb;
         Worksheet ws;
     }     
}

Open a worksheet inside of a workbook

Open a worksheet inside of an existing workbook to begin editing that sheet. Excel starts it’s indexes with 1 instead of 0, so you want to use worksheets[1] to get the first worksheet in your workbook.

wb = excel.Workbooks.Open(filePath);
ws = wb.Worksheets[1];

Select an Excel Range and change it’s value

Next, we are going to select an Excel range. In our example, this range is going to be C1 to C1, which is just the C1 cell. We are going to set that range’s value to “Pizza!” in our example code below.

Range cellRange = ws.Range["C1:C1"];
cellRange.Value = "Pizza!";

Save and Close the Excel Document

Lastly, we need to save and close our excel document. To save your changes to the Excel document and close it, you will need to add the 2 lines of code below. I will include all of the above code though, so you can easily copy/paste the finished product.

public static void writeExcel {
     {
         string filePath = "c:\\Simple\\ExcelTest.xlsx";
         Microsoft.Office.Interop.Excel.Application excel = new Microsoft.Office.Interop.Excel.Application();
         Workbook wb;
         Worksheet ws;

         wb = excel.Workbooks.Open(filePath);
         ws = wb.Worksheets[1];

         Range cellRange = ws.Range["C1:C1"];
         cellRange.Value = "Pizza!";

         wb.SaveAs("c:\\Simple\\ExcelTest5.xlsx");
         wb.close();
     }     
}

We now have Pizza written to our Excel Document

At this point, you should be able to run your application and it should add “Pizza!” to your excel document just like it did in mine here. If you are having trouble with this, be sure to watch my video above for step by step instructions.

Opening an Excel file with C#

I wanted to toss in a tip about how to Open the excel file after you have saved your changes to it. You can use Process.start to open the excel file. The only trick is that you need to add a Using statement for System.diagnostics. I’ll add the two lines of code below, keep in mind the Using statement goes at the top of your class and the Process.Start will go in our writeExcel function.

using System.Diagnostics;

Process.start("c:\\Simple\\ExcelTest5.xlsx");

In Closing

Well, that’s about it for the absolute basics on writing to an Excel file! I hope this quick guide helps you get started and if you have any questions, feel free to ask in the comments below!

We are going to be reading data that is stored in Excel files using C#. Writing code to read Excel sheets in C# is really easy! You can read from xlsx, xlsm and xls formats in the same way! We will go over how to do that step by step! Follow along and you will be able to get values out of your sheets with ease!

First, I’ve created a video guide that is embedded here that will show you the entire process! If you would like to learn how to read from excel from a text-based format though, read on!

The first step is to create a new C# Application in Visual Studio, I create a new WinForms application in the above example and use a simple button. You can create a Console application or WinForms application to do the following task.

I would also like to add that this code can be easily converted to work with VB.Net! Most of the code I write to read excel documents is actually written in VB.Net. If you have any questions about how to read from Excel files in CSharp or VB.Net, leave a comment below or on the Youtube video and I will help as soon as I see it!

This is the simple Windows Forms application that I created to read from an excel file. It just contains a simple button.

Next, you need to double-click on the button to handle the click event. This will get us into the code behind with an event handler already written! That should look like the screenshot below!

After that, we need to include the Excel Object Library. To do this, you need to right-click on References, then click add a reference. Next, you click on COM on the left and search for “Excel”. This will bring up “Microsoft Excel 16.0 Object Library”. This can have different version numbers if you have different versions of Excel installed.

You will have to have a version of Microsoft Office installed for this to work. What the application does, in the end, is create an instance of Excel that we use to open and read the file. So if you don’t have Excel installed, the application can’t create an instance of it. You will know this by not being able to find the Object Library. So if you can’t find the excel reference, it’s most likely because Excel isn’t installed on the box and needs to be installed.

Once you have the reference added, the next step is to use that reference in the heading of your code. The line of code for this is below. I’ve included the other two lines that will be there already, just so you know where to put the using Excel line.

using System;
using Microsoft.Office.Interop.Excel;
using System.Windows.Forms;

Alright, now we have our references all set up and it’s time to start writing our code to read from the excel document! I created a new function called readExcel, which gets called from the new button click event handler. I’ll show what that looks like in the picture below.

Doing it this way just keeps the excel code out of the designer code. In a perfect world, you would put this function in another class file and not in the same file as the designer code (event handler in this case).

The following code is used to open the workbook

private void readExcel() {
     string filePath = "c:\path\to\file.xls";
     Microsoft.Office.Interop.Excel.Application excel = new Excel.Application();
     Workbook wb;
     Worksheet ws;
     wb = excel.Workbooks.Open(filePath);
     ws = wb.Worksheets[1];

}

Obviously, you will need to change the filePath to your desired file path. I also recommend using a file browser dialog or something to that nature, if the path changes frequently.

So to work through this code, we declare the file path, then we create a new excel application, next we create an object to hold an excel workbook, then we create an object to hold an excel worksheet. After that, we open the file located at the path and it is stored in the wb Workbook variable. Now that we have the book open, we can then get the first sheet and store that in ws, our worksheet variable.

Now that we have everything set up it is time to start reading values from cells!

The simple way to read a value from the excel file would be to just message box out the results using the line of code below.

private void readExcel() {
     string filePath = "c:\path\to\file.xls";
     Microsoft.Office.Interop.Excel.Application excel = new Excel.Application();
     Workbook wb;
     Worksheet ws;
     wb = excel.Workbooks.Open(filePath);
     ws = wb.Worksheets[1];

     MessageBox.Show(Convert.ToString(ws.Cells[1, 1].Value));

}

In my excel file, the cell at 1,1 has the word Apple and the resulting message box looked like this:

Below I have broken that line down into parts that make it easier to understand:

private void readExcel() {
     string filePath = "c:\path\to\file.xls";
     Microsoft.Office.Interop.Excel.Application excel = new Excel.Application();
     Workbook wb;
     Worksheet ws;
     wb = excel.Workbooks.Open(filePath);
     ws = wb.Worksheets[1];

     Range cell = ws.Cells[1, 2];
     string CellValue = cell.Value;
     MessageBox.Show(CellValue);

}

The last 3 lines are the important bit. The first line creates a Range object called cell and stores the Range located at position 1,2 in the Excel file in it. Next we create a string variable called CellValue and pull the Value out of the cell variable and store it in the CellValue string. Lastly, we message box out that value. The resulting message box in my example said “Wine”

Another method you can do is to use excel’s own naming convention to read cells and ranges from the sheet. What I mean by that is being able to say “A1” or “A1:B1” to read from the sheet. This will make it easier for you to know where in the document you are reading at a glance. The code for that is below.

Range cell = ws.Range["A1"];

If you attempt to read a range using the above code, you are going to get Object[] as the result. This is because the value is an array instead of a single value. To read in a range of cell values, you will need to loop through the array to display each value. The code for this is located below.

private void readExcel() {
     string filePath = "c:\path\to\file.xls";
     Microsoft.Office.Interop.Excel.Application excel = new Excel.Application();
     Workbook wb;
     Worksheet ws;
     wb = excel.Workbooks.Open(filePath);
     ws = wb.Worksheets[1];

     Range cell = ws.Cells["A1:A2"];
     foreach (string Result in cell.Value)
     {
           MessageBox.Show(Result);
     }
}

The result of this will be a message box for each cell in the range which will contain the value of each cell. In my case, the first message box said Apple, and the second said Banana.

If you are reading a lot of values out of an Excel sheet, you are going to want to read the data in as a range and store that in an array. At that point, you can manipulate the array in code really quickly. If you read the data in one cell at a time, instead of as a range, it will be much slower with large datasets.

One last thing to note is that you will want to use .close() and .dispose() on your workbook after you are done reading values. This way your excel sheet isn’t continually locked out!

I hope this was helpful and if you have any questions, feel free to leave a comment!