Multi-Tier Integration Service

C# Service for integrating multi-tier applications

Updated: 03 September 2023

For applications that span multiple tiers or make use of a separate data accesss and web application layers a generic integration service can be used to communicate between tiers

Service Definition

The service enables you to call controllers on the underlying tier by their route, provided that complex objects are supplied in the request body where needed

1
public class IntegrationService
2
{
3
private string _apiBaseUrl;
4
private WebProxy _proxy;
5
6
public IntegrationService(string apiBaseUrl, WebProxy proxy = null)
7
{
8
_apiBaseUrl = apiBaseUrl;
9
_proxy = proxy;
10
}
11
12
/// <summary>
13
/// Creates a new HttpClient instance that can be used to make HTTP requests to the API endpoint with the endpoint and proxy precofigured
14
/// Supports basic HTTP methods and configurations. Essentially enables client to call a function on another application's route with
15
/// params as a single POST DTO if necessary
16
/// </summary>
17
/// <returns></returns>
18
public HttpClient GetClient()
19
{
20
HttpClient client;
21
22
if (_proxy != null)
23
{
24
var handler = new HttpClientHandler()
25
{
26
Proxy = _proxy
27
};
28
client = new HttpClient(handler);
29
}
30
else
31
{
32
client = new HttpClient();
33
}
34
35
client.BaseAddress = new Uri(_apiBaseUrl);
36
37
return client;
38
}
39
40
#region GET Methods
41
public async Task<string> Get(string path)
42
{
43
using (var client = GetClient())
44
{
45
var response = await client.GetStringAsync(path);
46
return response;
47
}
48
}
49
50
public async Task<T> Get<T>(string path)
51
{
52
using (var client = GetClient())
53
{
54
var response = await client.GetStringAsync(path);
55
var data = JsonConvert.DeserializeObject<T>(response);
56
return data;
57
}
58
}
59
#endregion
60
61
#region POST Methods
62
public async Task<string> Post(string path, object requestData)
63
{
64
using (var client = GetClient())
65
{
66
var requestContent = new StringContent(
67
JsonConvert.SerializeObject(requestData),
68
Encoding.UTF8,
69
"application/json"
70
);
71
72
var response = await client.PostAsync(path, requestContent);
73
var responseString = await response.Content.ReadAsStringAsync();
74
75
return responseString;
76
}
77
}
78
79
public async Task<T> Post<T>(string path, object requestData)
80
{
81
using (var client = GetClient())
82
{
83
var requestContent = new StringContent(
84
JsonConvert.SerializeObject(requestData),
85
Encoding.UTF8,
86
"application/json"
87
);
88
89
var response = await client.PostAsync(path, requestContent);
90
var responseString = await response.Content.ReadAsStringAsync();
91
var data = JsonConvert.DeserializeObject<T>(responseString);
92
93
return data;
94
}
95
}
96
#endregion
97
98
#region PUT Methods
99
public async Task<string> Put(string path, object requestData)
100
{
101
using (var client = GetClient())
102
{
103
var requestContent = new StringContent(
104
JsonConvert.SerializeObject(requestData),
105
Encoding.UTF8,
106
"application/json"
107
);
108
109
var response = await client.PutAsync(path, requestContent);
110
var responseString = await response.Content.ReadAsStringAsync();
111
112
return responseString;
113
}
114
}
115
116
public async Task<T> Put<T>(string path, object requestData)
117
{
118
using (var client = GetClient())
119
{
120
var requestContent = new StringContent(
121
JsonConvert.SerializeObject(requestData),
122
Encoding.UTF8,
123
"application/json"
124
);
125
126
var response = await client.PutAsync(path, requestContent);
127
var responseString = await response.Content.ReadAsStringAsync();
128
var data = JsonConvert.DeserializeObject<T>(responseString);
129
130
return data;
131
}
132
}
133
#endregion
134
135
#region DELETE Methods
136
public async Task<string> Delete(string path)
137
{
138
using (var client = GetClient())
139
{
140
var response = await client.DeleteAsync(path);
141
var responseString = await response.Content.ReadAsStringAsync();
142
143
return responseString;
144
}
145
}
146
147
public async Task<T> Delete<T>(string path)
148
{
149
using (var client = GetClient())
150
{
151
var response = await client.DeleteAsync(path);
152
var responseString = await response.Content.ReadAsStringAsync();
153
var data = JsonConvert.DeserializeObject<T>(responseString);
154
155
return data;
156
}
157
}
158
#endregion
159
}
160
161
/// <summary>
162
/// Proxy settings, needed for accessing accross tiers
163
/// </summary>
164
public class ProxySettings
165
{
166
public string Endpoint { get; set; }
167
public bool BypassOnLocal { get; set; } = true;
168
public bool EnvironmentHasProxy() => !string.IsNullOrEmpty(Endpoint);
169
}

Confugure the Service

You can configure the service in your startup.cs as follows:

1
services.AddScoped<IntegrationService>(s =>
2
{
3
var proxySettings = Configuration
4
.GetSection("ProxySettings")
5
.Get<ProxySettings>();
6
7
var intBaseUrl = Configuration.GetValue<string>("IntegrationUrl");
8
9
if (proxySettings.EnvironmentHasProxy())
10
{
11
var proxy = new WebProxy(
12
proxySettings.Endpoint,
13
proxySettings.BypassOnLocal
14
);
15
16
return new IntegrationService(intBaseUrl, proxy);
17
}
18
else
19
{
20
return new IntegrationService(intBaseUrl);
21
}
22
});

The above is a bit overkill as it does the proxy checking too, but you don’t need that if you know your proxy configuration beforehand or are not using a proxy

Using the Service

To use the service you need to request it in a controller constructor via Dependency Injection

1
public class MyController : Controller {
2
3
private IntegrationService _integrationService;
4
5
public MyController(IntegrationService integrationService)
6
{
7
_integrationService = integrationService;
8
}
9
10
public async task<MyObject> MyFunction(ComplexObject data)
11
{
12
var result = await integrationService.Post<MyObject>("api/DoStuff", data);
13
14
return result;
15
}
16
}

You will need the following in your appsettings.json

1
...,
2
"ProxySettings: {
3
"Endpoint": "",
4
"BypassOnLocal": true
5
},
6
...