Static Functions Issues

[tomspilman]

I'm having issues with exporting static functions from C++ without getting weird looking wrappers.

My first try was just adding static methods to a class with private constructor. My thinking was that since the class had nothing but static methods, CppSharp would not make it constructible.... but that does not seem to be the case. The final class had constructors and dispose methods.

My next try was just putting plain methods in a header:

// MyStaticClass.h
#pragma once
#include "PreDecls.h"

__declspec(dllexport) bool MyStaticMethod();

What I got was this...

namespace MyNamespace
{
    public unsafe partial class MyNamespace_MyStaticClass
    {
        public struct Internal
        {
           // blah blah blah
        }

        public static bool MyStaticMethod()
        {
            var __ret = Internal.MyStaticMethod_0();
            return __ret;
        }
    }
}

Instead of having the class named after the header file... MyStaticClass... I got something with the assembly namespace prepended MyNamespace_MyStaticClass.

So what is the best way to get a C# style "static class" wrapper from C++?

[tritao]

My first try was just adding static methods to a class with private constructor. My thinking was that since the class had nothing but static methods, CppSharp would not make it constructible.... but that does not seem to be the case. The final class had constructors and dispose methods.

This seems like a bug, I'll put it on the TODO. What I'm thinking is that even if the class only has a private constructor the user might still want to instantiate the class with a native pointer, so I'm not sure if we can assume that no constructors/dispose are needed. Though since the class has a private constructor, we could check if there is any static method returning an instance of the class. If no such overload exists, or if C++11 deleted constructors are used, then we can be reasonably sure that this class cannot be instantiated at all, and do a better job wrapping it up.

Instead of having the class named after the header file... MyStaticClass... I got something with the assembly namespace prepended MyNamespace_MyStaticClass.

Yes this is a bit weird, I'm don't remember why I chose to prepend the namespace name here, but it sure can be improved.

So what is the best way to get a C# style "static class" wrapper from C++?

I'm not sure there's any way at the moment, besides hacking the generator. I'll try to hack something up by the end of the week.

[tomspilman]

Though since the class has a private constructor,
we could check if there is any static method returning
an instance of the class.

That seems reasonable. If there is no public constructor, all the exported methods are static, and the class is not referenced in any other place in the wrapper... it could be considered to be a static class.

I'll try to hack something up by the end of the week.

Thanks... this would be fantastic to have cleaned up.

[tomspilman]

It would be nice to have this solved in the coming weeks. We will be starting on another PS4 project where this will be critical.

By the way check out TowerFall on PS4 on March 11th... i think it may be the first shipping game using CppSharp for bindings.

[tritao]

I've now pushed some better support for static classes, it would be great if you could test this.

About the global functions, it still needs some work on the naming. I think the reason I do not use the name of the header directly is because it could conflict with some already existing class which also has the name of the header. In this case, we could just store the functions directly as static methods under that class.

[tomspilman]

I've now pushed some better support for static classes

Cool. I'd do that ASAP!

Thanks!

[tomspilman]

So I grabbed this build...

http://builds.tritao.eu/viewLog.html?buildTypeId=CppSharp_VS2012&buildId=3428

And have good and bad news...

Good news in that namespaces show up as "My.Name.Space" and not "My_Name_Space" like they did before. Also all the CppSharp.Runtime.ICppMarshal is gone which is nice.

However I still can't get static classes to be static. This is my class...

class MyStaticClass
{
private:
    MyStaticClass() {}

public:

    __declspec(dllexport) static bool DoStuff();
};

... this is what CppSharp generates....

    public unsafe partial class MyStaticClass : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 1)]
        public struct Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport]
            ... blah, blah, blah...
        }

        public global::System.IntPtr __Instance { get; protected set; }

        internal MyStaticClass(MyStaticClass .Internal* native)
            : this(new global::System.IntPtr(native))
        {
        }

        internal MyStaticClass(MyStaticClass.Internal native)
            : this(&native)
        {
        }

        public MyStaticClass(global::System.IntPtr native)
        {
            __Instance = native;
        }

        public void Dispose()
        {
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            Internal.dtor_0(__Instance);
            Marshal.FreeHGlobal(__Instance);
        }

        public static bool DoStuff()
        {
            var __ret = Internal.DoStuff_0();
            return __ret;
        }
    }

I'm basically seeing no change in static behavior here... it still tries to make the class an instance that can be disposed.

I tried with and without private constructors/destructors... no changes. The class is not reference in any other way in the library... so no instances.

[tritao]

That's weird, the test case I added is pretty much the same.

Could you step through CheckStaticClass.VisitClassDecl and check why it's bailing out on your class?

[tomspilman]

Could you step through CheckStaticClass.VisitClassDecl and check
why it's bailing out on your class?

Sure... i'll give it a shot today.

[tomspilman]

Ok... this is interesting IsStatic is true on the class. So detecting the static class isn't the problem.

[tritao]

I've found some code in the stash today for handling static classes in the C# backend. Maybe I didn't fully commit my work the last time I looked at this, will test this again soon.

[tomspilman]

Thanks @tritao! We can use the fixes there.

[tritao]

I've pushed some new fixes for this, let me know if it works so we can close this.

[tomspilman]

This does look to be fixed in the latest code. Closing this issue.