public void WriteClient(CodeWriter writer, Client client, Configuration configuration)
{
var cs = client.Type;
var @namespace = cs.Namespace;
using (writer.Namespace(@namespace))
{
writer.WriteXmlDocumentationSummary(client.Description);
using (writer.Scope($"{client.Declaration.Accessibility} partial class {cs.Name}"))
{
WriteClientFields(writer, client);
WriteClientCtors(writer, client);
foreach (var clientMethod in client.Methods)
{
WriteClientMethod(writer, clientMethod, true);
WriteClientMethod(writer, clientMethod, false);
}
foreach (var pagingMethod in client.PagingMethods)
{
WritePagingOperation(writer, pagingMethod, true);
WritePagingOperation(writer, pagingMethod, false);
}
foreach (var longRunningOperation in client.LongRunningOperationMethods)
{
WriteStartOperationOperation(writer, longRunningOperation, true);
WriteStartOperationOperation(writer, longRunningOperation, false);
}
}
}
}
public void WriteHeaderModel(CodeWriter writer, ResponseHeaderGroupType responseHeaderGroup)
{
using (writer.Namespace(responseHeaderGroup.Declaration.Namespace))
{
writer.UseNamespace(new CSharpType(typeof(ResponseHeadersExtensions)).Namespace);
using (writer.Scope($"{responseHeaderGroup.Declaration.Accessibility} class {responseHeaderGroup.Declaration.Name}"))
{
WriteField(writer);
WriteConstructor(writer, responseHeaderGroup);
foreach (var method in responseHeaderGroup.Headers)
{
WriteHeaderProperty(writer, method);
}
}
}
}
private void WriteSealedChoiceSerialization(CodeWriter writer, EnumType schema)
{
using (writer.Namespace(schema.Declaration.Namespace))
{
string declaredTypeName = schema.Declaration.Name;
var isString = schema.BaseType.FrameworkType == typeof(string);
using (writer.Scope($"internal static class {declaredTypeName}Extensions"))
{
using (writer.Scope($"public static {schema.BaseType} ToSerialString(this {declaredTypeName} value) => value switch", end: "};"))
{
foreach (EnumTypeValue value in schema.Values)
{
writer.Line($"{declaredTypeName}.{value.Declaration.Name} => {value.Value.Value:L},");
}
writer.Line($"_ => throw new {typeof(ArgumentOutOfRangeException)}(nameof(value), value, \"Unknown {declaredTypeName} value.\")");
}
writer.Line();
using (writer.Scope($"public static {declaredTypeName} To{declaredTypeName}(this {schema.BaseType} value)"))
{
foreach (EnumTypeValue value in schema.Values)
{
writer.Append($"if ({schema.BaseType}.Equals(value, {value.Value.Value:L}");
if (isString)
{
writer.Append($", {typeof(StringComparison)}.InvariantCultureIgnoreCase");
}
writer.Line($")) return {declaredTypeName}.{value.Declaration.Name};");
}
writer.Line($"throw new {typeof(ArgumentOutOfRangeException)}(nameof(value), value, \"Unknown {declaredTypeName} value.\");");
}
writer.Line();
}
}
}
private void WriteSealedChoiceSchema(CodeWriter writer, EnumType schema)
{
if (schema.Declaration.IsUserDefined)
{
return;
}
using (writer.Namespace(schema.Declaration.Namespace))
{
writer.WriteXmlDocumentationSummary(schema.Description);
using (writer.Scope($"public enum {schema.Declaration.Name}"))
{
foreach (EnumTypeValue value in schema.Values)
{
writer.WriteXmlDocumentationSummary(value.Description);
writer.Line($"{value.Declaration.Name},");
}
writer.RemoveTrailingComma();
}
}
}
public void WriteClient(CodeWriter writer, RestClient restClient)
{
var cs = restClient.Type;
var @namespace = cs.Namespace;
using (writer.Namespace(@namespace))
{
writer.WriteXmlDocumentationSummary(restClient.Description);
using (writer.Scope($"{restClient.Declaration.Accessibility} partial class {cs.Name}"))
{
WriteClientFields(writer, restClient);
WriteClientCtor(writer, restClient, cs);
foreach (var method in restClient.Methods)
{
WriteRequestCreation(writer, method);
WriteOperation(writer, method, true);
WriteOperation(writer, method, false);
}
}
}
}
public static void Write(CodeWriter writer, LongRunningOperation operation)
{
var responseVariable = "response";
void WriteResultFunction(bool async)
{
if (operation.ResultSerialization != null)
{
writer.WriteDeserializationForMethods(
operation.ResultSerialization,
async: async,
(w, v) => w.Line($"return {v};"),
responseVariable);
}
else
{
if (async)
{
writer.Line($"return await new {typeof(ValueTask<Response>)}({responseVariable}).ConfigureAwait(false);");
}
else
{
writer.Line($"return {responseVariable};");
}
}
}
var cs = operation.Type;
var @namespace = cs.Namespace;
using (writer.Namespace(@namespace))
{
writer.WriteXmlDocumentationSummary(operation.Description);
var interfaceType = new CSharpType(typeof(IOperationSource <>), operation.ResultType);
var baseType = new CSharpType(typeof(Operation <>), operation.ResultType);
var waitForCompletionType = new CSharpType(typeof(ValueTask <>), new CSharpType(typeof(Response <>), operation.ResultType));
var helperType = new CSharpType(typeof(ArmOperationHelpers <>), operation.ResultType);
using (writer.Scope($"{operation.Declaration.Accessibility} partial class {cs.Name}: {baseType}, {interfaceType}"))
{
writer.Line($"private readonly {helperType} _operation;");
using (writer.Scope($"internal {cs.Name}({typeof(ClientDiagnostics)} clientDiagnostics, {typeof(HttpPipeline)} pipeline, {typeof(Request)} request, {typeof(Response)} response)"))
{
writer.Line($"_operation = new {helperType}(this, clientDiagnostics, pipeline, request, response, {typeof(OperationFinalStateVia)}.{operation.FinalStateVia}, {operation.Diagnostics.ScopeName:L});");
}
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override string Id => _operation.Id;");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {operation.ResultType} Value => _operation.Value;");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override bool HasCompleted => _operation.HasCompleted;");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override bool HasValue => _operation.HasValue;");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {typeof(Response)} GetRawResponse() => _operation.GetRawResponse();");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {typeof(Response)} UpdateStatus({typeof(CancellationToken)} cancellationToken = default) => _operation.UpdateStatus(cancellationToken);");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {typeof(ValueTask<Response>)} UpdateStatusAsync({typeof(CancellationToken)} cancellationToken = default) => _operation.UpdateStatusAsync(cancellationToken);");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {waitForCompletionType} WaitForCompletionAsync({typeof(CancellationToken)} cancellationToken = default) => _operation.WaitForCompletionAsync(cancellationToken);");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
writer.Line($"public override {waitForCompletionType} WaitForCompletionAsync({typeof(TimeSpan)} pollingInterval, {typeof(CancellationToken)} cancellationToken = default) => _operation.WaitForCompletionAsync(pollingInterval, cancellationToken);");
writer.Line();
using (writer.Scope($"{operation.ResultType} {interfaceType}.CreateResult({typeof(Response)} {responseVariable:D}, {typeof(CancellationToken)} cancellationToken)"))
{
WriteResultFunction(false);
}
writer.Line();
using (writer.Scope($"async {new CSharpType(typeof(ValueTask<>), operation.ResultType)} {interfaceType}.CreateResultAsync({typeof(Response)} {responseVariable:D}, {typeof(CancellationToken)} cancellationToken)"))
{
WriteResultFunction(true);
}
}
}
}
private void WriteObjectSerialization(CodeWriter writer, ObjectType model)
{
if (!model.Serializations.Any())
{
return;
}
using (writer.Namespace(model.Declaration.Namespace))
{
if (model.IsStruct)
{
writer.Append($"{model.Declaration.Accessibility} partial struct {model.Declaration.Name}");
}
else
{
writer.Append($"{model.Declaration.Accessibility} partial class {model.Declaration.Name}");
}
if (model.IncludeSerializer)
{
bool hasJson = model.Serializations.OfType <JsonSerialization>().Any();
bool hasXml = model.Serializations.OfType <XmlElementSerialization>().Any();
if (hasJson || hasXml)
{
writer.Append($": ");
}
if (hasJson)
{
writer.Append($"{typeof(IUtf8JsonSerializable)}");
writer.Append($", ");
}
if (hasXml)
{
writer.Append($"{typeof(IXmlSerializable)}");
writer.Append($", ");
}
writer.RemoveTrailingComma();
}
using (writer.Scope())
{
foreach (var serialization in model.Serializations)
{
switch (serialization)
{
case JsonSerialization jsonSerialization:
if (model.IncludeSerializer)
{
WriteJsonSerialize(writer, jsonSerialization);
}
if (model.IncludeDeserializer)
{
WriteJsonDeserialize(writer, model, jsonSerialization);
}
break;
case XmlElementSerialization xmlSerialization:
if (model.IncludeSerializer)
{
WriteXmlSerialize(writer, xmlSerialization);
}
if (model.IncludeDeserializer)
{
WriteXmlDeserialize(writer, model, xmlSerialization);
}
break;
default:
throw new NotImplementedException(serialization.ToString());
}
}
}
}
}
private void WriteObjectSchema(CodeWriter writer, ObjectType schema)
{
using (writer.Namespace(schema.Declaration.Namespace))
{
List <CSharpType> implementsTypes = new List <CSharpType>();
if (schema.Inherits != null)
{
implementsTypes.Add(schema.Inherits);
}
if (schema.ImplementsDictionaryType != null)
{
implementsTypes.Add(schema.ImplementsDictionaryType);
}
writer.WriteXmlDocumentationSummary(schema.Description);
if (schema.IsStruct)
{
writer.Append($"{schema.Declaration.Accessibility} readonly partial struct {schema.Declaration.Name}");
}
else
{
writer.Append($"{schema.Declaration.Accessibility} partial class {schema.Declaration.Name}");
}
if (implementsTypes.Any())
{
writer.AppendRaw(" : ");
foreach (var type in implementsTypes)
{
writer.Append($"{type} ,");
}
writer.RemoveTrailingComma();
}
writer.Line();
using (writer.Scope())
{
WriteConstructor(writer, schema);
foreach (var property in schema.Properties)
{
writer.WriteXmlDocumentationSummary(property.Description);
CSharpType propertyType = property.Declaration.Type;
writer.Append($"{property.Declaration.Accessibility} {propertyType} {property.Declaration.Name:D}");
writer.AppendRaw(property.IsReadOnly ? "{ get; }" : "{ get; set; }");
writer.Line();
}
if (schema.AdditionalPropertiesProperty is ObjectTypeProperty additionalPropertiesProperty)
{
var dictionaryType = schema.ImplementsDictionaryType;
Debug.Assert(dictionaryType != null);
var keyType = typeof(string);
var isReadonly = dictionaryType.FrameworkType == typeof(IReadOnlyDictionary <,>);
var itemType = dictionaryType.Arguments[1];
var keyValuePairType = new CSharpType(typeof(KeyValuePair <,>), keyType, itemType);
var iEnumeratorKeyValuePairType = new CSharpType(typeof(IEnumerator <>), keyValuePairType);
var collectionType = isReadonly ? typeof(IReadOnlyCollection <>) : typeof(ICollection <>);
var iCollectionKeyValuePairType = new CSharpType(collectionType, keyValuePairType);
var keyValueCollectionType = isReadonly ? typeof(IEnumerable <>) : typeof(ICollection <>);
var iCollectionKeyType = new CSharpType(keyValueCollectionType, keyType);
var iCollectionItemType = new CSharpType(keyValueCollectionType, itemType);
var iEnumerator = typeof(IEnumerator);
var iEnumerable = typeof(IEnumerable);
string additionalProperties = additionalPropertiesProperty.Declaration.Name;
writer
.WriteXmlDocumentationInheritDoc()
.Line($"public {iEnumeratorKeyValuePairType} GetEnumerator() => {additionalProperties}.GetEnumerator();")
.WriteXmlDocumentationInheritDoc()
.Line($"{iEnumerator} {iEnumerable}.GetEnumerator() => {additionalProperties}.GetEnumerator();")
.WriteXmlDocumentationInheritDoc()
.Line($"public bool TryGetValue(string key, out {itemType} value) => {additionalProperties}.TryGetValue(key, out value);")
.WriteXmlDocumentationInheritDoc()
.Line($"public bool ContainsKey({keyType} key) => {additionalProperties}.ContainsKey(key);")
.WriteXmlDocumentationInheritDoc()
.Line($"public {iCollectionKeyType} Keys => {additionalProperties}.Keys;")
.WriteXmlDocumentationInheritDoc()
.Line($"public {iCollectionItemType} Values => {additionalProperties}.Values;")
.WriteXmlDocumentationInheritDoc()
.Line($"int {iCollectionKeyValuePairType}.Count => {additionalProperties}.Count;");
if (!isReadonly)
{
writer
.WriteXmlDocumentationInheritDoc()
.Line($"public void Add({keyType} key, {itemType} value) => {additionalProperties}.Add(key, value);")
.WriteXmlDocumentationInheritDoc()
.Line($"public bool Remove({keyType} key) => {additionalProperties}.Remove(key);")
.WriteXmlDocumentationInheritDoc()
.Line($"bool {iCollectionKeyValuePairType}.IsReadOnly => {additionalProperties}.IsReadOnly;")
.WriteXmlDocumentationInheritDoc()
.Line($"void {iCollectionKeyValuePairType}.Add({keyValuePairType} value) => {additionalProperties}.Add(value);")
.WriteXmlDocumentationInheritDoc()
.Line($"bool {iCollectionKeyValuePairType}.Remove({keyValuePairType} value) => {additionalProperties}.Remove(value);")
.WriteXmlDocumentationInheritDoc()
.Line($"bool {iCollectionKeyValuePairType}.Contains({keyValuePairType} value) => {additionalProperties}.Contains(value);")
.WriteXmlDocumentationInheritDoc()
.Line($"void {iCollectionKeyValuePairType}.CopyTo({keyValuePairType}[] destination, int offset) => {additionalProperties}.CopyTo(destination, offset);")
.WriteXmlDocumentationInheritDoc()
.Line($"void {iCollectionKeyValuePairType}.Clear() => {additionalProperties}.Clear();");
}
using (writer
.WriteXmlDocumentationInheritDoc()
.Scope($"public {itemType} this[{keyType} key]"))
{
writer.Line($"get => {additionalProperties}[key];");
if (!isReadonly)
{
writer.Line($"set => {additionalProperties}[key] = value;");
}
}
}
}
}
}
private void WriteChoiceSchema(CodeWriter writer, EnumType schema)
{
var cs = schema.Type;
string name = schema.Declaration.Name;
var isString = schema.BaseType.FrameworkType == typeof(string);
using (writer.Namespace(schema.Declaration.Namespace))
{
writer.WriteXmlDocumentationSummary(schema.Description);
var implementType = new CSharpType(typeof(IEquatable <>), cs);
using (writer.Scope($"{schema.Declaration.Accessibility} readonly partial struct {name}: {implementType}"))
{
writer.Line($"private readonly {schema.BaseType} _value;");
writer.Line();
writer.WriteXmlDocumentationSummary($"Determines if two <see cref=\"{name}\"/> values are the same.");
using (writer.Scope($"public {name}({schema.BaseType} value)"))
{
writer.Append($"_value = value");
if (isString)
{
writer.Append($"?? throw new {typeof(ArgumentNullException)}(nameof(value))");
}
writer.Line($";");
}
writer.Line();
foreach (var choice in schema.Values)
{
writer.Line($"private const {schema.BaseType} {choice.Declaration.Name}Value = {choice.Value.Value:L};");
}
writer.Line();
foreach (var choice in schema.Values)
{
writer.WriteXmlDocumentationSummary(choice.Description);
writer.Append($"public static {cs} {choice.Declaration.Name}").AppendRaw("{ get; }").Append($" = new {cs}({choice.Declaration.Name}Value);").Line();
}
writer.WriteXmlDocumentationSummary($"Determines if two <see cref=\"{name}\"/> values are the same.");
writer.Line($"public static bool operator ==({cs} left, {cs} right) => left.Equals(right);");
writer.WriteXmlDocumentationSummary($"Determines if two <see cref=\"{name}\"/> values are not the same.");
writer.Line($"public static bool operator !=({cs} left, {cs} right) => !left.Equals(right);");
writer.WriteXmlDocumentationSummary($"Converts a string to a <see cref=\"{name}\"/>.");
writer.Line($"public static implicit operator {cs}({schema.BaseType} value) => new {cs}(value);");
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
WriteEditorBrowsableFalse(writer);
writer.Line($"public override bool Equals({typeof(object)} obj) => obj is {cs} other && Equals(other);");
writer.WriteXmlDocumentationInheritDoc();
writer.Append($"public bool Equals({cs} other) => ");
if (isString)
{
writer.Line($"{schema.BaseType}.Equals(_value, other._value, {typeof(StringComparison)}.InvariantCultureIgnoreCase);");
}
else
{
writer.Line($"{schema.BaseType}.Equals(_value, other._value);");
}
writer.Line();
writer.WriteXmlDocumentationInheritDoc();
WriteEditorBrowsableFalse(writer);
writer.Append($"public override int GetHashCode() => ");
if (isString)
{
writer.Line($"_value?.GetHashCode() ?? 0;");
}
else
{
writer.Line($"_value.GetHashCode();");
}
writer.WriteXmlDocumentationInheritDoc();
writer.Append($"public override {typeof(string)} ToString() => ");
if (isString)
{
writer.Line($"_value;");
}
else
{
writer.Line($"_value.ToString({typeof(CultureInfo)}.InvariantCulture);");
}
}
}
}