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); } } } }
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(); } }
public static void WriteClientOptions(CodeWriter writer, BuildContext context) { var title = context.Configuration.LibraryName; using (writer.Scope($"namespace {context.Configuration.Namespace}")) { writer.WriteXmlDocumentationSummary($"Client options for {title}."); using (writer.Scope($"public class {title}ManagementClientOptions: {typeof(ClientOptions)}")) { } } }
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(); } } }
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 WriteClientCtors(CodeWriter writer, Client client) { writer.WriteXmlDocumentationSummary($"Initializes a new instance of {client.Type.Name} for mocking."); using (writer.Scope($"protected {client.Type.Name:D}()")) { } writer.WriteXmlDocumentationSummary($"Initializes a new instance of {client.Type.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 client.RestClient.Parameters) { writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description); } writer.Append($"internal {client.Type.Name:D}({typeof(ClientDiagnostics)} {ClientDiagnosticsVariable}, {typeof(HttpPipeline)} {PipelineVariable},"); foreach (Parameter parameter in client.RestClient.Parameters) { writer.WriteParameter(parameter); } writer.RemoveTrailingComma(); writer.Line($")"); using (writer.Scope()) { writer.Append($"this.RestClient = new {client.RestClient.Type}({ClientDiagnosticsVariable}, {PipelineVariable}, "); foreach (var parameter in client.RestClient.Parameters) { writer.Append($"{parameter.Name}, "); } writer.RemoveTrailingComma(); writer.Line($");"); writer.Line($"{ClientDiagnosticsField} = {ClientDiagnosticsVariable};"); writer.Line($"{PipelineField} = {PipelineVariable};"); } writer.Line(); }
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); } } } }
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 WriteClientMethod(CodeWriter writer, ClientMethod clientMethod, bool async) { CSharpType?bodyType = clientMethod.RestClientMethod.ReturnType; CSharpType responseType = bodyType != null ? new CSharpType(typeof(Response <>), bodyType) : typeof(Response); responseType = async ? new CSharpType(typeof(Task <>), responseType) : responseType; var parameters = clientMethod.RestClientMethod.Parameters; writer.WriteXmlDocumentationSummary(clientMethod.Description); foreach (Parameter parameter in parameters) { writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description); } writer.WriteXmlDocumentationParameter("cancellationToken", "The cancellation token to use."); var methodName = CreateMethodName(clientMethod.Name, async); var asyncText = async ? "async" : string.Empty; writer.Append($"public virtual {asyncText} {responseType} {methodName}("); foreach (Parameter parameter in parameters) { writer.WriteParameter(parameter); } writer.Line($"{typeof(CancellationToken)} cancellationToken = default)"); using (writer.Scope()) { WriteDiagnosticScope(writer, clientMethod.Diagnostics, writer => { writer.Append($"return ("); if (async) { writer.Append($"await "); } writer.Append($"RestClient.{CreateMethodName(clientMethod.RestClientMethod.Name, async)}("); foreach (var parameter in clientMethod.RestClientMethod.Parameters) { writer.Append($"{parameter.Name:I}, "); } writer.Append($"cancellationToken)"); if (async) { writer.Append($".ConfigureAwait(false)"); } writer.Append($")"); if (bodyType == null && clientMethod.RestClientMethod.HeaderModel != null) { writer.Append($".GetRawResponse()"); } 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(); }
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 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);"); } } } }