In today’s interconnected digital landscape, Application Programming Interfaces (APIs) serve as the backbone of numerous web and mobile applications, enabling seamless communication and data exchange between different systems. However, increased connectivity means there’s a bigger chance someone could sneak in and get important information without permission. To make sure this doesn’t happen, it’s really important to put robust security measures in place for APIs.

API Security 12 Best Practices

Here are 12 essential tips for securing your APIs:

1. Use HTTPS: Always ensure that your API communications are encrypted using HTTPS (Hypertext Transfer Protocol Secure). This encrypts the data transmitted between the client and the server, preventing spying and tampering.
   For instance, instead of http://api.example.com, opt for https://api.example.com.
2. Use OAuth2: Implement OAuth2, an industry-standard protocol for authorization, to control access to your APIs. OAuth2 allows users to grant third-party applications limited access to their resources without exposing their credentials.
   For example, popular platforms like Google and Facebook utilize OAuth2 for authentication and authorization.
3. Use WebAuthn: Enhance authentication security by incorporating WebAuthn, a web authentication standard that enables passwordless authentication using biometrics or hardware tokens. By adopting WebAuthn, organizations can strengthen user authentication for accessing APIs, reducing the risk of credential-based attacks.
4. Use Leveled API Keys: Implement API keys with different levels of access privileges based on user roles and responsibilities.
   For instance, a read-only API key may restrict users from making modifications to data, whereas an admin API key grants full access rights.
5. Authorization: Enforce proper authorization mechanisms to ensure that users can only access the resources they are authorized to use. Role-based access control (RBAC) is a common authorization model where access permissions are assigned based on user roles.
   For example, an e-commerce API may grant customers permission to view product listings but restricts the ability to place orders to authenticated users.
6. Rate Limiting: Protect your APIs from abuse and DoS (Denial of Service) attacks by implementing rate limiting. Set limits on how many requests a client can ask for something within a certain period.
   For instance, a social media API may enforce rate limits to prevent a single user from making an excessive number of requests in a short period, thereby ensuring fair usage of resources.
7. API Versioning: Maintain backward compatibility and smooth transitions by versioning your APIs. Versioning allows developers to introduce changes and enhancements without disrupting existing integrations.
   For example, Twitter’s API includes versioning in its endpoints (e.g., /1.1/statuses/home_timeline) to support different API versions concurrently.
8. Whitelisting: Define a whitelist of trusted IP addresses or domains that are allowed to access your APIs. Whitelisting helps prevent unauthorized access from unknown sources or malicious actors.
   For instance, a financial institution may whitelist specific partner organizations to securely exchange financial data via APIs.
9. Check OWASP API Security Risks: Regularly assess and mitigate potential security vulnerabilities using the OWASP (Open Web Application Security Project) API Security Top 10 checklist. This comprehensive list identifies common security risks such as injection attacks, broken authentication, and excessive data exposure. By addressing these risks proactively, organizations can strengthen their API security posture.
10. Use API Gateway: Implement an API gateway as a centralized entry point for managing, securing, and monitoring API traffic. API gateways provide functionalities such as authentication, authorization, rate limiting, and logging, simplifying API management and enhancing security.
    For instance, Amazon API Gateway offers built-in features for securing and scaling APIs deployed on AWS.
11. Error Handling: Implement robust error handling mechanisms to provide informative error messages without exposing sensitive information. Proper error handling helps developers diagnose and troubleshoot issues efficiently while maintaining security.
    For example, an eCommerce API may return standardized error codes and messages for common scenarios like invalid input or resource not found.
12. Input Validation: Validate and sanitize input data to prevent common security vulnerabilities such as SQL injection and cross-site scripting (XSS). Input validation ensures that only well-formed and legitimate data is processed by the API, reducing the risk of exploitation.
    For instance, a healthcare API may validate user input to ensure that medical record identifiers comply with specific formats and do not contain malicious content.

With these 12 tips, you can strengthen the security of your APIs and protect your systems and data from potential threats and vulnerabilities. Remember, proactive security measures are key to staying ahead of malicious actors and maintaining trust with your users and partners.

C# .NET Core provides a robust platform for building applications that interact with Excel files making it easy to read Excel sheet’s cell value of any column type. Open XML is an open standard file format for office applications, maintained by the International Organization for Standardization (ISO). It is the default file format for Microsoft Office documents, including Excel (.xlsx) files. Open XML provides a structured way to represent document content, making it possible to interact with the various elements within an Office document programmatically. In this article, we will understand the process of reading Excel cell values using Open XML in a C# .NET Core application.

Step-by-step Guide to Read Excel Spreadsheet Cell Values from OpenXML in C#

For demonstration purposes, we’re going to use a Web API to upload an Excel file. So before we begin, let’s ensure that you have a C# .NET Core project set up. Then, we’ll use the OpenXML package to read Excel sheet & its values in each cell and store them in a DataTable.

Install OpenXml SDK Nuget Package

Install an OpenXML Nuget Package into the Web API project, using either:

Or

PM> Install-Package DocumentFormat.OpenXml -Version 3.0.0

After you install the package, you can include these assembly directives to use OpenXML, in the ‘Controller.cs’ class.

using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;

Create API to get an Excel file

Create an HTTP POST method in the controller class to receive the uploaded file from the API.

[HttpPost("UploadExcelFile")]
public IActionResult UploadExcelSheet(IFormFile uploadRegistration)
{
	string fileName = uploadRegistration.FileName;

	DataTable dt = ConvertExcelToDataTable(uploadRegistration);

	// write your logic,
	// example insert DataTable result into Database

	return Ok();
}

The API takes IFormFile as a parameter, representing a file sent with the HttpRequest.

Read Data from Excel Sheet using OpenXML – C#

private DataTable ConvertExcelToDataTable(IFormFile uploadRegistration)
{
	//Create a new DataTable.
	DataTable dt = new DataTable();
	dt.Columns.Add("FIRST_NAME", typeof(string));
	dt.Columns.Add("LAST_NAME", typeof(string));
	dt.Columns.Add("PHONE_NUMBER", typeof(int));
	dt.Columns.Add("EMAIL", typeof(string));
	dt.Columns.Add("ADDRESS", typeof(string));

	using (SpreadsheetDocument doc = SpreadsheetDocument.Open(uploadRegistration.OpenReadStream(), false))
	{
		//Read the first Sheet from Excel file.
		Sheet sheet = doc.WorkbookPart.Workbook.Sheets.GetFirstChild<Sheet>();

		//Get the Worksheet instance.
		Worksheet worksheet = (doc.WorkbookPart.GetPartById(sheet.Id.Value) as WorksheetPart).Worksheet;

		//Fetch all the rows present in the Worksheet.
		IEnumerable<Row> rows = worksheet.GetFirstChild<SheetData>().Descendants<Row>();

		//Loop through the Worksheet rows.
		foreach (Row row in rows)
		{
			//If first row is header and you want to use same excel header name in Database column.
			if (row.RowIndex.Value == 1)
			{
				//foreach (Cell cell in row.Descendants<Cell>())
				//{
				//    dt.Columns.Add(GetCellValue(doc, cell));
				//}
			}
			else
			{
				string firstName = GetCellValue(doc, (Cell)row.ElementAt(0));
				string lastName = GetCellValue(doc, (Cell)row.ElementAt(1));

				DataRow dataRow = dt.NewRow();

				// Validate if empty
				if (!string.IsNullOrEmpty(firstName))
				{
					dataRow["FIRST_NAME"] = firstName.Trim();
				}

				if (!string.IsNullOrEmpty(lastName))
				{
					dataRow["LAST_NAME"] = lastName.Trim();
				}

				dataRow["PHONE_NUMBER"] = GetCellValue(doc, (Cell)row.ElementAt(2)).Trim();

				dataRow["EMAIL"] = GetCellValue(doc, (Cell)row.ElementAt(3)).Trim();

				dataRow["ADDRESS"] = GetCellValue(doc, (Cell)row.ElementAt(4)).Trim();

				dt.Rows.Add(dataRow);
			}
		}

	}

	return dt;
}


