Integrating GPT-4 in C# Applications Using Azure OpenAI Services

dotnet new console -n AzureGPTIntegration
cd AzureGPTIntegration

{
  "AzureOpenAI": {
    "Endpoint": "https://your-resource.openai.azure.com/",
    "ApiKey": "your-api-key",
    "DeploymentName": "gpt4-dev",
    "ApiVersion": "2024-02-15-preview"
  }
}

var builder = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json", optional: false)
    .AddEnvironmentVariables();

var configuration = builder.Build();

using System.Net.Http.Headers;
using System.Text.Json;
using System.Text;

public class AzureOpenAIService
{
    private readonly HttpClient _client;
    private readonly string _endpoint;
    private readonly string _apiKey;
    private readonly string _deploymentName;
    private readonly string _apiVersion;

    public AzureOpenAIService(IConfiguration configuration)
    {
        _endpoint = configuration["AzureOpenAI:Endpoint"];
        _apiKey = configuration["AzureOpenAI:ApiKey"];
        _deploymentName = configuration["AzureOpenAI:DeploymentName"];
        _apiVersion = configuration["AzureOpenAI:ApiVersion"];

        _client = new HttpClient
        {
            BaseAddress = new Uri(_endpoint)
        };
        _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _apiKey);
    }

    public async Task<string> GetCompletionAsync(string prompt)
    {
        var uri = $"openai/deployments/{_deploymentName}/chat/completions?api-version={_apiVersion}";

        var requestBody = new
        {
            messages = new[]
            {
                new { role = "system", content = "You are a helpful assistant." },
                new { role = "user", content = prompt }
            },
            temperature = 0.7,
            max_tokens = 1000
        };

        var json = JsonSerializer.Serialize(requestBody);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await _client.PostAsync(uri, content);
        response.EnsureSuccessStatusCode();

        var result = await response.Content.ReadAsStringAsync();
        var document = JsonDocument.Parse(result);
        var message = document.RootElement
            .GetProperty("choices")[0]
            .GetProperty("message")
            .GetProperty("content")
            .GetString();

        return message;
    }
}

You can process the responses by,

• Extracting text
• Logging for audit
• Displaying in UI

Example Main method.

class Program
{
    static async Task Main(string[] args)
    {
        var config = new ConfigurationBuilder()
            .AddJsonFile("appsettings.json")
            .Build();

        var service = new AzureOpenAIService(config);

        while (true)
        {
            Console.Write("You: ");
            var input = Console.ReadLine();

            if (input.ToLower() == "exit") break;

            var output = await service.GetCompletionAsync(input);
            Console.WriteLine("GPT-4: " + output);
        }
    }
}

Common Use Cases with GPT-4 and C#

Here are some business-ready examples.

a. Summarization

await service.GetCompletionAsync("Summarize the following article in 5 points..."); 

b. Code Generation

await service.GetCompletionAsync("Generate C# code for a REST API controller with GET and POST endpoints."); 

c. Sentiment Analysis

await service.GetCompletionAsync("What is the sentiment of this customer feedback: 'The delivery was late and the box was damaged.'"); 

d. Natural Language SQL

await service.GetCompletionAsync("Convert this request into SQL: Show me all orders from last month."); 

Exception Handling and Logging (Best practices)

try
{
    var result = await service.GetCompletionAsync(prompt);
    Console.WriteLine(result);
}
catch (HttpRequestException ex)
{
    Console.WriteLine("Network error: " + ex.Message);
}
catch (JsonException ex)
{
    Console.WriteLine("Parsing error: " + ex.Message);
}
catch (Exception ex)
{
    Console.WriteLine("Unknown error: " + ex.Message);
}

Security Considerations

When integrating Azure OpenAI into your C# applications, securing your credentials and monitoring usage are critical. A few core best practices should always be followed to ensure your application is secure, maintainable, and compliant:

