Building Custom Power Platform Solutions with Advanced Connectors and C# Integration

The Microsoft Power Platform, with its tools like PowerApps, Power Automate, and Power BI, empowers organizations to create low-code, high-efficiency solutions. But what happens when the platform needs to connect to external services that aren't pre-configured? This is where custom connectors shine. Developers can extend the functionality of the Power Platform by creating custom connectors to access third-party APIs or enterprise services—and using C# makes this process even more robust.

What Are Custom Connectors?

Custom connectors allow the Power Platform to communicate with APIs that are not available out of the box. This provides businesses the flexibility to integrate and automate processes across systems, enabling seamless workflows tailored to specific needs. By building a custom connector, you can securely call API endpoints, pass parameters, retrieve data, and respond to triggers.

Why Use C# for Custom Connectors?

While Power Platform offers its own interface for creating connectors, incorporating C# brings several benefits:

• Fine-grained control: C# allows for better handling of API requests and responses, providing control over authentication, serialization, and error handling.
• Ease of scalability: Connectors written in C# are more robust and can handle complex scenarios with larger datasets.
• Reusable logic: The logic written in C# can be reused across different PowerApps workflows and functions.

Getting Started: How to Build a Power Platform Custom Connector with C Sharp

Step 1: Configure the API

Ensure that the API you're accessing is well-documented, available over HTTPS, and ready for integration. You'll need the endpoint URLs, authentication details, and the necessary parameters to make requests.

Step 2: Create a Custom Connector in Power Platform

1. Navigate to the PowerApps or Power Automate portal and go to Custom Connectors.
2. Click on + New Custom Connector and select Import from Postman Collection or Create from Blank.
3. Define the name, description, and logo for your connector.

Step 3: Code the API Proxy with C

Using ASP.NET Core, you can write a proxy service to handle requests between the Power Platform and the external API. Here's an example:

using Microsoft.AspNetCore.Mvc;
using System.Net.Http;
using System.Threading.Tasks;

[Route("api/[controller]")]
[ApiController]
public class ExternalApiProxyController : ControllerBase
{
    private readonly HttpClient _httpClient;

    public ExternalApiProxyController(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    [HttpGet("data")]
    public async Task<IActionResult> GetDataFromApi()
    {
        var apiUrl = "https://api.external-service.com/data";
        var response = await _httpClient.GetAsync(apiUrl);

        if (!response.IsSuccessStatusCode)
        {
            return StatusCode((int)response.StatusCode, response.Content.ReadAsStringAsync());
        }

        var data = await response.Content.ReadAsStringAsync();
        return Ok(data);
    }
}

This proxy handles HTTP GET requests to an external API, providing a secure layer for API integration.

Step 4: Deploy and Configure Your API Proxy

Deploy your C# code to an Azure App Service or other cloud hosting platforms. Ensure that your API has HTTPS enabled, and document the endpoints for use within Power Platform.

Step 5: Define Connector Authentication

Secure your connector by setting up authentication options, such as OAuth 2.0 or API keys. This ensures that only authorized users can access sensitive data.

Step 6: Test Your Custom Connector

Before deploying, use the test functionality within PowerApps or Power Automate to validate your connector. Check that the requests and responses match the expected outputs.

Benefits of Custom Connectors in Business Solutions

1. Enhanced Productivity: Automating data flows and third-party service interactions allows teams to focus on higher-value tasks.
2. Seamless Integration: Connectors bridge the gap between disparate systems, ensuring consistent data exchange.
3. Secure Communication: C# enhances security with robust authentication and error-handling mechanisms.

Closing Thoughts

Custom connectors are a powerful way to expand the capabilities of the Microsoft Power Platform, and integrating them with C# ensures scalability, security, and efficiency. Whether you're building solutions for internal processes or external integrations, mastering custom connectors opens new doors for innovation.

By leveraging the combined capabilities of Power Platform and C#, developers can design smarter, faster, and more tailored solutions to tackle unique business challenges.

Below, you'll find additional C# examples to expand the custom connector functionality and a step-by-step guide to integrate and deploy it within a Canvas app.

Additional Code Example: POST Request with Authentication

You might need to handle authenticated API requests with POST methods. Here’s an example:

using Microsoft.AspNetCore.Mvc;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

[Route("api/[controller]")]
[ApiController]
public class SecureApiProxyController : ControllerBase
{
    private readonly HttpClient _httpClient;

    public SecureApiProxyController(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    [HttpPost("submit-data")]
    public async Task<IActionResult> SubmitData([FromBody] object payload)
    {
        var apiUrl = "https://api.external-service.com/submit";
        var apiKey = "YourAPIKeyHere";

        var jsonContent = JsonConvert.SerializeObject(payload);
        var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");

        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");

        var response = await _httpClient.PostAsync(apiUrl, content);

        if (!response.IsSuccessStatusCode)
        {
            return StatusCode((int)response.StatusCode, await response.Content.ReadAsStringAsync());
        }

        var responseData = await response.Content.ReadAsStringAsync();
        return Ok(responseData);
    }
}

What This Code Does:

• API Authentication: Adds a Bearer token for secure access.
• POST Method: Sends JSON data to an external API endpoint.
• Error Handling: Provides appropriate status codes and messages.

---

Step-by-Step Guide: Deploy Custom Connector and Use It in a Canvas App

1. Publish the API Proxy

1. Host the C# API Proxy:

   • Deploy your proxy to a cloud service such as Azure App Service or AWS.
   • Ensure HTTPS is enabled for secure communication.

2. Test the API Endpoints:

   • Use Postman or a similar tool to verify the API proxy's requests and responses.

---

2. Create a Custom Connector

1. Set Up in Power Platform:

   • Navigate to the Power Platform Admin Center, select Custom Connectors, and click + New Custom Connector.

2. Define the API Proxy:

   • Use the HTTPS URL of your deployed C# API as the base URL.
   • Add endpoints for GET or POST (e.g., /data, /submit-data) along with request parameters and headers.

3. Authentication Settings:

   • Add OAuth 2.0 or API Key details for secure access.

4. Test Your Custom Connector:

   • Use the test functionality in the Custom Connector interface to validate the API interactions.

---

3. Integrate with a Canvas App

1. Add the Custom Connector:

   • In PowerApps Studio, go to Data > Add Data Source, and select your Custom Connector.

2. Use the Connector in the App:

   • Add a button and assign an action, such as calling the API endpoint.

3. Example Expression:
   Use the following formula to call the custom connector:
   

   Set(response, YourCustomConnector.GetDataFromApi())

This stores the API response in a variable called response.

1. Display Data in the App:

   • Use a gallery or label to show response contents:

    response.DataField
   

---

4. Test and Deploy

1. Preview the App:

   • Ensure the app successfully retrieves data using the custom connector.

2. Publish:

   • Save and publish the app, making it available for users in your organization.

---

By combining your custom connector's enhanced API functionality with Power Platform’s low-code environment, you can create powerful, tailored applications that drive efficiency and innovation!