private string GetCellValue(SpreadsheetDocument doc, Cell cell)
{
	if (cell.CellValue != null)
	{
		string value = cell.CellValue.InnerText;
		if (cell.DataType != null && cell.DataType.Value == CellValues.SharedString)
		{
			// in older version e.g. 2.0, you can use GetItem instead of ElementAt
			return doc.WorkbookPart.SharedStringTablePart.SharedStringTable.ChildElements.ElementAt(int.Parse(value)).InnerText;
		}
		else
		{
			return value;
		}
	}
	return string.Empty;
}

1. We open the Excel file (RegistrationFormTest.xlsx in this case) using the SpreadsheetDocument.Open method.
2. We obtain the WorkbookPart and identify the first sheet in the workbook.
3. For each row in the sheet, we iterate through the cells, using the GetCellValue method to retrieve the cell value.
4. The GetCellValue method takes care of differentiating between shared string values and other types of cell values. It reads Excel Sheet cell value and stores the result in the DataTable.

also read: How to Export DataSet To Excel in C# .Net Core – OpenXml

Testing – Upload & Read Excel file

Let’s consider an example. I have a basic Excel file with the column and row information. Now, let’s attempt to upload and read the file using API, as shown in the screenshots below.

Screenshots:

In this example, we demonstrate how to read Excel spreadsheet cell values and add results to the DataTable. However, you also have the option to save all records to a database. This can be done either through bulk insert or by saving each row individually, passing the values of each row via the property object.

Adding WordPress Custom Rest API Plugin

Sometimes you prefer to create a custom Rest API in PHP within the context of WordPress to return data in a structured format such as JSON which involves setting up custom routes. Here’s a step-by-step guide to creating & integrating a basic WordPress Custom REST API in a WordPress plugin.

Set up a WordPress Plugin

Go to ‘wp-content/plugins’ directory of your WordPress and create a PHP file (e.g., CustomApi.php) to serve as a main plugin file.

In this example, the plugin folder and PHP file names are the same. You can rename it.

You can follow simple 3 steps to create and activate a Custom Plugin in the WordPress Dashboard in a few minutes, check this link – How to Create Custom WordPress Plugin: 3 Easy Steps.

Define WP API Route:

In your plugin file, use the add_action function to hook into WordPress and register your custom API route. Here’s an example of how to add an API route:

function registe_api_routes() {
    register_rest_route('PublicAPIs/v1', '/GetTop10Items',
						array('methods' => 'GET', 'callback' => 'CallFun_GetTop10Items',)
						);
}

add_action('rest_api_init', 'registe_api_routes');

Create API Callback Function

Define the callback function you specified in the register_rest_route for your API route. This function will handle the request and return the data you want to show via the API.

In our example, whenever public API is called by an external source then the below code will be executed internally.

function CallFun_GetTop10Items() {
	// Your API logic here
	// Example:
	$args =  array('showposts' => 10, 'orderby' => 'post_date', 'order' => 'DESC','post_status' => 'publish');

	$query_result = query_posts($args);

	$postList = [];

	foreach ($query_result as $result) {
	  $postList[] = array( "post_title" => $result->post_title, "post_name" => $result->post_name);
	}

	return $postList;
	// or
	// return new WP_REST_Response($postList, 200);
}

Test Your API Endpoint

You can now access your API endpoint and check if it is working as accepted.

How to find WP API endpoints or URLs?

• Open the browser and open the Inspect element developer tool as well. (press f12 or right-click & click Inspect)
• Go to https://yourdomain.com/wp-json/ to get wp-json list.
• Once it is loaded, navigate and go to routes
• expand and go to the path (namespace/endpoint) that is defined in register_rest_route method, that is ‘PublicAPIs/v1/GetTop10Items‘
• Get the API (full URL) as shown in the below screenshot.
  example: https://yourdomain.com/wp-json/PublicAPIs/v1/GetTop10Items

Test WP Web API – Get Method()

Get API can be executed directly on the browser but for demo purposes, we will use the Postman tool to test our API.

The below screenshot demonstrates that a Get API request sends back a response as a JSON result via Postman tool.

Test API: https://yourdomain.com/wp-json/PublicAPIs/v1/GetTop10Items

Calling WordPress Custom Rest API from Javascript

You can use the fetch method in Javascript to call and get the response from the WordPress Custom Rest API, as demonstrated below.

<script>

document.addEventListener("DOMContentLoaded", LoadLatestPosts);

async function LoadLatestPosts() {

	const response = await fetch('/wp-json/PublicAPIs/v1/GetTop10Items');
	const data = await response.json();

	data.forEach(obj => {
		// your logic
	});

}

</script>

for more details check this link: https://developer.wordpress.org/rest-api/extending-the-rest-api/adding-custom-endpoints/

.NET provides a hierarchy of built-in exception classes that are derived from the fundamental Exception base class. However, there may be times when none of the predefined exceptions meet your specific needs or requirements. In such case, you can create your own exception classes by deriving from the Exception class. In this article, we will discuss how to create custom exceptions in .Net Core using ExceptionFilterAttribute and implementing a global exception-handling mechanism in the Web API .Net Core application.

What is ExceptionFilterAttribute?

In .NET Core, ExceptionFilterAttribute is a class that allows developers to create custom exception filters. Exception filters are used to handle exceptions that occur during the execution of ASP.NET Core MVC or Web API actions. These filters can be applied globally to all actions or selectively to specific controllers or actions. When an exception is thrown, an ExceptionFilterAttribute can catch it, perform custom logic (such as logging or generating a specific response), and potentially prevent the exception from propagating to the higher levels of the application. This helps in creating more robust and user-friendly error handling mechanisms in .NET Core applications. In other words, ExceptionFilterAttribute is an attribute used to define exception filters in ASP.NET Web API.

Create an Exception Filter class and override the OnException Method

The implementation for creating a custom Exception Filter is done in the following 3 simple steps.

