bfriesen / csharpinator Goto Github PK

• Add option to default all properties to be nullable.
• When the above option is off, and the class definitions are being refined (by processing an additional document):
  • If a property had existed previously as non-nullable, switch it to nullable if it is not found in the new document.
  • If a new property is encountered, add it as nullable, since it hadn't existed before.

Given no refinements, an empty element should output a property of type string. Upon refinement (where the element has some kind of child(ren)), completely reevaluate the property.

Add branching to code to detect each combination, throwing a NotImplementedException for cases that aren't implemented yet.

• XmlElement
• XmlAttribute
• XmlText
• List with container (XmlArray + XmlArrayItem)
• List without container (XmlElement)
• Any others?

Implementation brainstorming:

• Create ListClass (inherits from Class)
• Should contain another Class (the generic argument of the List)
• Need to be able to create a PropertyDefinition that has its Class be an instance of ListClass

Currently, it is required to process an document in order to generate classes. We need to be able to generated classes based purely on a previously-saved metadata file.

Identifiers like THIS_THING should end up like ThisThing, thisThing, or this_thing (depending on the specific casing). They're currently ending up like THIS_THING.

Example:

<container>
  <foos>
    <foo>abc</foo>
    <foo>xyz</foo>
    <bar>123</bar>
  </foos>
</container>

Produced c# code:

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Xml.Serialization;

namespace FooBar
{
    [XmlRoot("container")]
    public partial class Container
    {
        [XmlElement("foos")]
        public Foos Foos { get; set; }
    }

    [XmlRoot("foos")]
    public partial class Foos
    {
        [XmlElement("foo")]
        public List<string> Foos { get; set; }

        [XmlIgnore]
        public int? Bar { get; set; }

        [XmlElement("bar")]
        public string BarString
        {
            get
            {
                return Bar == null ? null : Bar.ToString();
            }
            set
            {
                Bar = value == null ? null : (int?)int.Parse(value);
            }
        }
    }
}

The problem is that class Foos has a property named Foos, which doesn't compile.

Given a JSON document like this:

{
    "ID": 1,
    "PublishedAt": "\/Date(1330848000000-0800)\/",
    "Text": "Best blog post ever",
    "Title": "Magical Title"
}

It creates a class with property like this:

[DataContract]
public partial class Container
{
    [IgnoreDataMember]
    public DateTime PublishedAt { get; set; }

    [DataMember(Name="PublishedAt")]
    public string PublishedAtString
    {
        get
        {
            return PublishedAt.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK", new CultureInfo("en-US"));
        }
        set
        {
            PublishedAt = DateTime.ParseExact(value, "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK", new CultureInfo("en-US"));
        }
    }

    /* Other properties here */
}

It should create a class like this:

[DataContract]
public partial class Container
{
    [DataMember(Name="PublishedAt")]
    public DateTime PublishedAt { get; set; }

    /* Other properties here */
}

Given this input...

<foo foo_value="true">
  <bar bar_value="123">abc</bar>
  <bar bar_value="456">xyz</bar>
</foo>

Or this one...

<foo foo_value="true">
  <bar bar_value="123">abc</bar>
</foo>

This class is being generated:

    [XmlRoot("bar")]
    public partial class Bar
    {

    }

The Bar class should have two properties: BarValue (of type int) and Value (of type string).

When you have a list of elements, they're not merging with each other during a single pass. A second pass fixes this.