NSwag生成客户端调用代码

Posted 2020-12-05 leo_wl

NetCore2.1 WebAPI 根据swagger.json自动生成客户端代码

https://www.cnblogs.com/hunanzp/p/9297361.html

前言
上一篇博客中我们可以得知通过Swagger插件可以很方便的提供给接口开发者在线调试，但是实际上Swagger附带的功能还有很多，

比如使用NSwag生成客户端调用代码，进一步解放接口开发者。

NSwag
NSwag是一个发布在GitHub上的开源项目，它可以根据Swagger说明页上的swagger.json文件生成C#、TypeScript客户端代码。

NSwag的项目地址:https://github.com/RSuter/NSwag

Nswag提供4种代码生成方法

1、使用 NSwagStudio，这是一款 Windows 桌面应用，用于在 C# 和 TypeScript 中为 API 生成客户端代码。

2、使用 NSwag.CodeGeneration.CSharp 或 NSwag.CodeGeneration.TypeScript NuGet 包在项目中执行代码生成。

3、使用命令行中的 NSwag。

4、使用 NSwag.MSBuild NuGet 包。

这里推荐使用NSwagStudio，可以从GitHub上下载该工具，地址:https://github.com/RSuter/NSwag/wiki/NSwagStudio

下载后开始安装，安装完毕后打开NSwagStudio，如下图，在左侧选择Tab页菜单里选择Documents

如上图框框选中的几点，我们需要留意。其中Swagger Specification URL就是我们WebAPI的swagger.json的在线地址。

如果点击【Create local Copy 】按钮时你的WebAPI未在线则代码生成工具会弹出错误对话框，如下图:

所以采取读取Swagger Specification URL 方式进行生成代码的前提条件是你必须保证swagger.json文件能在线读取！

其次你可以选择RunTime（运行时），这里应该是服务端WebAPI的运行时(毕竟TypeScript是不关心你服务端是.NET Core还是.NET Framework).

因为我的环境是.NET Core2.1，所以这里选择NET Core21。

接下来，点击【Create local Copy】按钮，点击后NSwagStudio会与WebAPI服务端进行交互，成功后会将swagger.json文件格式化到左边的文本编辑器中，如下图:

此时，你可以在右侧的Outputs中勾选你需要输出的文件格式，这里我选择TypeScript和CSharp Client，

这个地方有个C# WebAPI Controller，我有点纳闷，我都有swagger.json文件了绝壁是已经存在webapi了，

没有必要反向再去生成一遍webapi的控制器啦。 不懂，反正只管生成客户端代码就好。

我们勾选好后下面就会出现相应的输出配合页面，如下图:

我们选择CSharp Client页面，该页面左侧分为Setting和Output两个页面，Setting页可以对输出的cs文件进行配置，如命名空间、类名称、输出文件路径等等(很多配置我也不会....)

我们点击【Generate Outputs】后NSwagStudio会根据配置生成客户端操作类，在Output页面即可检查，检查无误后再点击【Generate Files】可将类文件导出到配置的输出目录。

TypeScript亦是如此，同时NSwagStudio也可支持加载DLL反射生成，具体方法可根据官网操作(毕竟可以直接使用json文件在线生成没必要再自己手工选择dll..)

这里截图看SwagerUI页和NSwagStudio生成后的客户端cs文件

生成的客户端C#代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
//----------------------
//
// Generated using the NSwag toolchain v11.17.19.0 (NJsonSchema v9.10.58.0 (Newtonsoft.Json v9.0.0.0)) (http://NSwag.org)
//
//----------------------

namespace Test
{
#pragma warning disable // Disable all warnings

[System.CodeDom.Compiler.GeneratedCode("NSwag", "11.17.19.0 (NJsonSchema v9.10.58.0 (Newtonsoft.Json v9.0.0.0))")]
public  partial class Client
{
    private string _baseUrl = "http://localhost:58985";
    private System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings;
 
    public Client()
    {
        _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(() =>
        {
            var settings = new Newtonsoft.Json.JsonSerializerSettings();
            UpdateJsonSerializerSettings(settings);
            return settings;
        });
    }
 
    public string BaseUrl
    {
        get { return _baseUrl; }
        set { _baseUrl = value; }
    }
 
    protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _settings.Value; } }
 
    partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
    partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
    partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
    partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
 
    /// <summary>巴拉巴拉</summary>
    /// <returns>Success</returns>
    /// <exception cref="SwaggerException">A server side error occurred.</exception>
    public System.Threading.Tasks.Task ApiTestGetAsync()
    {
        return ApiTestGetAsync(System.Threading.CancellationToken.None);
    }
 
    /// <summary>巴拉巴拉</summary>
    /// <returns>Success</returns>
    /// <exception cref="SwaggerException">A server side error occurred.</exception>
    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
    public async System.Threading.Tasks.Task ApiTestGetAsync(System.Threading.CancellationToken cancellationToken)
    {
        var urlBuilder_ = new System.Text.StringBuilder();
        urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/Test");
 
        var client_ = new System.Net.Http.HttpClient();
        try
        {
            using (var request_ = new System.Net.Http.HttpRequestMessage())
            {
                request_.Method = new System.Net.Http.HttpMethod("GET");
 
                PrepareRequest(client_, request_, urlBuilder_);
                var url_ = urlBuilder_.ToString();
                request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
                PrepareRequest(client_, request_, url_);
 
                var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
                try
                {
                    var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
                    if (response_.Content != null && response_.Content.Headers != null)
                    {
                        foreach (var item_ in response_.Content.Headers)
                            headers_[item_.Key] = item_.Value;
                    }
 
                    ProcessResponse(client_, response_);
 
                    var status_ = ((int)response_.StatusCode).ToString();
                    if (status_ == "200")
                    {
                        return;
                    }
                    else
                    if (status_ != "200" && status_ != "204")
                    {
                        var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
                        throw new SwaggerException("The HTTP status code of the response was not expected (" + (int)response_.StatusCode + ").", (int)response_.StatusCode, responseData_, headers_, null);
                    }
                }
                finally
                {
                    if (response_ != null)
                        response_.Dispose();
                }
            }
        }
        finally
        {
            if (client_ != null)
                client_.Dispose();
        }
    }
 
    /// <returns>Success</returns>
    /// <exception cref="SwaggerException">A server side error occurred.</exception>
    public System.Threading.Tasks.Task ApiTestPostAsync(string value)
    {
        return ApiTestPostAsync(value, System.Threading.CancellationToken.None);
    }
 
    /// <returns>Success</returns>
    /// <exception cref="SwaggerException">A server side error occurred.</exception>
    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
    public async System.Threading.Tasks.Task ApiTestPostAsync(string value, System.Threading.CancellationToken cancellationToken)
    {
        var urlBuilder_ = new System.Text.StringBuilder();
        urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/Test");
 
        var client_ = new System.Net.Http.HttpClient();
        try
        {
            using (var request_ = new System.Net.Http.HttpRequestMessage())
            {
                var content_ = new System.Net.Http.StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(value, _settings.Value));
                content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("multipart/form-data");
                request_.Content = content_;
                request_.Method = new System.Net.Http.HttpMethod("POST");
 
                PrepareRequest(client_, request_, urlBuilder_);
                var url_ = urlBuilder_.ToString();
                request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
                PrepareRequest(client_, request_, url_);
 
                var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
                try
                {
                    var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
                    if (response_.Content != null && response_.Content.Headers != null)
                    {
                        foreach (var item_ in response_.Content.Headers)
                            headers_[item_.Key] = item_.Value;
                    }
 
                    ProcessResponse(client_, response_);
 
                    var status_ = ((int)response_.StatusCode).ToString();
                    if (status_ == "200")
                    {
                        return;
                    }
                    else
                    if (status_ != "200" && status_ != "204")
                    {
                        var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
                        throw new SwaggerException("The HTTP status code of the response was not expected (" + (int)response_.StatusCode + ").", (int)response_.StatusCode, responseData_, headers_, null);
                    }
                }
                finally
                {
                    if (response_ != null)
                        response_.Dispose();
                }
            }
        }
        finally
        {
            if (client_ != null)
                client_.Dispose();
        }
    }
 
    /// <summary>我是get测试</summary>
    /// <returns>Success</returns>
    /// <exception cref="SwaggerException">A server side error occurred.</exception>
    public System.Threading.Tasks.Task<string> ApiTestByIdGetAsync(int id)
    {
        return ApiTestByIdGetAsync(id, System.Threading.CancellationToken.None);
    }
 
    /// <summary>我是get测试</summary>
    /// <returns>Success</returns>
    /// <exception cref="SwaggerException">A server side error occurred.</exception>
    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
    public async System.Threading.Tasks.Task<string> ApiTestByIdGetAsync(int id, System.Threading.CancellationToken cancellationToken)
    {
        if (id == null)
            throw new System.ArgumentNullException("id");
 
        var urlBuilder_ = new System.Text.StringBuilder();
        urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/Test/{id}");
        urlBuilder_.Replace("{id}", System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
 
        var client_ = new System.Net.Http.HttpClient();
        try
        {
            using (var request_ = new System.Net.Http.HttpRequestMessage())
            {
                request_.Method = new System.Net.Http.HttpMethod("GET");
                request_.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
 
                PrepareRequest(client_, request_, urlBuilder_);
                var url_ = urlBuilder_.ToString();
                request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
                PrepareRequest(client_, request_, url_);
 
                var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
                try
                {
                    var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
                    if (response_.Content != null && response_.Content.Headers != null)
                    {
                        foreach (var item_ in response_.Content.Headers)
                            headers_[item_.Key] = item_.Value;
                    }
 
                    ProcessResponse(client_, response_);
 
                    var status_ = ((int)response_.StatusCode).ToString();
                    if (status_ == "200")
                    {
                        var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
                        var result_ = default(string);
                        try
                        {
                            result_ = Newtonsoft.Json.JsonConvert.DeserializeObject<string>(responseData_, _settings.Value);
                            return result_;
                        }
                        catch (System.Exception exception_)
                        {
                            throw new SwaggerException("Could not deserialize the response body.", (int)response_.StatusCode, responseData_, headers_, exception_);
                        }
                    }
                    else
                    if (status_ != "200" && status_ != "204")
                    {
                        var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
                        throw new SwaggerException("The HTTP status code of the response was not expected (" + (int)response_.StatusCode + ").", (int)response_.StatusCode, responseData_, headers_, null);
                    }
         
                    return default(string);
                }
                finally
                {
                    if (response_ != null)
                        response_.Dispose();
                }
            }
        }
        finally
        {
            if (client_ != null)
                client_.Dispose();
        }
    }
 
    /// <returns>Success</returns>
    /// <exception cref="SwaggerException">A server side error occurred.</exception>
    public System.Threading.Tasks.Task ApiTestByIdPutAsync(int id, string value)
    {
        return ApiTestByIdPutAsync(id, value, System.Threading.CancellationToken.None);
    }
 
    /// <returns>Success</returns>
    /// <exception cref="SwaggerException">A server side error occurred.</exception>
    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
    public async System.Threading.Tasks.Task ApiTestByIdPutAsync(int id, string value, System.Threading.CancellationToken cancellationToken)
    {
        if (id == null)
            throw new System.ArgumentNullException("id");
 
        var urlBuilder_ = new System.Text.StringBuilder();
        urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/Test/{id}");
        urlBuilder_.Replace("{id}", System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
 
        var client_ = new System.Net.Http.HttpClient();
        try
        {
            using (var request_ = new System.Net.Http.HttpRequestMessage())
            {
                var content_ = new System.Net.Http.StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(value, _settings.Value));
                content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("multipart/form-data");
                request_.Content = content_;
                request_.Method = new System.Net.Http.HttpMethod("PUT");
 
                PrepareRequest(client_, request_, urlBuilder_);
                var url_ = urlBuilder_.ToString();
                request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
                PrepareRequest(client_, request_, url_);
 
                var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
                try
                {
                    var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
                    if (response_.Content != null && response_.Content.Headers != null)
                    {
                        foreach (var item_ in response_.Content.Headers)
                            headers_[item_.Key] = item_.Value;
                    }
 
                    ProcessResponse(client_, response_);
 
                    var status_ = ((int)response_.StatusCode).ToString();
                    if (status_ == "200")
                    {
                        return;
                    }
                    else
                    if (status_ != "200" && status_ != "204")
                    {
                        var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
                        throw new SwaggerException("The HTTP status code of the response was not expected (" + (int)response_.StatusCode + ").", (int)response_.StatusCode, responseData_, headers_, null);
                    }
                }
                finally
                {
                    if (response_ != null)
                        response_.Dispose();
                }
            }
        }
        finally
        {
            if (client_ != null)
                client_.Dispose();
        }
    }
 
    /// <summary>小魔仙</summary>
    /// <returns>Success</returns>
    /// <exception cref="SwaggerException">A server side error occurred.</exception>
    public System.Threading.Tasks.Task ApiTestByIdDeleteAsync(int id)
    {
        return ApiTestByIdDeleteAsync(id, System.Threading.CancellationToken.None);
    }
 
    /// <summary>小魔仙</summary>
    /// <returns>Success</returns>
    /// <exception cref="SwaggerException">A server side error occurred.</exception>
    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
    public async System.Threading.Tasks.Task ApiTestByIdDeleteAsync(int id, System.Threading.CancellationToken cancellationToken)
    {
        if (id == null)
            throw new System.ArgumentNullException("id");
 
        var urlBuilder_ = new System.Text.StringBuilder();
        urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/Test/{id}");
        urlBuilder_.Replace("{id}", System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
 
        var client_ = new System.Net.Http.HttpClient();
        try
        {
            using (var request_ = new System.Net.Http.HttpRequestMessage())
            {
                request_.Method = new System.Net.Http.HttpMethod("DELETE");
 
                PrepareRequest(client_, request_, urlBuilder_);
                var url_ = urlBuilder_.ToString();
                request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
                PrepareRequest(client_, request_, url_);
 
                var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
                try
                {
                    var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
                    if (response_.Content != null && response_.Content.Headers != null)
                    {
                        foreach (var item_ in response_.Content.Headers)
                            headers_[item_.Key] = item_.Value;
                    }
 
                    ProcessResponse(client_, response_);
 
                    var status_ = ((int)response_.StatusCode).ToString();
                    if (status_ == "200")
                    {
                        return;
                    }
                    else
                    if (status_ != "200" && status_ != "204")
                    {
                        var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
                        throw new SwaggerException("The HTTP status code of the response was not expected (" + (int)response_.StatusCode + ").", (int)response_.StatusCode, responseData_, headers_, null);
                    }
                }
                finally
                {
                    if (response_ != null)
                        response_.Dispose();
                }
            }
        }
        finally
        {
            if (client_ != null)
                client_.Dispose();
        }
    }
 
    private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
    {
        if (value is System.Enum)
        {
            string name = System.Enum.GetName(value.GetType(), value);
            if (name != null)
            {
                var field = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
                if (field != null)
                {
                    var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field, typeof(System.Runtime.Serialization.EnumMemberAttribute))
                        as System.Runtime.Serialization.EnumMemberAttribute;
                    if (attribute != null)
                    {
                        return attribute.Value;
                    }
                }
            }
        }
        else if (value is byte[])
        {
            return System.Convert.ToBase64String((byte[]) value);
        }
        else if (value != null && value.GetType().IsArray)
        {
            var array = System.Linq.Enumerable.OfType<object>((System.Array) value);
            return string.Join(",", System.Linq.Enumerable.Select(array, o => ConvertToString(o, cultureInfo)));
        }
     
        return System.Convert.ToString(value, cultureInfo);
    }
}
 
 



