/// <summary> /// Constructs a new <see cref="CSharpProperty" /> object. /// </summary> /// <param name="name">The name of this property.</param> /// <param name="type">The type of this property.</param> /// <param name="accessModifier">The access level of this property.</param> /// <param name="isStatic">Whether or not this is a static property.</param> /// <param name="isOverride">Whether or not this is overriding a property in a base type.</param> /// <param name="hasGetter">Whether or not this property has a getter.</param> /// <param name="hasSetter">Whether or not this property has a setter.</param> /// <param name="defaultValue">The default value for this property.</param> /// <param name="attributes">The attributes on this property.</param> /// <param name="documentationComment">The documentation comment for this property.</param> public CSharpProperty( string name, string type, CSharpAccessModifier accessModifier = CSharpAccessModifier.Public, bool isStatic = false, bool isOverride = false, bool hasGetter = true, bool hasSetter = true, string defaultValue = null, IEnumerable <CSharpAttribute> attributes = null, CSharpDocumentationComment documentationComment = null) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException("C# Property name cannot be null or whitespace", nameof(name)); } if (type != null && string.IsNullOrWhiteSpace(type)) { throw new ArgumentException("Property type cannot be empty or whitespace", nameof(name)); } this.Name = name; this.TypeName = type ?? throw new ArgumentNullException(nameof(type)); this.IsStatic = isStatic; this.IsOverride = isOverride; this.AccessModifier = accessModifier; this.HasGetter = hasGetter; this.HasSetter = hasSetter; this.DefaultValue = defaultValue; this.Attributes = attributes ?? Array.Empty <CSharpAttribute>(); this.DocumentationComment = documentationComment; }
/// <summary> /// Constructs a new <see cref="CSharpMethod" /> object. /// </summary> /// <param name="name">The name of the method.</param> /// <param name="returnType"> /// The full name of the method's return type. /// <para> /// If null, the return type will not be shown in the generated output. /// </para> /// </param> /// <param name="body">The method body.</param> /// <param name="parameters">The parameters which need to be provided as inputs to this method.</param> /// <param name="accessModifier">The access level of the method.</param> /// <param name="isStatic">True if this method should be marked as static, otherwise false.</param> /// <param name="isOverride">True if this method is overriding a base type's method, otherwise false.</param> /// <param name="isAsync">True if this method should be marked as async, otherwise false.</param> /// <param name="documentationComment">The method's documentation comment. The parameters' documentation will automatically be included in this comment.</param> public CSharpMethod( string name, string returnType, string body, IEnumerable <CSharpParameter> parameters = null, CSharpAccessModifier accessModifier = CSharpAccessModifier.Public, bool isStatic = false, bool isOverride = false, bool isAsync = false, CSharpDocumentationComment documentationComment = null) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException("Method name cannot be null or whitespace", nameof(name)); } if (returnType != null && string.IsNullOrWhiteSpace(returnType)) { throw new ArgumentException("Return type cannot be empty or whitespace", nameof(name)); } this.Name = name; this.AccessModifier = accessModifier; this.IsStatic = isStatic; this.IsOverride = isOverride; this.IsAsync = isAsync; this.ReturnType = returnType; this.Parameters = parameters ?? Array.Empty <CSharpParameter>(); this.Body = body ?? string.Empty; this.DocumentationComment = documentationComment; // Add parameter descriptions into the documentation comment string parametersDocumentationComment = this.GetParametersDocumentationComment(this.Parameters); if (!string.IsNullOrWhiteSpace(parametersDocumentationComment)) { if (!string.IsNullOrWhiteSpace(this.DocumentationComment?.RawNotes)) { parametersDocumentationComment += $"{Environment.NewLine}{this.DocumentationComment.RawNotes}"; } this.DocumentationComment = new CSharpDocumentationComment(this.DocumentationComment?.Summary, parametersDocumentationComment); } }
/// <summary> /// Constructs a new <see cref="CSharpClassConstructor" /> object. /// </summary> /// <param name="className">The name of the class that contains this constructor.</param> /// <param name="accessModifier">The access level of the method.</param> /// <param name="parameters">The parameters which need to be provided as inputs to this method.</param> /// <param name="baseClassConstructorParameterValues"> /// The parameter values to pass to the base class' constructor, as they will appear in the code. /// <para> /// If this is null, the base constructor call will not be visible in the generated output. /// Do this either when this constructor's class does not inherit from another class, or /// when the constructor should call the base class' default constructor automatically. /// </para> /// <para> /// NOTE: These values will not automatically be sanitized if they are identifiers. For /// example, if one of the variables being passed to the base constructor is called "class", /// then you should provide the string "@class" instead). /// </para> /// </param> /// <param name="body">The method body.</param> /// <param name="documentationComment"> /// The method's documentation comment. The parameters' documentation will automatically be /// included in this comment. /// </param> public CSharpClassConstructor( string className, string body, CSharpAccessModifier accessModifier = CSharpAccessModifier.Public, IEnumerable <CSharpParameter> parameters = null, IEnumerable <string> baseClassConstructorParameterValues = null, CSharpDocumentationComment documentationComment = null) : base( name: className, returnType: null, body: body, parameters: parameters, accessModifier: accessModifier, isStatic: false, isOverride: false, isAsync: false, documentationComment: documentationComment) { this.BaseClassConstructorParameterValues = baseClassConstructorParameterValues ?? Array.Empty <string>(); }
/// <summary> /// Creates a new <see cref="CSharpClass" /> object. /// </summary> /// <param name="name">The name of the class.</param> /// <param name="accessModifier">The class' access modifier.</param> /// <param name="baseType">The class' base (super/parent) type.</param> /// <param name="interfaces">The interfaces that this class implements.</param> /// <param name="attributes">The attributes on this class.</param> /// <param name="properties">The properties in this class.</param> /// <param name="constructors">The constructor methods for this class.</param> /// <param name="methods">The methods in this class.</param> /// <param name="isStatic">True if the class should be marked as static, otherwise false.</param> /// <param name="documentationComment">The documentation comment on this class.</param> public CSharpClass( string name, CSharpAccessModifier accessModifier = CSharpAccessModifier.Public, IEnumerable <CSharpProperty> properties = null, IEnumerable <CSharpClassConstructor> constructors = null, IEnumerable <CSharpMethod> methods = null, bool isStatic = false, string baseType = null, IEnumerable <string> interfaces = null, IEnumerable <CSharpAttribute> attributes = null, CSharpDocumentationComment documentationComment = null) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException("Class name cannot be null or whitespace", nameof(name)); } if (baseType != null && string.IsNullOrWhiteSpace(baseType)) { throw new ArgumentException("Base type name cannot be empty. Set it to null to remove the base type.", nameof(baseType)); } this.Name = name; this.AccessModifier = accessModifier; this.BaseType = baseType; this.IsStatic = isStatic; this.Interfaces = interfaces == null ? Array.Empty <string>().AsEnumerable() : new HashSet <string>(interfaces); this.Attributes = attributes ?? Array.Empty <CSharpAttribute>(); this.Properties = properties ?? Array.Empty <CSharpProperty>(); this.Constructors = constructors ?? Array.Empty <CSharpClassConstructor>(); this.Methods = methods ?? Array.Empty <CSharpMethod>(); this.DocumentationComment = documentationComment; }