private static void WriteConstructor(CodeWriter writer, ObjectType schema)
{
foreach (var constructor in schema.Constructors)
{
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {schema.Declaration.Name}");
foreach (var parameter in constructor.Parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.Append($"{constructor.Declaration.Accessibility} {schema.Declaration.Name}(");
foreach (var parameter in constructor.Parameters)
{
writer.WriteParameter(parameter);
}
writer.RemoveTrailingComma();
writer.Append($")");
if (constructor.BaseConstructor?.Parameters.Length > 0)
{
writer.Append($": base(");
foreach (var baseConstructorParameter in constructor.BaseConstructor.Parameters)
{
writer.Append($"{baseConstructorParameter.Name:I}, ");
}
writer.RemoveTrailingComma();
writer.Append($")");
}
writer.Line();
using (writer.Scope())
{
writer.WriteParameterNullChecks(constructor.Parameters);
foreach (var initializer in constructor.Initializers)
{
writer.Append($"{initializer.Property.Declaration.Name} = ")
.WriteReferenceOrConstant(initializer.Value)
.WriteConversion(initializer.Value.Type, initializer.Property.Declaration.Type);
if (initializer.DefaultValue != null &&
!initializer.Value.Type.IsValueType)
{
writer.Append($"?? ").WriteReferenceOrConstant(initializer.DefaultValue.Value);
}
writer.Line($";");
}
}
writer.Line();
}
}
private void WriteStartOperationOperation(CodeWriter writer, LongRunningOperationMethod lroMethod, bool async)
{
RestClientMethod originalMethod = lroMethod.StartMethod;
CSharpType returnType = async ? new CSharpType(typeof(Task <>), lroMethod.Operation.Type) : lroMethod.Operation.Type;
Parameter[] parameters = originalMethod.Parameters;
writer.WriteXmlDocumentationSummary(originalMethod.Description);
foreach (Parameter parameter in parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.WriteXmlDocumentationParameter("cancellationToken", "The cancellation token to use.");
string asyncText = async ? "async " : string.Empty;
writer.Append($"public virtual {asyncText}{returnType} {CreateStartOperationName(lroMethod.Name, async)}(");
foreach (Parameter parameter in parameters)
{
writer.WriteParameter(parameter);
}
writer.Line($"{typeof(CancellationToken)} cancellationToken = default)");
using (writer.Scope())
{
writer.WriteParameterNullChecks(parameters);
WriteDiagnosticScope(writer, lroMethod.Diagnostics, writer =>
{
string awaitText = async ? "await" : string.Empty;
string configureText = async ? ".ConfigureAwait(false)" : string.Empty;
writer.Append($"var originalResponse = {awaitText} RestClient.{CreateMethodName(originalMethod.Name, async)}(");
foreach (Parameter parameter in parameters)
{
writer.Append($"{parameter.Name}, ");
}
writer.Line($"cancellationToken){configureText};");
writer.Append($"return new {lroMethod.Operation.Type}({ClientDiagnosticsField}, {PipelineField}, RestClient.{CreateRequestMethodName(originalMethod.Name)}(");
foreach (Parameter parameter in parameters)
{
writer.Append($"{parameter.Name}, ");
}
writer.RemoveTrailingComma();
writer.Line($").Request, originalResponse);");
});
}
writer.Line();
}
private void WriteClientCtor(CodeWriter writer, RestClient restClient, CSharpType cs)
{
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {cs.Name}");
writer.WriteXmlDocumentationParameter(ClientDiagnosticsVariable, "The handler for diagnostic messaging in the client.");
writer.WriteXmlDocumentationParameter(PipelineVariable, "The HTTP pipeline for sending and receiving REST requests and responses.");
foreach (Parameter parameter in restClient.Parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
if (restClient.Parameters.HasAnyNullCheck())
{
writer.WriteXmlDocumentationException(typeof(ArgumentNullException), "This occurs when one of the required arguments is null.");
}
writer.Append($"public {cs.Name:D}({typeof(ClientDiagnostics)} {ClientDiagnosticsVariable}, {typeof(HttpPipeline)} {PipelineVariable},");
foreach (Parameter clientParameter in restClient.Parameters)
{
writer.WriteParameter(clientParameter);
}
writer.RemoveTrailingComma();
writer.Line($")");
using (writer.Scope())
{
writer.WriteParameterNullChecks(restClient.Parameters);
foreach (Parameter clientParameter in restClient.Parameters)
{
writer.Line($"this.{clientParameter.Name} = {clientParameter.Name};");
}
writer.Line($"{ClientDiagnosticsField} = {ClientDiagnosticsVariable};");
writer.Line($"{PipelineField} = {PipelineVariable};");
}
writer.Line();
}
public static void WriteAggregateClient(CodeWriter writer, BuildContext context)
{
var title = context.Configuration.LibraryName;
using (writer.Scope($"namespace {context.Configuration.Namespace}"))
{
Dictionary <string, Parameter> allParameters = new Dictionary <string, Parameter>();
foreach (var parameter in context.Library.Clients.SelectMany(p => p.RestClient.Parameters))
{
if (ManagementClientWriterHelpers.IsApiVersionParameter(parameter))
{
continue;
}
allParameters[parameter.Name] = parameter;
}
writer.WriteXmlDocumentationSummary($"{title} service management client.");
using (writer.Scope($"public class {title}ManagementClient"))
{
writer.Line($"private readonly {typeof(ClientDiagnostics)} {ClientDiagnosticsField};");
writer.Line($"private readonly {typeof(HttpPipeline)} {PipelineField};");
foreach (var parameter in allParameters.Values)
{
writer.Line($"private readonly {parameter.Type} _{parameter.Name};");
}
writer.Line();
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {title}ManagementClient for mocking.");
using (writer.Scope($"protected {title}ManagementClient()"))
{
}
writer.Line();
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {title}ManagementClient");
foreach (Parameter parameter in allParameters.Values)
{
if (ManagementClientWriterHelpers.IsEndpointParameter(parameter))
{
continue;
}
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.WriteXmlDocumentationParameter(TokenCredentialVariable, "The OAuth token for making client requests.");
writer.WriteXmlDocumentationParameter(OptionsVariable, "The options for configuring the client.");
writer.Append($"public {title}ManagementClient(");
foreach (Parameter parameter in allParameters.Values)
{
if (ManagementClientWriterHelpers.IsEndpointParameter(parameter))
{
continue;
}
writer.WriteParameter(parameter);
}
writer.Append($"{typeof(TokenCredential)} {TokenCredentialVariable}, {title}ManagementClientOptions {OptionsVariable} = null) : this(");
foreach (Parameter parameter in allParameters.Values)
{
// Pass the default host
if (ManagementClientWriterHelpers.IsEndpointParameter(parameter))
{
writer.Append($"null, ");
continue;
}
writer.Append($"{parameter.Name},");
}
writer.Line($"{TokenCredentialVariable}, {OptionsVariable})");
using (writer.Scope())
{
}
writer.WriteXmlDocumentationSummary($"Initializes a new instance of {title}ManagementClient");
foreach (Parameter parameter in allParameters.Values)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.WriteXmlDocumentationParameter(TokenCredentialVariable, "The OAuth token for making client requests.");
writer.WriteXmlDocumentationParameter(OptionsVariable, "The options for configuring the client.");
if (allParameters.Values.HasAnyNullCheck())
{
writer.WriteXmlDocumentationException(typeof(ArgumentNullException), "This occurs when one of the required arguments is null.");
}
writer.Append($"public {title}ManagementClient(");
foreach (Parameter parameter in allParameters.Values)
{
writer.WriteParameter(parameter, false);
}
writer.Append($"{typeof(TokenCredential)} {TokenCredentialVariable}, {title}ManagementClientOptions {OptionsVariable} = null)");
using (writer.Scope())
{
writer.WriteParameterNullChecks(allParameters.Values);
writer.Line($"{OptionsVariable} ??= new {title}ManagementClientOptions();");
writer.Line($"{ClientDiagnosticsField} = new {typeof(ClientDiagnostics)}({OptionsVariable});");
writer.Line($"{PipelineField} = {typeof(ManagementPipelineBuilder)}.Build({TokenCredentialVariable}, endpoint, {OptionsVariable});");
foreach (Parameter parameter in allParameters.Values)
{
writer.Line($"_{parameter.Name} = {parameter.Name};");
}
}
writer.Line();
foreach (var client in context.Library.Clients)
{
writer.WriteXmlDocumentationSummary($"Creates a new instance of {client.Type.Name}");
using (writer.Scope($"public virtual {client.Type} Get{client.Type.Name}()"))
{
writer.Append($"return new {client.Type}({ClientDiagnosticsField}, {PipelineField}, ");
foreach (var parameter in client.RestClient.Parameters)
{
if (ManagementClientWriterHelpers.IsApiVersionParameter(parameter))
{
continue;
}
writer.Append($"_{parameter.Name}, ");
}
writer.RemoveTrailingComma();
writer.Line($");");
}
writer.Line();
}
}
}
}
private void WritePagingOperation(CodeWriter writer, PagingMethod pagingMethod, bool async)
{
var pageType = pagingMethod.ItemType;
CSharpType responseType = async ? new CSharpType(typeof(AsyncPageable <>), pageType) : new CSharpType(typeof(Pageable <>), pageType);
var parameters = pagingMethod.Method.Parameters;
writer.WriteXmlDocumentationSummary(pagingMethod.Method.Description);
foreach (Parameter parameter in parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.WriteXmlDocumentationParameter("cancellationToken", "The cancellation token to use.");
writer.Append($"public virtual {responseType} {CreateMethodName(pagingMethod.Name, async)}(");
foreach (Parameter parameter in parameters)
{
writer.WriteParameter(parameter);
}
writer.Line($"{typeof(CancellationToken)} cancellationToken = default)");
using (writer.Scope())
{
writer.WriteParameterNullChecks(parameters);
var pageWrappedType = new CSharpType(typeof(Page <>), pageType);
var funcType = async ? new CSharpType(typeof(Task <>), pageWrappedType) : pageWrappedType;
var nullableInt = new CSharpType(typeof(int), true);
var continuationTokenText = pagingMethod.NextLinkName != null ? $"response.Value.{pagingMethod.NextLinkName}" : "null";
var asyncText = async ? "async" : string.Empty;
var awaitText = async ? "await" : string.Empty;
var configureAwaitText = async ? ".ConfigureAwait(false)" : string.Empty;
using (writer.Scope($"{asyncText} {funcType} FirstPageFunc({nullableInt} pageSizeHint)"))
{
WriteDiagnosticScope(writer, pagingMethod.Diagnostics, writer =>
{
writer.Append($"var response = {awaitText} RestClient.{CreateMethodName(pagingMethod.Method.Name, async)}(");
foreach (Parameter parameter in parameters)
{
writer.Append($"{parameter.Name}, ");
}
writer.Line($"cancellationToken){configureAwaitText};");
writer.Line($"return {typeof(Page)}.FromValues(response.Value.{pagingMethod.ItemName}, {continuationTokenText}, response.GetRawResponse());");
});
}
var nextPageFunctionName = "null";
if (pagingMethod.NextPageMethod != null)
{
nextPageFunctionName = "NextPageFunc";
var nextPageParameters = pagingMethod.NextPageMethod.Parameters;
using (writer.Scope($"{asyncText} {funcType} {nextPageFunctionName}({typeof(string)} nextLink, {nullableInt} pageSizeHint)"))
{
WriteDiagnosticScope(writer, pagingMethod.Diagnostics, writer =>
{
writer.Append($"var response = {awaitText} RestClient.{CreateMethodName(pagingMethod.NextPageMethod.Name, async)}(");
foreach (Parameter parameter in nextPageParameters)
{
writer.Append($"{parameter.Name}, ");
}
writer.Line($"cancellationToken){configureAwaitText};");
writer.Line($"return {typeof(Page)}.FromValues(response.Value.{pagingMethod.ItemName}, {continuationTokenText}, response.GetRawResponse());");
});
}
}
writer.Line($"return {typeof(PageableHelpers)}.Create{(async ? "Async" : string.Empty)}Enumerable(FirstPageFunc, {nextPageFunctionName});");
}
writer.Line();
}