[System.CodeDom.Compiler.GeneratedCode("NSwag", "11.17.19.0 (NJsonSchema v9.10.58.0 (Newtonsoft.Json v9.0.0.0))")]
public partial class SwaggerException : System.Exception
{
    public int StatusCode { get; private set; }

    public string Response { get; private set; }

    public System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }

    public SwaggerException(string message, int statusCode, string response, System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
        : base(message, innerException)
    {
        StatusCode = statusCode;
        Response = response;
        Headers = headers;
    }

    public override string ToString()
    {
        return string.Format("HTTP Response: 

{0}

{1}", Response, base.ToString());
    }
}

[System.CodeDom.Compiler.GeneratedCode("NSwag", "11.17.19.0 (NJsonSchema v9.10.58.0 (Newtonsoft.Json v9.0.0.0))")]
public partial class SwaggerException<TResult> : SwaggerException
{
    public TResult Result { get; private set; }

    public SwaggerException(string message, int statusCode, string response, System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
        : base(message, statusCode, response, headers, innerException)
    {
        Result = result;
    }
}

}
　　

结语
不得不赞叹Swagger的强大，它的出现解放了多少程序员啊，后续但凡有客户端码农说不会调用哥的API，哥都可以直接给他代码生成器生成的代码，一个字：爽。