Step 1: Create Custom Exception Class

To address unhandled exception scenarios, you can create a custom exception filter by defining a class that inherits the ExceptionFilterAttribute abstract class which implements the IExceptionFilter interface internally. In our example, we have given the class name as CustomExceptionAttribute.
Note: End the class name with Arrtibute.

Custom Exception Filter Class

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.Extensions.Logging;

namespace Product.Web
{
    public class CustomExceptionAttribute : ExceptionFilterAttribute
    {
        private readonly ILogger _logger;

        //constructor
        public CustomExceptionAttribute(ILogger logger)
        {
            _logger = logger;
        }


        // override the OnException Method
        public override void OnException(ExceptionContext ex)
        {
            var controllerActionDescriptor = ((Microsoft.AspNetCore.Mvc.Controllers.ControllerActionDescriptor)ex.ActionDescriptor);

            _logger.LogError("API: " + controllerActionDescriptor.AttributeRouteInfo.Template + "\r\n"
                    + ex.Exception.Message + "\r\n"
                    + ex.Exception.ToString());

            //assigning custom response
            ex.Result = JsonResultDto();

            ex.HttpContext.Response.StatusCode = 400;  
        }


        // override the OnException async Method 
        public override async Task OnExceptionAsync(ExceptionContext ex)
        {
            var controllerActionDescriptor = ((Microsoft.AspNetCore.Mvc.Controllers.ControllerActionDescriptor)ex.ActionDescriptor);
                
            _logger.LogError("API: " + controllerActionDescriptor.AttributeRouteInfo.Template + "\r\n"
                    + ex.Exception.Message + "\r\n"
                    + ex.Exception.ToString());

            await Task.FromResult(0);

            //assigning custom response
            ex.Result = JsonResultDto();

            ex.HttpContext.Response.StatusCode = 400;
        }

        // returning custom Json response
        private JsonResult JsonResultDto()
        {
            return new JsonResult(
                new
                {
                    ErrorMessage = "Internal error occurred.",
                    HasError = true,
                    ResponseCode = 400
                });

        }
    }
} 

In the above code, we have overridden two OnException methods (one for normal and another for async methods). If any exception occurs while executing an API method (or in its internal sub-methods) then the code will hit the custom exception filter class. The OnException method will be invoked depending on whether the call is synchronous or asynchronous.
Here, we are using the ILogger interface to log the error details such as:
1) API Path,
2) Exception message,
3) full error stack trace.

The benefit of an Exception Filter is we can return a user-friendly error message to the front-end application in the response body. In the example, after logging the error, the JsonResultDto() method is called which will return the user-defined Json result to the user.

Step 2: Registering Exception Filter

We need to define the scope and register the custom exception filter globally, inside the ConfigureServices method in the startup.cs file.

Add services.AddScoped<CustomExceptionAttribute>(); line of code as shown below:

public class Startup
{
	public void ConfigureServices(IServiceCollection services)
	{
		//...
		//services.AddControllers();
		//...
		
		//register CustomExceptionAttribute class
		services.AddScoped<CustomExceptionAttribute>();
	}
} 

Step 3: Apply Exception Filter on Controller or Action methods

To use a registered filter, it should be placed or decorated at the top of the Controller or Action as a ServiceType.

You can apply the Exception Filter at:
1) Controller Level, or
2) Action Level (one or more based on your requirement).

The example shows custom exception filter is applied at the Controller level, which means it is applicable to all API methods as well.
The GetProducts() method will throw System.FormatException error when code tries to convert a string variable (object) to an integer.

Add [ServiceFilter(typeof(CustomExceptionAttribute))] line of code above the Controller class, as shown below:

namespace Product.Web
{
    [ServiceFilter(typeof(CustomExceptionAttribute))]
    [ApiController]
    [Route("[controller]")]
    public class ProductController
    {
	
        [HttpGet]
        [Route("GetProducts")]
        public IActionResult GetProducts()
        {
            //example: System.FormatException: 'Input string was not in a correct format.'
            object input = "test";
            int result = Convert.ToInt32(input);

            return Ok();
        }
	}
} 

Testing ExceptionFilterAttribute – Screenshots

That’s it, now we can do a unit test and confirm if it is working as expected.

Swagger API Test

Call & execute API method from Swagger. It will return “400 – Bad Request” with a user-friendly JSON message in the response body, as shown in the below screenshot.

Debug code

The custom exception class will be called whenever an error occurs in the Controller’s Web API method and it will capture & log the following details:
1) on which API error occurred e.g., Path: “Product/GetProducts”
2) error message e.g., “Input string was not in a correct format.”
3) full stack trace

see the debugging screenshot below.

We will understand the difference between ExceptionLogger, ExceptionFilter, and ExceptionHandler which helps to handle exceptions in several ways in .NET Core. In this article, we will explore each of these techniques, discussing when and how to use them with real-world examples.

Difference – Overview

ExceptionLogger

ExceptionLogger allows you to log exceptions that occur during the execution of your application. It provides a way to capture detailed information about exceptions, such as the exception message, stack trace, and other relevant data, and then log this information using a custom logging mechanism.

ExceptionLogger is typically used for auditing and monitoring purposes. It helps developers and administrators track the occurrence of exceptions in an application, enabling them to diagnose issues, identify error patterns, and take corrective actions.

When to use ExceptionLogger:

You might use an ExceptionLogger to log exceptions to a central log database or send alerts to a monitoring system like Application Insights or ELK Stack.
Use ExceptionLogger when you want to log exceptions that occur during the execution of your application. ExceptionLogger allows you to capture detailed information about exceptions, including the exception message, stack trace, and other relevant data.

Purpose: all unhandled exceptions (before they even reach exception filters)
Scope: global

public class CustomExceptionLogger : ExceptionLogger
{
    public override void Log(ExceptionLoggerContext context)
    {
        // Log the exception details using your preferred logging mechanism
        LogHelper.LogException(context.Exception);
    }
}

In this example, we create a custom ExceptionLogger that logs exceptions using a custom logging utility. You can then register this logger in your application’s configuration to handle exception logging.

ExceptionFilter

ExceptionFilter allows you to perform custom actions in response to specific exceptions during the execution of your application. It lets you modify the HTTP response, redirect the user, or execute any other logic based on the exception type or conditions you define.

ExceptionFilters are useful when you need to handle exceptions in a more fine-grained manner. You can use them to implement custom error handling behavior for specific scenarios. For example, you might want to return a user-friendly error message for a particular exception type or redirect the user to a login page if their session has expired.

When to use ExceptionFilter:

You can create an ExceptionFilter to catch and handle authorization-related exceptions by redirecting the user to a login page or returning a 403 Forbidden status code.
ExceptionFilters are useful when you need to perform custom actions in response to specific exceptions. They allow you to modify the HTTP response, redirect the user, or perform any other action based on the exception type or condition.

Purpose: handle (not log) exceptions
Scope: per action, per controller, global