• Avoid Hardcoding API Keys: Never embed your API keys directly in source code. Hardcoding secrets exposes them to version control systems (like Git) and makes them vulnerable to leaks. Instead, use configuration files for development and secure environment variables or managed services in production.
• Use Azure Key Vault to Store Secrets: Azure Key Vault is a secure cloud service designed to safeguard cryptographic keys and secrets. You can store your OpenAI API key in Key Vault and access it securely from your application using Azure SDKs or Managed Identity. This eliminates the need to expose sensitive data in app settings or deployment pipelines.
• Enable Rate Limiting and Quotas: To prevent abuse, accidental overuse, or denial-of-service scenarios, configure rate limits and consumption quotas in your Azure OpenAI deployment. Azure provides configurable throttling that helps protect both the model and your application from unexpected spikes in usage.
• Audit API Usage in Azure Metrics: Regularly monitor and audit your application’s usage of the Azure OpenAI API through Azure Monitor. You can view metrics such as request volume, latency, error rates, and more. This insight allows you to identify anomalies, track user behavior, and optimize performance while staying within your cost limits.

Optimization Tips

To get the most out of your GPT-4 integration using Azure OpenAI and C#, it’s important to tune your request parameters and application architecture for performance, cost-efficiency, and responsiveness. Below are some best practices that can significantly enhance your application’s performance.

• Use max_tokens Wisely: The max_tokens parameter defines the maximum length of the output generated by the model. Setting it too high can lead to unnecessarily long responses, increased latency, and higher usage costs. Tailor the value based on your use case—for example, use lower values for simple classification tasks and higher values for document summarization or code generation.
• Control Randomness with temperature and top_p: These parameters influence the creativity of the model's output. temperature (ranging from 0 to 1) controls the randomness—lower values make the output more deterministic, while higher values produce more diverse results. top_p (nucleus sampling) controls the probability mass of tokens considered. For stable business logic, keep the temperature around 0.2–0.4; for creative writing or brainstorming, you might use 0.7–0.9. Fine-tuning these can balance creativity and reliability.
• Reuse HttpClient Instances: Instantiating HttpClient for every request is a common anti-pattern that can exhaust system resources. Instead, create and reuse a single HttpClient instance throughout the lifecycle of your service. This approach reduces socket exhaustion and improves throughput, especially in high-traffic scenarios or when calling the Azure OpenAI endpoint frequently.
• Cache Frequent Results Using MemoryCache: If your application frequently sends repeated prompts or requests for the same type of content (e.g., FAQs, template-based summaries), consider caching the results using MemoryCache. This minimizes redundant API calls, reduces latency, and helps you stay within quota limits. Implement expiration policies to ensure the freshness of dynamic content.

Future Extensions

This service can be integrated with,

a. ASP.NET MVC / Web API.

Wrap the service as a controller and expose it via endpoints.

[HttpPost("ask")] 
public async Task<IActionResult> Ask([FromBody] string prompt) 
{ 
   var response = await _gptService.GetCompletionAsync(prompt); 
   return Ok(response); 
} 

b. Blazor WebAssembly

Call the GPT-4 service via HttpClient using a backend API.

c. WinForms/WPF

Update the UI in real time with GPT-4 outputs.

Conclusion

Integrating GPT-4 using Azure OpenAI Service and C# unlocks the potential to build intelligent, human-like interactions directly into the applications. Whether you're creating chatbots that converse naturally, document processors that summarize and extract insights, or developer tools that generate and analyze code, GPT-4 provides a powerful foundation for transforming static workflows into dynamic, AI-driven experiences.

The entire development cycle from provisioning the Azure OpenAI resource, deploying the GPT-4 model, and securely managing secrets, to building a scalable and reusable C# service layer—has been designed with enterprise readiness in mind. Azure ensures compliance, observability, and governance, while C# offers the robustness and flexibility to meet diverse business requirements.

By following best practices for security, performance optimization, and resource management, your GPT-4-powered application can scale reliably while delivering high-value, real-time intelligence to users. Whether you're developing internal tools or customer-facing applications, this integration approach is not only technically sound it’s also production-ready and future-proof.