Also, on that same note. Would you mind making a short list of code style preferences for this project? (please make one for C++ code and one for C#).

For example:

Naming C++:

public variable: pascalCase;
private variable: _pascalCase;
Event variable: OnTitleCase;
Function: TitleCase;
Type: class/struct TitleCase
Typedef: using MyTypeT = ExistingType;
Concept: concept IsTitleCase[T] (suffix with T if Type check)
Template type: template <[Concept] class [TypeName]T>
enum: enum class TitleCase
enum value: TitleCase;
constant: TitleCase;
namespace: namespace Word::Word::Word (prefer short names)

braces/indent sample:

namespace My::Namespace 
{
    void MyFunction()
    {
        if (!expression) // One line allowed
            return;
        
        switch(i) {
            case 1:
                // branch A
                return;
            case 2:
            {
                // branch C
                return;
            }
        }
    }
}

Class definition order:
public:
typedefs
constants
constructors
operators
functions
vars
protected:
private:
same order as public

Also, on that same note. Would you mind making a short list of code style preferences for this project? (please make one for C++ code and one for C#).

For example:

Naming C++:

public variable: pascalCase; private variable: _pascalCase; Event variable: OnTitleCase; Function: TitleCase; Type: class/struct TitleCase Typedef: using MyTypeT = ExistingType; Concept: concept IsTitleCase[T] (suffix with T if Type check) Template type: template <[Concept] class [TypeName]T> enum: enum class TitleCase enum value: TitleCase; constant: TitleCase; namespace: namespace Word::Word::Word (prefer short names)

braces/indent sample:

namespace My::Namespace 
{
    void MyFunction()
    {
        if (!expression) // One line allowed
            return;
        
        switch(i) {
            case 1:
                // branch A
                return;
            case 2:
            {
                // branch C
                return;
            }
        }
    }
}

Class definition order: public: typedefs constants constructors operators functions vars protected: private: same order as public

I am not too picky about it to be honest, we should probably go with a consistency style that doesn't cause too many changes to existing code, if it can reasonably match that existing style, I think it would be good, though with Git's support for introducing ignored revisions as not to break blame, maybe changes are not that important.

What are you thinking, should we use clang-format maybe? Not sure if we should try to match LLVM/Clang coding style, or keep it more close to C# conventions maybe?

Yeah I was thinking clang-format

Also, I know this doesn't compile. The reason is that there is a mismatch in the c# and CLI bindings for std::vector as you had noted before.

I was looking at implementing it as a simple type map with a getter/setter pair like this:

get {
    for (uint i = 0; i < <ProperyName>Count; ++i)
        yield return Get<ProperyName>(i);
}
set {
    Clear<ProperyName>();
    foreach (var __x in value)
        Add<ProperyName>(__x);
}

But the source generator is giving me some problems with the implementation. For example it's now generating a private field which should not be there.

@tritao Got this working, so just wanted to let you know it's ready for review. (No pressure :p)

Looks great, thanks for much needed cleanups 👍