public class CustomExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        if (context.Exception is CustomNotFoundException)
        {
            // Handle the not found exception by returning a custom response
            context.Result = new NotFoundObjectResult("Resource not found");
            context.ExceptionHandled = true;
        }
    }
}

In this example, a CustomExceptionFilter is used to catch a specific CustomNotFoundException and return a custom response. You can register this filter globally or on specific controllers or action methods as needed.

ExceptionHandler

ExceptionHandler deals with unhandled exceptions that occur during the execution of your application. It provides a way to customize the behavior when an unhandled exception is encountered, such as redirecting the user to an error page, returning a specific response, or performing cleanup tasks.

ExceptionHandler is designed to handle exceptions that propagate beyond the scope of regular exception handling mechanisms like try-catch blocks. It ensures that your application gracefully manages unhandled exceptions, preventing crashes and providing a more user-friendly experience.

When to use ExceptionHandler:

You can configure an ExceptionHandler to catch unhandled exceptions and return a custom error response with a 500 Internal Server Error status code. This helps ensure that users receive a meaningful error message rather than seeing a generic server error page.
ExceptionHandler is suitable for handling unhandled exceptions that occur during the execution of your application. It allows you to customize the behavior when an unhandled exception occurs, such as redirecting the user to an error page or returning a specific response.

Purpose: log and handle unpredictable/unexpected exceptions
Scope: global

public class CustomExceptionHandler : IExceptionHandler
{
    public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
    {
        // Handle the exception and return a custom response
        context.Result = new ObjectResult("An error occurred")
        {
            StatusCode = StatusCodes.Status500InternalServerError
        };
        return Task.CompletedTask;
    }
}

In this example, a CustomExceptionHandler is used to catch unhandled exceptions and return a custom response with a 500 Internal Server Error status code. You can configure the ExceptionHandler in your application’s startup code to define how unhandled exceptions should be handled.

Conclusion
Exception handling is a crucial part of any application’s development, and in .NET Core, you have several options to tailor your approach to your specific needs. ExceptionLogger, ExceptionFilter, and ExceptionHandler each serve distinct purposes, allowing you to log, filter, and handle exceptions effectively.

reference: web-api-global-error-handling

API testing is a crucial part of modern software development, ensuring that your applications communicate effectively and reliably with external services. Postman has long been a go-to tool for API testing, with its user-friendly interface and powerful features. However, there are several excellent alternatives available that offer unique advantages. In this article, we’ll explore the 15 best Postman alternatives for API testing along with the advantages of each.

Top 15 API Testing Tools

1) Insomnia

Insomnia is a free, open-source API testing tool known for its intuitive interface and robust features. It offers features such as auto-completion, code generation, and real-time previews of API responses, making it a strong Postman alternative.

Advantages:

• Open-source and free.
• User-friendly interface.
• Supports GraphQL.
• Import and export API definitions.

Official site: https://insomnia.rest/

2) Paw

Paw is a macOS-exclusive API testing tool that provides advanced capabilities like dynamic values, authentication, and environment variables. Its clean and intuitive interface appeals to developers and testers alike.

Advantages:

• Native macOS app.
• Advanced request customization.
• Excellent support for OAuth and JWT.
• Extensive documentation.

Official site: https://paw.cloud/

3) SoapUI

SoapUI is a specialized tool for testing SOAP and REST APIs. It’s a powerful option for those working in environments where SOAP is still prevalent. It offers features like data-driven testing, security testing, and assertion scripting.

Advantages:

• Specialized for SOAP and REST.
• Robust data-driven testing.
• Supports security testing.
• Cross-platform support.

Official site: https://www.soapui.org/

4) Katalon Studio

Katalon Studio is a comprehensive automation testing solution with API testing capabilities. It’s designed for end-to-end testing and offers a wide range of integrations with various testing frameworks.

Advantages:

• All-in-one testing solution.
• GUI-based API testing.
• Integration with popular CI/CD tools.
• Extensive reporting and analytics.

Official site: https://katalon.com/

5) Apigee

Apigee is a Google Cloud product designed for API management and testing. While it’s primarily an API management platform, it offers robust API testing capabilities, making it an excellent choice for organizations heavily invested in the Google Cloud ecosystem.

Advantages:

• Google Cloud integration.
• Scalability and reliability.
• Comprehensive API management features.
• Security and compliance.

Official site: https://docs.apigee.com/

6) Rest-Assured

Rest-Assured is a Java library for testing REST APIs, making it ideal for developers comfortable with Java. It offers a simple and expressive syntax for API testing and supports both JSON and XML.

Advantages:

• Java-based, suitable for Java developers.
• Fluent, expressive API testing syntax.
• Supports JSON and XML.
• Easily integrates with popular testing frameworks.

Official site: https://rest-assured.io/

7) Swagger (OpenAPI)

Swagger, now known as OpenAPI, is a specification for documenting RESTful APIs. While not a testing tool itself, it’s a valuable resource for API testing. Tools like Swagger UI and Postwoman use OpenAPI specifications for testing APIs.

Advantages:

• Standardized API documentation.
• Supports multiple API languages.
• Compatible with various API testing tools.
• Promotes API consistency.

Official site: https://swagger.io/

8) Karate DSL

Karate DSL is an open-source tool for API testing and test automation. It combines API testing and HTTP request mocking capabilities, making it a unique choice for comprehensive API testing.

Advantages:

• Built-in HTTP request mocking.
• Supports BDD-style testing.
• JSON and XML support.
• Easy to learn for non-developers.

Official site: https://www.karatelabs.io/

9) Talend API Tester

Talend API Tester is a user-friendly tool for API testing and validation. It’s designed to simplify the API testing process and offers features like assertions, parameterization, and data-driven testing.

Advantages:

• Simplified API testing.
• GUI-based interface.
• Supports data-driven testing.
• Integration with Talend ETL for data transformation.

Official site: https://www.talend.com/

10) JMeter

Apache JMeter is a popular open-source tool for load testing and performance testing, but it can also be used for API testing. It’s highly extensible and can simulate heavy loads on your API.

Advantages:

• Open-source and free.
• Scalable for load testing.
• Extensive plugin support.
• Supports multiple protocols.

Official site: https://jmeter.apache.org/

11) Dredd

Dredd is a language-agnostic HTTP API testing framework that focuses on testing API documentation against its implementation. It ensures that your API endpoints conform to your API blueprint or OpenAPI specification.

Advantages:

• Tests API documentation against implementation.
• Language-agnostic.
• Command-line interface.
• Automation-friendly.

Official site: https://dredd.org/

12) Tricentis Tosca

Tricentis Tosca is an enterprise-level test automation platform that includes API testing capabilities. It’s a comprehensive solution for end-to-end testing, including API testing and UI testing.

Advantages:

• Comprehensive test automation platform.
• Supports API testing.
• Integrates with CI/CD pipelines.
• Advanced reporting and analytics.

Official site: https://www.tricentis.com/

13) WireMock

WireMock is a flexible HTTP mocking library for API testing. It allows you to simulate HTTP responses from APIs, making it ideal for testing in isolation and during development.

