Completed C# Compiler

[LogicAndTrick]

I started this a few days ago, and I just noticed that you were working on it as well so hopefully this can save you some time. I've compiled the test cases and the outputs all build using .NET Core. I haven't tried running them, though.

I've made some changes so that the result fits into the .NET naming standards and it takes advantage of some of the C#/.NET features that Java doesn't have.

• Added a .NET namespace config option (but defaults to Kaitai if not specified)
• Using .NET naming standards (public members use PascalCase, private members use camelCase)
  • Properties can't have the same name as classes, so the public getters are named Get{Thing}() instead of just {Thing}()
• I've done a (hopefully) complete implementation of the KaitaiStream class in my runtime fork at LogicAndTrick/kaitai_struct_csharp_runtime, let me know if you would like a PR for the runtime.
  • The runtime stream is based off .NET's BinaryReader class which has implementations for little-endian types, so only the BE methods need to be implemented.
  • As a bonus the BinaryReader already has ReadSingle and ReadDouble (and others), so floating point support comes free.
• All the classes are marked as partial so users can add methods and properties to the class without touching the generated file

Apologies if this conflicts with anything you're working on! I've never used Scala before, so hopefully I didn't do anything wrong.

[GreyCat]

What's the idea of changing it back to literal KaitaiStream?

[LogicAndTrick]

I think this may have been caused because I started from the Java compiler originally. I must have missed a few changes when I was matching it back to what you had. There's a couple of others with the renaming of the camelCase/member naming functions, I'll get them cleaned up.

[GreyCat]

Thank you so much for you hard work here, it's certainly really helpful :)

I've reviewed and commented all the changes you've sent. Could you fix / respond to stuff I've mentioned and update this pull request, so I could apply it right away?

I'm currently working on a testing system for C#, and actually it's almost finished. I'll try to deploy it to Travis soon enough, so we can get things rolling in C# department, with proper CI and progress measurements at http://kaitai.io/ci/

As a side note, a little advice for the future commits: could you please send them in more distinct, separate commits, so I could have applied some right away?

[LogicAndTrick]

No problems, thanks for the quick review. I'll get those changes in as soon as I can.

[GreyCat]

I've done a (hopefully) complete implementation of the KaitaiStream class in my runtime fork at LogicAndTrick/kaitai_struct_csharp_runtime, let me know if you would like a PR for the runtime.

I've already reviewed and I agree with most of it, except for GetXXX stuff and renaming of _io to stream (_io should probably become m_Io, as per MS / .NET core codestyle). But I'm definitely in no position to judge any C# code, you people obviously know it much better than I do. Please do the PR, so other people interested in the C# support could review it too (i.e. @indrora).

[LogicAndTrick]

I'm working on this now, the naming of things is going to get a bit messy because of the conflicts. Java allows for something like this:

class Test {
  private String example;
  public String example() { return example; }
}

Whereas this will result in a compiler error in C# due to duplicate declarations of the same name. I'm going with this alternative for now:

class Test {
  private String _example;
  public String example { get { return _example; } }
}

This doesn't suit the naming standard (public property should be PascalCase), but then it breaks in the case of an inner class...

class Test {
  public class Example { ... }
  private Example _example;
  public Example Example { get { return _example; } } // <- `Example` is already defined in class
}

The other option is to name inner classes something else, such as _Example or Example_Inner. But that will also deviate from the standard. Which do you think would be the better option? Break C# naming standards by using camelCase for getters, or change the name of inner classes?

Or should I use PascalCase and leave the test cases broken to be fixed later?

[LogicAndTrick]

Closing this - Created PR #2 instead.