Advantages:

• Mocks HTTP responses.
• Supports custom response scenarios.
• Useful for isolated testing.
• Easily integrates with testing frameworks.

Official site: https://wiremock.org/

14) Runscope

Runscope is an API testing and monitoring platform designed for teams. It offers features like API monitoring, traffic inspection, and integration with various tools and services.

Advantages:

• Team collaboration features.
• API monitoring capabilities.
• Traffic inspection and debugging.
• Integrates with CI/CD pipelines.

Official site: https://www.runscope.com/

15) HttpMaster

HttpMaster is a desktop application for API testing and debugging. It offers features like dynamic parameters, data validation, and advanced response data extraction.

Advantages:

• User-friendly desktop app.
• Supports dynamic parameters.
• Data validation and extraction.
• Automation through command-line interface.

Official site: https://www.httpmaster.net/

Conclusion

You have many options when it comes to choosing an API testing tool. Each of the 15 alternatives mentioned above offers unique advantages, catering to different needs and preferences. Whether you prioritize simplicity, scalability, or specialized features, there’s a Postman alternative that suits your requirements. As the landscape of software development continues to evolve, these tools will remain essential for ensuring the reliability and functionality of your APIs.

To validate a JSON Web Token (JWT) issued by Azure Active Directory B2C (Azure AD B2C) in a .NET Core Web API, you need to configure the authentication middleware to validate the JWT tokens.

Steps to Validate Azure AD B2C Jwt Bearer

Create Web API project in .NET Core

Install Required NuGet Packages

Install the necessary JwtBearer NuGet packages to work with JWT authentication and Azure AD B2C.

Configure Azure B2C JWT Authentication.

In your Startup.cs file, configure JWT authentication in the ConfigureServices and Configure methods:

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;

// ...

public void ConfigureServices(IServiceCollection services)
{
	// Add authentication services
    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
        .AddJwtBearer(options =>
        {
			options.Authority = "AzureAdB2C:IssuerOrAuthorizationUrl";
			options.Audience = "AzureAdB2C:Audience";
			options.Events = new JwtBearerEvents
			{
				//OnAuthenticationFailed = AuthenticationFailed
			};
			
			/* Note:Authority and audience are enough to validate AD B2C Authentication but if your requirement is to validate the Token issuer & SigninKey also then include the below code as well.*/
            options.TokenValidationParameters = new TokenValidationParameters
            {
                ValidateIssuer = true,
                ValidateAudience = true,
                //ValidateLifetime = true,
                ValidateIssuerSigningKey = true,
                ValidIssuer = "AzureAdB2C:IssuerOrAuthorizationUrl",
                ValidAudience = "AzureAdB2C:Audience",
                IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["AzureAdB2C:JwtKey"]))
            };
        });

    // Other ConfigureServices configuration...
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Use authentication middleware
    app.UseAuthentication();

    // Other Configure configuration...
} 

{
  "AzureAdB2C": {
    "IssuerOrAuthorizationUrl": "https://<your-tenant-name>.b2clogin.com/<your-tenant-name>.onmicrosoft.com/<your-policy-name>/v2.0/",
    "Audience": "ecjud59-Your-ClientId-or-AudienceId-e0d02e",
    "JwtKey": "my_secret_key_12345"
  }
}

Authorize API Endpoints

You can now protect your API endpoints by applying the [Authorize] attribute to the controllers or actions you want to secure:

using Microsoft.AspNetCore.Authorization;

[Authorize]
[ApiController]
[Route("api/[controller]")]
public class MyController : ControllerBase
{
    // Controller actions...
}

Your .NET Core rest API is now configured to validate JWT tokens issued by Azure AD B2C.

Testing Azure AD B2C Jwt Bearer

To test the JWT Bearer token authentication, include the JWT token in the Authorization header of your HTTP requests. The header should look like:

Authorization: Bearer <your-JWT-token>

If validation is successful then it will execute the API method else app will throw an exception.

Make sure you have the correct Azure AD B2C configuration values in your application, and ensure that your B2C policies and user flows are set up to issue tokens with the required audience and issuer values.

Handle Claims: You can access user claims (e.g., user’s email, name, etc.) using User.Claims within your API controller actions.

In this article, we’ll walk through the steps to configure Swagger in a Web API with JWT Bearer Authentication to provide comprehensive documentation and testing capabilities while ensuring security.

Prerequisites

Before we look into the configuration process, make sure:
1) You have installed the Swashbuckle NuGet package, which integrates Swagger with your API or .NET Core application.
2) You should have JWT Bearer Authentication set up in your Web API to validate incoming tokens.

Configure Swagger with JWT Bearer Authentication

Now, let’s configure Swagger to work with JWT Bearer Authentication in your .NET Core Web API.

Open your Startup.cs file and add the necessary configurations for Swagger in the ConfigureServices and Configure methods.

using Microsoft.OpenApi.Models;
using System;
using System.IO;
using System.Reflection;


public void ConfigureServices(IServiceCollection services)
{
	// ...

	services.AddSwaggerGen(swagger =>
	{
		//This is to generate the Default UI of Swagger Documentation  
		swagger.SwaggerDoc("v1", new OpenApiInfo
		{
			Version = "v1",
			Title = "My App",
			Description = "About Application"
		});

		// Set the comments path for the Swagger JSON and UI.
		var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
		var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
		swagger.IncludeXmlComments(xmlPath);                
	});

	//To Enable authorization using Swagger (JWT)
	swagger.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme()
	{
		Name = "Authorization",
		Type = SecuritySchemeType.ApiKey,
		Scheme = "Bearer",
		BearerFormat = "JWT",
		In = ParameterLocation.Header,
		Description = "JWT Authorization header using the Bearer scheme. \r\n\r\n Enter 'Bearer' [space] and then your token in the text input below.\r\n\r\nExample: \"Bearer 12345abcdef\"",
	});
	swagger.AddSecurityRequirement(new OpenApiSecurityRequirement
	{
		{
			  new OpenApiSecurityScheme
				{
					Reference = new OpenApiReference
					{
						Type = ReferenceType.SecurityScheme,
						Id = "Bearer"
					}
				},
				new string[] {}
		}
	});
}


public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
	// ...

	// Enable middleware to serve generated Swagger as a JSON endpoint.
	app.UseSwagger();

	// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),
	// specifying the Swagger JSON endpoint.
	app.UseSwaggerUI(c =>
	{
		c.SwaggerEndpoint("/swagger/v1/swagger.json", "Your API Name v1");
	});
} 

Secure Your API

Make sure your API controllers and actions are protected using JWT Bearer Authentication. You can use the [Authorize] attribute on specific controllers or actions that require authentication.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class YourController : ControllerBase
{
    [HttpGet]
    [Authorize]
    public IActionResult Get()
    {
        // Your action logic
    }
} 

Test Your API with Swagger JWT Bearer Authentication

1. Start your .NET Core Web API project.
2. Navigate to the Swagger UI by accessing /swagger in your web application (e.g., http://localhost:5000/swagger).
3. Click on the “Authorize” button in the top right corner of the Swagger UI.
   
   
   
4. In the “Authorization” dialog, enter your JWT token in the following format: Bearer YOUR_JWT_TOKEN.
   
   
   
5. Click “Authorize” to authenticate.
6. Explore the available API endpoints, provide any required input data, and click “Execute” to test your API.

Swagger will include the JWT token in the “Authorization” header automatically, allowing you to test the secured endpoints.

Swagger is a powerful tool for documenting and testing APIs in a user-friendly and interactive way. It allows developers to create interactive API documentation, making it easier for both developers and consumers to understand and interact with the API. While there are tools and packages that automate Swagger integration in .NET Core, sometimes you may want to implement it manually for more control over the configuration and customization. In this article, we will guide you through the manual implementation of Swagger in a .NET Core application.

Swagger implementation in .NET Core Web API Project

The following steps describe the configuration of Swagger docs in the Web API project.

Step 1: Install Required Packages

To begin, open your .NET Core project in Visual Studio or Visual Studio Code and install the necessary NuGet packages for Swagger integration. You need Swashbuckle.AspNetCore package. You can install these packages using the NuGet Package Manager or Package Manager Console:

option 1) Console Command

dotnet add package Swashbuckle.AspNetCore

Note: This command will add all packages available under Swashbuckle.AspNetCore.
Recommendation – Install only necessary packages from Nuget Manager

option 2) Nuget Package manager recommended

You can install only the required packages needed for Swagger Web API documentation from Nuget Package Manager

Step 2: Configure Swagger in Startup.cs

Open your project’s Startup.cs file, where you configure your application’s services and middleware. Add the following code to configure Swagger:

using Microsoft.OpenApi.Models;
using System;
using System.IO;
using System.Reflection;


public void ConfigureServices(IServiceCollection services)
{
	// ...

	services.AddSwaggerGen(swagger =>
	{
		//This is to generate the Default UI of Swagger Documentation  
		swagger.SwaggerDoc("v1", new OpenApiInfo
		{
			Version = "v1",
			Title = "My App",
			Description = "About Application"
		});

		// Set the comments path for the Swagger JSON and UI.
		var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
		var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
		swagger.IncludeXmlComments(xmlPath);                
	});
}


public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
	// ...

	// Enable middleware to serve generated Swagger as a JSON endpoint.
	app.UseSwagger();

	// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),
	// specifying the Swagger JSON endpoint.
	app.UseSwaggerUI(c =>
	{
		c.SwaggerEndpoint("/swagger/v1/swagger.json", "Your API Name v1");
	});
} 

In the code above, you are configuring Swagger in the ConfigureServices and Configure methods of your Startup.cs file. Make sure to replace “Your API Name” with the actual name of your API.

Step 3: Define API Documentation

Now, let’s add documentation to your API endpoints. Decorate your controllers and actions with XML comments that Swagger will use to generate documentation. For example:

/// <summary>
/// This is a sample controller for managing products.
/// </summary>
[ApiController]
[Route("api/[controller]")]
public class WeatherForecastController : ControllerBase
{
    /// <summary>
    /// Gets a list of all WeatherForecast.
    /// </summary>
    /// <returns>A list of WeatherForecast.</returns>
    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        // Your action code here
    }
    // Add similar XML comments for other actions
} 

After adding descriptions to the APIs, go to the Swagger URL and check the documentation.

Step 4: Generate Swagger Documentation

With the configuration and documentation in place, you can now generate Swagger documentation by running your application. Build and run your .NET Core application, and navigate to URL https://localhost:<port>/swagger or https://localhost:<port>/swagger/index.html in your browser. You should see the Swagger UI, where you can interactively explore and test your API.

If you want to launch the Swagger URL by default then change the value of launchUrl in launchSettings.json file, See the screenshot below:

Troubleshooting

You might get System.IO.FileNotFoundException error – “Could not find file ‘filePath/appfilename.xml‘” as shown in the below screenshot.

XML comments file could not be found – Swagger

In such case, you can enable DocumentationFile property, manually. There are two ways to do it:

Option 1) Go to .csproj project file and add the GenerateDocumentationFile tag within PropertyGroup:

<PropertyGroup>
	<GenerateDocumentationFile>true</GenerateDocumentationFile> 
</PropertyGroup>

Option 2) If you want to avoid editing the .csproj manually then right-click on app >> click on Properties >> Select Build and tick XML documentation file checkbox under the output section. See the screenshot below:

It will add the DocumentationFile tag in PropertyGroup automatically.

In this post, we will see how to convert or export DataSet (DataTable) to an Excel file using OpenXml and C# code (Web API, .Net Core). OpenXML SDK is a free, open-source NuGet package from Microsoft that provides tools to work with Office Word, Excel, and PowerPoint documents programmatically.

We will cover, how to:

• Generating one or more Sheets in a single Excel file depending on DataTables in a DataSet
• Customizing cell style (Stylesheet): Cell Formats (Fonts, Border, Fill) and Alignments (Wrap Text, Vertical, Horizontal)
• Resize each Column’s width

Steps to generate excel sheet

1. Install OpenXml SDK Nuget Package

Create a new Web API project and add the OpenXml package.

2. Create API to download excel file

Add the below Get API method in the Controller class, so that the generated excel file can be downloaded. The Swagger tool will be used to test this API.

[HttpGet]
public IActionResult DownloadExcelFile()
{
	DataSet dataSet = new DataSet();
	//Configure DB connection string in appsetting.json
	using (SqlConnection connection = new SqlConnection(_conn))
	{
		/* for multi Sheet either enter multiple 'Select' statement as inline query
		or get multiple result set from Stored Procedure from DB*/
		SqlDataAdapter adapter = new SqlDataAdapter
		{
			SelectCommand = new SqlCommand("Select * from Products", connection)
		};
		adapter.Fill(dataSet);
	}
	return File(Helper.ExportToExcelDownload(dataSet), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "YourFileName.xls");
} 

3. Export to Excel C# Code

Create a static class called “Helper.cs” and add a static method to generate one or multiple sheets in the excel file from DataSet.
Simply, copy & paste the entire code given below. That’s it, done.

Just call ExportToExcelDownload() method and pass the DataSet result as input. It will create one or more Sheets based on the number of DataTables in the DataSet and return the fully formed Excel file as bytes.

Download this Project (configure DB and inline query before running this project).
Also, read how to change the Cell format – explained below.

Make sure all the necessary namespaces are added.
Scroll down to the output screenshot

using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;
using System;
using System.Data;
using System.Globalization;
using System.IO; 

public static class Helper
{
	private const string noRecordsToDisplay = "No records to display";
	
	public static byte[] ExportToExcelDownload(DataSet dataSet)
	{
		byte[] byteResult = null;
		if (dataSet == null) { return byteResult; }

		if (dataSet.Tables.Count > 0)
		{
			using (MemoryStream stream = new MemoryStream())
			{
				using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Create(stream, SpreadsheetDocumentType.Workbook))
				{
					// Add a WorkbookPart to the document.
					WorkbookPart workbookpart = AddWorkbookPart(spreadsheetDocument);
					AddSheet(spreadsheetDocument, out Sheets sheets, out uint currentSheetID);
					AddNewPartStyle(workbookpart);

					int rowIndexCount = 1;

					foreach (DataTable dt in dataSet.Tables)
					{
						// Add a WorksheetPart to the WorkbookPart.
						WorksheetPart worksheetPart = workbookpart.AddNewPart<WorksheetPart>();
						worksheetPart.Worksheet = new Worksheet();
						Columns columns = SetDefaultColumnWidth();
						worksheetPart.Worksheet.Append(columns);

						SheetData sheetData = new SheetData();
						worksheetPart.Worksheet.AppendChild(sheetData);

						// Append a new worksheet and associate it with the workbook.
						Sheet sheet = new Sheet()
						{
							Id = spreadsheetDocument.WorkbookPart.GetIdOfPart(worksheetPart),
							SheetId = currentSheetID,
							Name = string.IsNullOrWhiteSpace(dt.TableName) ? "Sheet" + currentSheetID : dt.TableName
						};

						if (dt.Rows.Count == 0)
						{
							//if table rows count is 0, create Excel Sheet with default message
							CreateDefaultWithMessage(rowIndexCount, sheetData);
						}
						else
						{
							int numberOfColumns = dt.Columns.Count;
							string[] excelColumnNames = new string[numberOfColumns];

							//Create Header
							Row SheetrowHeader = CreateHeader(rowIndexCount, dt, numberOfColumns, excelColumnNames);
							sheetData.Append(SheetrowHeader);
							++rowIndexCount;

							//Create Body
							rowIndexCount = CreateBody(rowIndexCount, dt, sheetData, excelColumnNames);
						}

						sheets.Append(sheet);

						++currentSheetID;

						rowIndexCount = 1;
					}

					workbookpart.Workbook.Save();

					// Close the document.
					//spreadsheetDocument.Close();

				}

				stream.Flush();
				stream.Position = 0;

				byteResult = new byte[stream.Length];
				stream.Read(byteResult, 0, byteResult.Length);
			}
		}
		return byteResult;
	}

	//Customize column width
	private static Columns SetDefaultColumnWidth()
	{
		Columns columns = new Columns();
		//width of 1st Column
		columns.Append(new Column() { Min = 1, Max = 1, Width = 25, CustomWidth = true });
		//with of 2st Column
		columns.Append(new Column() { Min = 2, Max = 2, Width = 50, CustomWidth = true });
		//set column width from 3rd to 400 columns
		columns.Append(new Column() { Min = 3, Max = 400, Width = 10, CustomWidth = true });
		return columns;
	}

	private static void AddNewPartStyle(WorkbookPart workbookpart)
	{
		WorkbookStylesPart stylePart = workbookpart.AddNewPart<WorkbookStylesPart>();
		stylePart.Stylesheet = GenerateStylesheet();
		stylePart.Stylesheet.Save();
	}

	private static void AddSheet(SpreadsheetDocument spreadsheetDocument, out Sheets sheets, out uint currentSheetID)
	{
		sheets = spreadsheetDocument.WorkbookPart.Workbook.AppendChild(new Sheets());
		currentSheetID = 1;
	}

	private static WorkbookPart AddWorkbookPart(SpreadsheetDocument spreadsheetDocument)
	{
		WorkbookPart workbookpart = spreadsheetDocument.AddWorkbookPart();
		workbookpart.Workbook = new Workbook();
		return workbookpart;
	}

	private static void CreateDefaultWithMessage(int rowIndexCount, SheetData sheetData)
	{
		Row Sheetrow = new Row() { RowIndex = Convert.ToUInt32(rowIndexCount) };
		Cell cellHeader = new Cell() { CellReference = "A1", CellValue = new CellValue(noRecordsToDisplay), DataType = CellValues.String };
		cellHeader.StyleIndex = 1;

		Sheetrow.Append(cellHeader);
		sheetData.Append(Sheetrow);
	}

	private static int CreateBody(int rowIndexCount, DataTable dt, SheetData sheetData, string[] excelColumnNames)
	{
		for (int i = 0; i < dt.Rows.Count; i++)
		{
			Row Sheetrow = new Row() { RowIndex = Convert.ToUInt32(rowIndexCount) };
			for (int j = 0; j < dt.Columns.Count; j++)
			{
				// insert value in cell with dataType (String, Int, decimal, datatime)
				Sheetrow.Append(GetCellWithDataType(excelColumnNames[j] + rowIndexCount, dt.Rows[i][j], dt.Columns[j].DataType));
			}
			sheetData.Append(Sheetrow);
			++rowIndexCount;
		}

		return rowIndexCount;
	}

	private static Row CreateHeader(int rowIndexCount, DataTable dt, int numberOfColumns, string[] excelColumnNames)
	{
		Row SheetrowHeader = new Row() { RowIndex = Convert.ToUInt32(rowIndexCount) };
		for (int n = 0; n < numberOfColumns; n++)
		{
			excelColumnNames[n] = GetExcelColumnName(n);

			Cell cellHeader = new Cell() { CellReference = excelColumnNames[n] + rowIndexCount, CellValue = new CellValue(dt.Columns[n].ColumnName), DataType = CellValues.String };
			cellHeader.StyleIndex = 2;
			SheetrowHeader.Append(cellHeader);
		}

		return SheetrowHeader;
	}

	private static string GetExcelColumnName(int columnIndex)
	{
		if (columnIndex < 26)
		{
			return ((char)('A' + columnIndex)).ToString();
		}

		char firstChar = (char)('A' + (columnIndex / 26) - 1);
		char secondChar = (char)('A' + (columnIndex % 26));

		return string.Format(CultureInfo.CurrentCulture, "{0}{1}", firstChar, secondChar);
	}

	private static Stylesheet GenerateStylesheet()
	{
		Fonts fonts = GenerateFonts();
		Fills fills = GenerateFills();
		Borders borders = GenerateBorders();
		CellFormats cellFormats = GenerateCellFormats();
		Column column = GenerateColumnProperty();
		Stylesheet styleSheet = new Stylesheet(fonts, fills, borders, cellFormats, column);

		return styleSheet;
	}

	private static Column GenerateColumnProperty()
	{
		return new Column
		{
			Width = 100,
			CustomWidth = true
		};
	}

	private static CellFormats GenerateCellFormats()
	{
		CellFormats cellFormats = new CellFormats(
			// default - Cell StyleIndex = 0 
			new CellFormat(new Alignment() { WrapText = true, Vertical = VerticalAlignmentValues.Top }),

			// default2 - Cell StyleIndex = 1
			new CellFormat(new Alignment() { WrapText = true, Vertical = VerticalAlignmentValues.Top }) { FontId = 0, FillId = 0, BorderId = 1, ApplyBorder = true },

			// header - Cell StyleIndex = 2
			new CellFormat(new Alignment() { WrapText = true, Vertical = VerticalAlignmentValues.Top }) { FontId = 1, FillId = 0, BorderId = 1, ApplyFill = true },

			// DateTime DataType - Cell StyleIndex = 3
			new CellFormat(new Alignment() { Vertical = VerticalAlignmentValues.Top }) { FontId = 0, FillId = 0, BorderId = 1, ApplyBorder = true, NumberFormatId = 15, ApplyNumberFormat = true },

			// int,long,short DataType - Cell StyleIndex = 4
			new CellFormat(new Alignment() { WrapText = true, Vertical = VerticalAlignmentValues.Top }) { FontId = 0, FillId = 0, BorderId = 1, ApplyBorder = true, NumberFormatId = 1 },

			// decimal DataType  - Cell StyleIndex = 5
			new CellFormat(new Alignment() { WrapText = true, Vertical = VerticalAlignmentValues.Top }) { FontId = 0, FillId = 0, BorderId = 1, ApplyBorder = true, NumberFormatId = 2 }
			);
		return cellFormats;
	}

	private static Borders GenerateBorders()
	{
		Borders borders = new Borders(
			// index 0 default
			new Border(),

			// index 1 black border
			new Border( 
				new LeftBorder(new Color() { Auto = true }) { Style = BorderStyleValues.Thin },
				new RightBorder(new Color() { Auto = true }) { Style = BorderStyleValues.Thin },
				new TopBorder(new Color() { Auto = true }) { Style = BorderStyleValues.Thin },
				new BottomBorder(new Color() { Auto = true }) { Style = BorderStyleValues.Thin },
				new DiagonalBorder())
			);
		return borders;
	}

	private static Fills GenerateFills()
	{
		Fills fills = new Fills(
			// Index 0
			new Fill(new PatternFill() { PatternType = PatternValues.None }),

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

			// Index 2 - header
			new Fill(new PatternFill(new ForegroundColor { Rgb = new HexBinaryValue() { Value = "66666666" } }) { PatternType = PatternValues.Solid })  
			);
		return fills;
	}

	private static Fonts GenerateFonts()
	{
		Fonts fonts = new Fonts(
			// Index 0 - default
			new Font( 
				new FontSize() { Val = 10 },
				new FontName() { Val = "Arial Unicode" }
			),

			// Index 1 - header
			new Font( 
				new FontSize() { Val = 10 },
				new Bold()//,

			//new Color() { Rgb = "FFFFFF" }

			));
		return fonts;
	}

	private static Cell GetCellWithDataType(string cellRef, object value, Type type)
	{
		if (type == typeof(DateTime))
		{
			Cell cell = new Cell()
			{
				DataType = new EnumValue<CellValues>(CellValues.Number),
				StyleIndex = 3
			};

			if (value != DBNull.Value)
			{
				System.Globalization.CultureInfo cultureinfo = new System.Globalization.CultureInfo("en-US");
				DateTime valueDate = (DateTime)value;
				string valueString = valueDate.ToOADate().ToString(cultureinfo);
				CellValue cellValue = new CellValue(valueString);
				cell.Append(cellValue);
			}

			return cell;
		}
		if (type == typeof(long) || type == typeof(int) || type == typeof(short))
		{
			Cell cell = new Cell() { CellReference = cellRef, CellValue = new CellValue(value.ToString()), DataType = CellValues.Number };
			cell.StyleIndex = 4;
			return cell;
		}
		if (type == typeof(decimal))
		{
			Cell cell = new Cell() { CellReference = cellRef, CellValue = new CellValue(value.ToString()), DataType = CellValues.Number };
			cell.StyleIndex = 5;
			return cell;
		}
		else
		{
			Cell cell = new Cell() { CellReference = cellRef, CellValue = new CellValue(value.ToString()), DataType = CellValues.String };
			cell.StyleIndex = 1;
			return cell;
		}
	}
} 

Run the application and test export to excel functionality from Swagger.

Execute the Get Excel API

The below screenshot shows a successful API response code-200 with downloadable Excel file –SampleExcel.xls

Output

You might receive a ‘trust source’ warning popup message while opening the downloaded file. Just click on the ‘Yes’ button to open the excel file.

That’s all about generating the multi-sheet excel file from DataSet.

Now, we will see how to format Header or Body Cell like wrapping text, changing fonts, filling colors to a cell, resizing the column width, and applying borders from code.

How to work with style Index in Open XML?

To apply different styles to a cell, create a set of Cell formats or ‘StyleIndex’ and assign that particular format while creating a Cell. For example, if you want to fill color for a Header Cell then you need to define two indexes or formats –

1. Style Index 0 – ‘no fill’ as default (white color) which applies to common body Cell
2. Style Index 1 – fill with light grey color for Header Cell

While creating a Header apply ‘Index 1’ to the cell property and for normal Cells use ‘Index 0’.
So in this way, all Cell styles or formats are defined in this sample code. The below screenshots shows the code flow of Cell StyleIndex.

Cell StyleIndex Code Flow – Explanation

1. Create Cell Formats – StyleIndex

First, create different Cell formats. We have created six cell formats, refer GenerateCellFormats() method in the example above:

1. StyleIndex = 0 – Default without border
2. StyleIndex = 1 – Default with border
3. StyleIndex = 2 – for Header cell
4. StyleIndex = 3 – DateTime data type cell
5. StyleIndex = 4 – Integer data type cell
6. StyleIndex = 5 – decimal data type cell

Apply the correct style index when creating a cell. Please find the following lines in the code:
a) CellFormats GenerateCellFormats() – Method
// header – Cell StyleIndex = 2
new CellFormat(new Alignment() { WrapText = true, Vertical = VerticalAlignmentValues.Top }) { FontId = 1, FillId = 0, BorderId = 1, ApplyFill = true },
b) apply style index to the header cell
cellHeader.StyleIndex = 2;

2. Create Indexes for Font, Border, Fill

FontId, FillId and BorderId are defined with some index value, in each CellFormats. So, you have to define a set of styles for each attribute.

i. Defining Font Index

Refer GenerateFonts() method in code – defines two indexes: one for the normal cell (default) and another for the header cell. See the highlighted text above – FontId = 1

ii. Define Borders

Refer GenerateBorders() method in code – defines two indexes: one without borderline and another with borderline. See the highlighted text above – BorderId = 1,

iii. Define Fill Colors

Refer GenerateFills() method in code – defines three indexes.
See the highlighted text above – FillId = 0. It applies the default color to a cell.

How to Customize Column Width – OpenXml

Refer SetDefaultColumnWidth() method in code – defines width size up to 400 columns. ‘Min’ & ‘Max’ is a column range. As shown in the screenshot below, the first column’s Min & Max value is 1 which means the width size 25 is applicable only to the 1^st column.
In the same way, width size 50 is for the 2^nd column.
If you want to assign the same width value to more than one column then increase the Max property value. Width column size 10 is applied from the 3^rd to 400^th columns in the code.

Hope you liked it! Happy Coding!! Thanks