feat: finish basic function of BMapSharp.

- fix weird C sharp behavior about calling FreeNativeData without calling ManagedToNative, which cause segment fault.
- disable unhandled exception handler in debug mode for BMap.
- change all associated code involving these issues.

BMap/BMExports.cpp

@@ -55,7 +55,7 @@ bool BMInit() {
 	if (CheckInited()) return false;
 
 	// register exception handler if we are in Windows.
-#if YYCC_OS == YYCC_OS_WINDOWS
+#if defined(LIBCMO_BUILD_RELEASE) && (YYCC_OS == YYCC_OS_WINDOWS)
 	YYCC::ExceptionHelper::Register();
 #endif
 
@@ -89,7 +89,7 @@ bool BMDispose() {
 	LibCmo::CK2::CKShutdown();
 
 	// unregister exception handler if we are in Windows
-#if YYCC_OS == YYCC_OS_WINDOWS
+#if defined(LIBCMO_BUILD_RELEASE) && (YYCC_OS == YYCC_OS_WINDOWS)
 	YYCC::ExceptionHelper::Unregister();
 #endif
 

BMapBindings/BMapSharp/.editorconfig

@@ -0,0 +1,364 @@
+root = true
+
+# All files
+[*]
+indent_style = space
+
+# Xml files
+[*.xml]
+indent_size = 2
+
+# C# files
+[*.cs]
+
+#### Core EditorConfig Options ####
+
+# Indentation and spacing
+indent_size = 4
+tab_width = 4
+
+# New line preferences
+end_of_line = crlf
+insert_final_newline = false
+
+#### .NET Coding Conventions ####
+[*.{cs,vb}]
+
+# Organize usings
+dotnet_separate_import_directive_groups = false
+dotnet_sort_system_directives_first = false
+file_header_template = unset
+
+# this. and Me. preferences
+dotnet_style_qualification_for_event = false:silent
+dotnet_style_qualification_for_field = false:silent
+dotnet_style_qualification_for_method = false:silent
+dotnet_style_qualification_for_property = false:silent
+
+# Language keywords vs BCL types preferences
+dotnet_style_predefined_type_for_locals_parameters_members = true:silent
+dotnet_style_predefined_type_for_member_access = true:silent
+
+# Parentheses preferences
+dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:silent
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:silent
+dotnet_style_parentheses_in_other_operators = never_if_unnecessary:silent
+dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:silent
+
+# Modifier preferences
+dotnet_style_require_accessibility_modifiers = for_non_interface_members:silent
+
+# Expression-level preferences
+dotnet_style_coalesce_expression = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_explicit_tuple_names = true:suggestion
+dotnet_style_null_propagation = true:suggestion
+dotnet_style_object_initializer = true:suggestion
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+dotnet_style_prefer_auto_properties = true:suggestion
+dotnet_style_prefer_compound_assignment = true:suggestion
+dotnet_style_prefer_conditional_expression_over_assignment = true:suggestion
+dotnet_style_prefer_conditional_expression_over_return = true:suggestion
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
+dotnet_style_prefer_inferred_tuple_names = true:suggestion
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion
+dotnet_style_prefer_simplified_boolean_expressions = true:suggestion
+dotnet_style_prefer_simplified_interpolation = true:suggestion
+
+# Field preferences
+dotnet_style_readonly_field = true:warning
+
+# Parameter preferences
+dotnet_code_quality_unused_parameters = all:suggestion
+
+# Suppression preferences
+dotnet_remove_unnecessary_suppression_exclusions = none
+
+#### C# Coding Conventions ####
+[*.cs]
+
+# var preferences
+csharp_style_var_elsewhere = false:silent
+csharp_style_var_for_built_in_types = false:silent
+csharp_style_var_when_type_is_apparent = false:silent
+
+# Expression-bodied members
+csharp_style_expression_bodied_accessors = true:silent
+csharp_style_expression_bodied_constructors = false:silent
+csharp_style_expression_bodied_indexers = true:silent
+csharp_style_expression_bodied_lambdas = true:suggestion
+csharp_style_expression_bodied_local_functions = false:silent
+csharp_style_expression_bodied_methods = false:silent
+csharp_style_expression_bodied_operators = false:silent
+csharp_style_expression_bodied_properties = true:silent
+
+# Pattern matching preferences
+csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
+csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
+csharp_style_prefer_not_pattern = true:suggestion
+csharp_style_prefer_pattern_matching = true:silent
+csharp_style_prefer_switch_expression = true:suggestion
+
+# Null-checking preferences
+csharp_style_conditional_delegate_call = true:suggestion
+
+# Modifier preferences
+csharp_prefer_static_local_function = true:warning
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:silent
+
+# Code-block preferences
+csharp_prefer_braces = true:silent
+csharp_prefer_simple_using_statement = true:suggestion
+
+# Expression-level preferences
+csharp_prefer_simple_default_expression = true:suggestion
+csharp_style_deconstructed_variable_declaration = true:suggestion
+csharp_style_inlined_variable_declaration = true:suggestion
+csharp_style_pattern_local_over_anonymous_function = true:suggestion
+csharp_style_prefer_index_operator = true:suggestion
+csharp_style_prefer_range_operator = true:suggestion
+csharp_style_throw_expression = true:suggestion
+csharp_style_unused_value_assignment_preference = discard_variable:suggestion
+csharp_style_unused_value_expression_statement_preference = discard_variable:silent
+
+# 'using' directive preferences
+csharp_using_directive_placement = outside_namespace:silent
+
+#### C# Formatting Rules ####
+
+# New line preferences
+csharp_new_line_before_catch = false
+csharp_new_line_before_else = false
+csharp_new_line_before_finally = false
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_open_brace = none
+csharp_new_line_between_query_expression_clauses = true
+
+# Indentation preferences
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents = true
+csharp_indent_case_contents_when_block = true
+csharp_indent_labels = one_less_than_current
+csharp_indent_switch_labels = true
+
+# Space preferences
+csharp_space_after_cast = false
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_after_comma = true
+csharp_space_after_dot = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_around_declaration_statements = false
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_before_comma = false
+csharp_space_before_dot = false
+csharp_space_before_open_square_brackets = false
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_parentheses = false
+csharp_space_between_square_brackets = false
+
+# Wrapping preferences
+csharp_preserve_single_line_blocks = true
+csharp_preserve_single_line_statements = true
+
+#### Naming styles ####
+[*.{cs,vb}]
+
+# Naming rules
+
+dotnet_naming_rule.types_and_namespaces_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.types_and_namespaces_should_be_pascalcase.symbols = types_and_namespaces
+dotnet_naming_rule.types_and_namespaces_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.interfaces_should_be_ipascalcase.severity = suggestion
+dotnet_naming_rule.interfaces_should_be_ipascalcase.symbols = interfaces
+dotnet_naming_rule.interfaces_should_be_ipascalcase.style = ipascalcase
+
+dotnet_naming_rule.type_parameters_should_be_tpascalcase.severity = suggestion
+dotnet_naming_rule.type_parameters_should_be_tpascalcase.symbols = type_parameters
+dotnet_naming_rule.type_parameters_should_be_tpascalcase.style = tpascalcase
+
+dotnet_naming_rule.methods_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.methods_should_be_pascalcase.symbols = methods
+dotnet_naming_rule.methods_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.properties_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.properties_should_be_pascalcase.symbols = properties
+dotnet_naming_rule.properties_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.events_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.events_should_be_pascalcase.symbols = events
+dotnet_naming_rule.events_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.local_variables_should_be_camelcase.severity = suggestion
+dotnet_naming_rule.local_variables_should_be_camelcase.symbols = local_variables
+dotnet_naming_rule.local_variables_should_be_camelcase.style = camelcase
+
+dotnet_naming_rule.local_constants_should_be_camelcase.severity = suggestion
+dotnet_naming_rule.local_constants_should_be_camelcase.symbols = local_constants
+dotnet_naming_rule.local_constants_should_be_camelcase.style = camelcase
+
+dotnet_naming_rule.parameters_should_be_camelcase.severity = suggestion
+dotnet_naming_rule.parameters_should_be_camelcase.symbols = parameters
+dotnet_naming_rule.parameters_should_be_camelcase.style = camelcase
+
+dotnet_naming_rule.public_fields_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.public_fields_should_be_pascalcase.symbols = public_fields
+dotnet_naming_rule.public_fields_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.private_fields_should_be__camelcase.severity = suggestion
+dotnet_naming_rule.private_fields_should_be__camelcase.symbols = private_fields
+dotnet_naming_rule.private_fields_should_be__camelcase.style = _camelcase
+
+dotnet_naming_rule.private_static_fields_should_be_s_camelcase.severity = suggestion
+dotnet_naming_rule.private_static_fields_should_be_s_camelcase.symbols = private_static_fields
+dotnet_naming_rule.private_static_fields_should_be_s_camelcase.style = s_camelcase
+
+dotnet_naming_rule.public_constant_fields_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.public_constant_fields_should_be_pascalcase.symbols = public_constant_fields
+dotnet_naming_rule.public_constant_fields_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.private_constant_fields_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.private_constant_fields_should_be_pascalcase.symbols = private_constant_fields
+dotnet_naming_rule.private_constant_fields_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.public_static_readonly_fields_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.public_static_readonly_fields_should_be_pascalcase.symbols = public_static_readonly_fields
+dotnet_naming_rule.public_static_readonly_fields_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.private_static_readonly_fields_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.private_static_readonly_fields_should_be_pascalcase.symbols = private_static_readonly_fields
+dotnet_naming_rule.private_static_readonly_fields_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.enums_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.enums_should_be_pascalcase.symbols = enums
+dotnet_naming_rule.enums_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.local_functions_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.local_functions_should_be_pascalcase.symbols = local_functions
+dotnet_naming_rule.local_functions_should_be_pascalcase.style = pascalcase
+
+dotnet_naming_rule.non_field_members_should_be_pascalcase.severity = suggestion
+dotnet_naming_rule.non_field_members_should_be_pascalcase.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascalcase.style = pascalcase
+
+# Symbol specifications
+
+dotnet_naming_symbols.interfaces.applicable_kinds = interface
+dotnet_naming_symbols.interfaces.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.interfaces.required_modifiers = 
+
+dotnet_naming_symbols.enums.applicable_kinds = enum
+dotnet_naming_symbols.enums.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.enums.required_modifiers = 
+
+dotnet_naming_symbols.events.applicable_kinds = event
+dotnet_naming_symbols.events.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.events.required_modifiers = 
+
+dotnet_naming_symbols.methods.applicable_kinds = method
+dotnet_naming_symbols.methods.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.methods.required_modifiers = 
+
+dotnet_naming_symbols.properties.applicable_kinds = property
+dotnet_naming_symbols.properties.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.properties.required_modifiers = 
+
+dotnet_naming_symbols.public_fields.applicable_kinds = field
+dotnet_naming_symbols.public_fields.applicable_accessibilities = public, internal
+dotnet_naming_symbols.public_fields.required_modifiers = 
+
+dotnet_naming_symbols.private_fields.applicable_kinds = field
+dotnet_naming_symbols.private_fields.applicable_accessibilities = private, protected, protected_internal, private_protected
+dotnet_naming_symbols.private_fields.required_modifiers = 
+
+dotnet_naming_symbols.private_static_fields.applicable_kinds = field
+dotnet_naming_symbols.private_static_fields.applicable_accessibilities = private, protected, protected_internal, private_protected
+dotnet_naming_symbols.private_static_fields.required_modifiers = static
+
+dotnet_naming_symbols.types_and_namespaces.applicable_kinds = namespace, class, struct, interface, enum
+dotnet_naming_symbols.types_and_namespaces.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.types_and_namespaces.required_modifiers = 
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers = 
+
+dotnet_naming_symbols.type_parameters.applicable_kinds = namespace
+dotnet_naming_symbols.type_parameters.applicable_accessibilities = *
+dotnet_naming_symbols.type_parameters.required_modifiers = 
+
+dotnet_naming_symbols.private_constant_fields.applicable_kinds = field
+dotnet_naming_symbols.private_constant_fields.applicable_accessibilities = private, protected, protected_internal, private_protected
+dotnet_naming_symbols.private_constant_fields.required_modifiers = const
+
+dotnet_naming_symbols.local_variables.applicable_kinds = local
+dotnet_naming_symbols.local_variables.applicable_accessibilities = local
+dotnet_naming_symbols.local_variables.required_modifiers = 
+
+dotnet_naming_symbols.local_constants.applicable_kinds = local
+dotnet_naming_symbols.local_constants.applicable_accessibilities = local
+dotnet_naming_symbols.local_constants.required_modifiers = const
+
+dotnet_naming_symbols.parameters.applicable_kinds = parameter
+dotnet_naming_symbols.parameters.applicable_accessibilities = *
+dotnet_naming_symbols.parameters.required_modifiers = 
+
+dotnet_naming_symbols.public_constant_fields.applicable_kinds = field
+dotnet_naming_symbols.public_constant_fields.applicable_accessibilities = public, internal
+dotnet_naming_symbols.public_constant_fields.required_modifiers = const
+
+dotnet_naming_symbols.public_static_readonly_fields.applicable_kinds = field
+dotnet_naming_symbols.public_static_readonly_fields.applicable_accessibilities = public, internal
+dotnet_naming_symbols.public_static_readonly_fields.required_modifiers = readonly, static
+
+dotnet_naming_symbols.private_static_readonly_fields.applicable_kinds = field
+dotnet_naming_symbols.private_static_readonly_fields.applicable_accessibilities = private, protected, protected_internal, private_protected
+dotnet_naming_symbols.private_static_readonly_fields.required_modifiers = readonly, static
+
+dotnet_naming_symbols.local_functions.applicable_kinds = local_function
+dotnet_naming_symbols.local_functions.applicable_accessibilities = *
+dotnet_naming_symbols.local_functions.required_modifiers = 
+
+# Naming styles
+
+dotnet_naming_style.pascalcase.required_prefix = 
+dotnet_naming_style.pascalcase.required_suffix = 
+dotnet_naming_style.pascalcase.word_separator = 
+dotnet_naming_style.pascalcase.capitalization = pascal_case
+
+dotnet_naming_style.ipascalcase.required_prefix = I
+dotnet_naming_style.ipascalcase.required_suffix = 
+dotnet_naming_style.ipascalcase.word_separator = 
+dotnet_naming_style.ipascalcase.capitalization = pascal_case
+
+dotnet_naming_style.tpascalcase.required_prefix = T
+dotnet_naming_style.tpascalcase.required_suffix = 
+dotnet_naming_style.tpascalcase.word_separator = 
+dotnet_naming_style.tpascalcase.capitalization = pascal_case
+
+dotnet_naming_style._camelcase.required_prefix = _
+dotnet_naming_style._camelcase.required_suffix = 
+dotnet_naming_style._camelcase.word_separator = 
+dotnet_naming_style._camelcase.capitalization = camel_case
+
+dotnet_naming_style.camelcase.required_prefix = 
+dotnet_naming_style.camelcase.required_suffix = 
+dotnet_naming_style.camelcase.word_separator = 
+dotnet_naming_style.camelcase.capitalization = camel_case
+
+dotnet_naming_style.s_camelcase.required_prefix = s_
+dotnet_naming_style.s_camelcase.required_suffix = 
+dotnet_naming_style.s_camelcase.word_separator = 
+dotnet_naming_style.s_camelcase.capitalization = camel_case
+

BMapBindings/BMapSharp/BMapSharp/BMap.cs

@@ -19,12 +19,8 @@ namespace BMapSharp {
 
     public static class BMap {
 
-        /// <summary>The callback function of BMap.</summary>
-        /// <param name="msg">The message content need to be printed.</param>
-        public delegate void OutputCallback([In, MarshalAs(UnmanagedType.LPUTF8Str)] string msg);
+        #region Custom Marshalers
 
-        /// <summary>The custom marshaler for BMap string array.</summary>
-        public class BMStringArrayMarshaler : ICustomMarshaler {
         // References:
         // https://stackoverflow.com/questions/18498452/how-do-i-write-a-custom-marshaler-which-allows-data-to-flow-from-native-to-manag
         // https://learn.microsoft.com/en-us/dotnet/fundamentals/runtime-libraries/system-runtime-interopservices-icustommarshaler
@@ -33,28 +29,40 @@ namespace BMapSharp {
         // Because my binding do not have In, Out parameter. All parameters are In OR Out.
         // So there is no reason to keep that member.
 
-            private static readonly BMStringArrayMarshaler g_Instance = new BMStringArrayMarshaler();
-            public static ICustomMarshaler GetInstance(string pstrCookie) => g_Instance;
+        // IDK why Microsoft try to call ICustomMarshaler.CleanUpNativeData without calling ICustomMarshaler.MarshalManagedToNative.
+        // It is trying to free the pointer managed by LibCmo self (for example, it will try to free we got string when getting object name)!
+        // So as the compromise, we use "cookie" feature to explicit specify the marshaler In/Out behavior when getting it.
+        [Flags]
+        internal enum MarshalerType {
+            None = 0b0,
+            In = 0b1,
+            Out = 0b10
+        }
+
+        /// <summary>The custom marshaler for BMap string array.</summary>
+        public class BMStringArrayMarshaler : ICustomMarshaler {
+            private static readonly BMStringArrayMarshaler g_InInstance = new BMStringArrayMarshaler(MarshalerType.In);
+            private static readonly BMStringArrayMarshaler g_OutInstance = new BMStringArrayMarshaler(MarshalerType.Out);
+            public static ICustomMarshaler GetInstance(string pstrCookie) {
+                if (pstrCookie == "In") return g_InInstance;
+                else if (pstrCookie == "Out") return g_OutInstance;
+                else throw new MarshalDirectiveException("Not supported cookie string for BMStringArrayMarshaler.");
+            }
+
+            private readonly MarshalerType m_MarshalerType;
+            private BMStringArrayMarshaler(MarshalerType marshaler_type) {
+                m_MarshalerType = marshaler_type;
+            }
 
             // For respecting the standard of BMap, 
             // the native memory we created is a simple array and each item is a pointer to a NULL-terminated UTF8 string.
-            // Please note the array self is not NULL-terminated because its length is provided by another argument in function calling.
-            // However, this memory layout is not good for our marshaling.
-            // We can not know the size of array we created. Because we need iterate it when freeing or fetching data.
-            // We also can not know the size of string we created because we need read them when parsing them to C# string.
-            // 
-            // So the solution we made is adding an uint32_t header before the array to indicate the size of array.
-            // And also add an uint32_t header for each string to indicate the length of string (in bytes, NULL exclusive).
-            // So the pointer put in array is not the address we allocated, it has an offset.
-            // Also we return native pointer is not the address we allocated, it also has an offset.
+            // Please note the array self is also NULL-terminated otherwise we don't know its length.
 
-            private static readonly int szLengthHeaderSize = Marshal.SizeOf<int>();
-            private static readonly int szArrayItemSize = Marshal.SizeOf<IntPtr>();
-            private static readonly int szStringItemSize = Marshal.SizeOf<byte>();
-
-            public IntPtr MarshalManagedToNative(object ManagedObj) {
+            public nint MarshalManagedToNative(object ManagedObj) {
+                // Check marshaler type
+                if (!m_MarshalerType.HasFlag(MarshalerType.In)) return nint.Zero;
                 // Check nullptr object.
-                if (ManagedObj is null) return IntPtr.Zero;
+                if (ManagedObj is null) return nint.Zero;
                 // Check argument type.
                 string[] castManagedObj = ManagedObj as string[];
                 if (castManagedObj is null)
@@ -62,97 +70,77 @@ namespace BMapSharp {
 
                 // Allocate string items first
                 int szArrayItemCount = castManagedObj.Length;
-                IntPtr[] apStrings = new IntPtr[szArrayItemCount];
+                int szArrayItemSize = Marshal.SizeOf<nint>();
+                nint[] apString = new nint[szArrayItemCount];
                 for (int i = 0; i < szArrayItemCount; ++i) {
-                    // Encode string first.
-                    byte[] encString = Encoding.UTF8.GetBytes(castManagedObj[i]);
-                    // Allocate string memory with extra NULL terminal.
-                    int szStringItemCount = encString.Length;
-                    IntPtr pString = Marshal.AllocHGlobal(szStringItemSize * (szStringItemCount + 1) + szLengthHeaderSize);
-                    // Setup length field
-                    Marshal.WriteInt32(pString, 0, szStringItemCount);
-                    // Copy string data with offset.
-                    IntPtr pFakeString = pString + szLengthHeaderSize;
-                    Marshal.Copy(encString, 0, pFakeString, szStringItemCount);
-                    // Set NULL terminal.
-                    Marshal.WriteByte(pFakeString, szStringItemSize * szStringItemCount, 0);
-                    // Set item in string pointer
-                    apStrings[i] = pFakeString;
+                    // Check null string
+                    string stringObj = castManagedObj[i];
+                    if (stringObj is null) apString[i] = nint.Zero;
+                    else apString[i] = BMStringMarshaler.ToNative(stringObj);
                 }
 
                 // Allocate array pointer now.
-                IntPtr pArray = Marshal.AllocHGlobal(szArrayItemSize * szArrayItemCount + szLengthHeaderSize);
-                // Setup length field
-                Marshal.WriteInt32(pArray, 0, szArrayItemCount);
-                // Copy string pointer data with offset.
-                IntPtr pFakeArray = pArray + szLengthHeaderSize;
-                Marshal.Copy(apStrings, 0, pFakeArray, szArrayItemCount);
+                nint pArray = Marshal.AllocHGlobal(szArrayItemSize * (szArrayItemCount + 1));
+                // Copy string pointer data
+                Marshal.Copy(apString, 0, pArray, szArrayItemCount);
+                // Setup NULL ternimal
+                Marshal.WriteIntPtr(pArray + (szArrayItemSize * szArrayItemCount), nint.Zero);
 
                 // Return value
-                return pFakeArray;
+                return pArray;
             }
 
-            public object MarshalNativeToManaged(IntPtr pNativeData) {
+            public object MarshalNativeToManaged(nint pNativeData) {
+                // Check marshaler type
+                if (!m_MarshalerType.HasFlag(MarshalerType.Out)) return null;
                 // Check nullptr
-                if (pNativeData == IntPtr.Zero) return null;
+                if (pNativeData == nint.Zero) return null;
 
-                // Get real array pointer
-                IntPtr pFakeArray = pNativeData;
-                IntPtr pArray = pFakeArray - szLengthHeaderSize;
-
-                // Get the count of array and read string pointers
-                int szArrayItemCount = Marshal.ReadInt32(pArray, 0);
-                IntPtr[] apStrings = new IntPtr[szArrayItemCount];
-                Marshal.Copy(pFakeArray, apStrings, 0, szArrayItemCount);
+                // Get the length of array
+                int szArrayItemCount = BMStringArrayMarshaler.GetArrayLength(pNativeData);
+                int szArrayItemSize = Marshal.SizeOf<nint>();
+                // Prepare array cache and read it.
+                nint[] apString = new nint[szArrayItemCount];
+                Marshal.Copy(pNativeData, apString, 0, szArrayItemCount);
 
                 // Iterate the array and process each string one by one.
                 string[] ret = new string[szArrayItemCount];
                 for (int i = 0; i < szArrayItemCount; ++i) {
                     // Get string pointer
-                    IntPtr pFakeString = apStrings[i];
-                    if (pFakeString == IntPtr.Zero) {
+                    nint pString = apString[i];
+                    if (pString == nint.Zero) {
                         ret[i] = null;
                         continue;
                     }
-                    IntPtr pString = pFakeString - szLengthHeaderSize;
-                    // Read string length
-                    int szStringItemCount = Marshal.ReadInt32(pString, 0);
-                    // Read string body
-                    byte[] encString = new byte[szStringItemCount];
-                    Marshal.Copy(pFakeString, encString, 0, szStringItemCount);
-                    // Decode string with UTF8
-                    ret[i] = Encoding.UTF8.GetString(encString);
+                    // Extract string
+                    ret[i] = BMStringMarshaler.ToManaged(pString);
                 }
 
                 // Return result
                 return ret;
             }
 
-            public void CleanUpNativeData(IntPtr pNativeData) {
+            public void CleanUpNativeData(nint pNativeData) {
+                // Check marshaler type
+                if (!m_MarshalerType.HasFlag(MarshalerType.In)) return;
                 // Check nullptr
-                if (pNativeData == IntPtr.Zero) return;
+                if (pNativeData == nint.Zero) return;
 
-                // Get real array pointer
-                IntPtr pFakeArray = pNativeData;
-                IntPtr pArray = pFakeArray - szLengthHeaderSize;
+                // Get the length of array
+                int szArrayItemCount = BMStringArrayMarshaler.GetArrayLength(pNativeData);
+                int szArrayItemSize = Marshal.SizeOf<nint>();
+                // Prepare array cache and read it.
+                nint[] apString = new nint[szArrayItemCount];
+                Marshal.Copy(pNativeData, apString, 0, szArrayItemCount);
+                // Free array self
+                Marshal.FreeHGlobal(pNativeData);
 
-                // Get the count of array and read string pointers
-                int szArrayItemCount = Marshal.ReadInt32(pArray, 0);
-                IntPtr[] apStrings = new IntPtr[szArrayItemCount];
-                Marshal.Copy(pFakeArray, apStrings, 0, szArrayItemCount);
-
-                // Iterate the array and free them one by one.
-                for (int i = 0; i < szArrayItemCount; ++i) {
-                    // Get string pointer
-                    IntPtr pFakeString = apStrings[i];
-                    if (pFakeString == IntPtr.Zero) continue;
-                    IntPtr pString = pFakeString - szLengthHeaderSize;
+                // Iterate the string pointer array and free them one by one.
+                foreach (nint pString in apString) {
                     // Free string pointer
+                    if (pString == nint.Zero) continue;
                     Marshal.FreeHGlobal(pString);
                 }
-
-                // Free array self
-                Marshal.FreeHGlobal(pArray);
             }
 
             public void CleanUpManagedData(object ManagedObj) {
@@ -164,7 +152,131 @@ namespace BMapSharp {
                 return -1;
             }
 
+            /// <summary>
+            /// Return the length of array created by this marshaler.
+            /// </summary>
+            /// <param name="ptr">The pointer to array for checking.</param>
+            /// <returns>The length of array (NULL terminal exclusive).</returns>
+            internal static int GetArrayLength(nint ptr) {
+                int count = 0, unit = Marshal.SizeOf<nint>();
+                while (Marshal.ReadIntPtr(ptr) != nint.Zero) {
+                    ptr += unit;
+                    ++count;
                 }
+                return count;
+            }
+        }
+
+        public class BMStringMarshaler : ICustomMarshaler {
+            private static readonly BMStringMarshaler g_InInstance = new BMStringMarshaler(MarshalerType.In);
+            private static readonly BMStringMarshaler g_OutInstance = new BMStringMarshaler(MarshalerType.Out);
+            public static ICustomMarshaler GetInstance(string pstrCookie) {
+                if (pstrCookie == "In") return g_InInstance;
+                else if (pstrCookie == "Out") return g_OutInstance;
+                else throw new MarshalDirectiveException("Not supported cookie string for BMStringMarshaler.");
+            }
+
+            private readonly MarshalerType m_MarshalerType;
+            private BMStringMarshaler(MarshalerType marshaler_type) {
+                m_MarshalerType = marshaler_type;
+            }
+
+            public nint MarshalManagedToNative(object ManagedObj) {
+                // Check marshaler type
+                if (!m_MarshalerType.HasFlag(MarshalerType.In)) return nint.Zero;
+                // Check requirements.
+                if (ManagedObj is null) return nint.Zero;
+                string castManagedObj = ManagedObj as string;
+                if (castManagedObj is null)
+                    throw new MarshalDirectiveException("BMStringMarshaler must be used on a string.");
+                // Call self
+                return BMStringMarshaler.ToNative(castManagedObj);
+            }
+
+            public object MarshalNativeToManaged(nint pNativeData) {
+                // Check marshaler type
+                if (!m_MarshalerType.HasFlag(MarshalerType.Out)) return null;
+                // Check nullptr
+                if (pNativeData == nint.Zero) return null;
+                // Call self
+                return BMStringMarshaler.ToManaged(pNativeData);
+            }
+
+            public void CleanUpNativeData(nint pNativeData) {
+                // Check marshaler type
+                if (!m_MarshalerType.HasFlag(MarshalerType.In)) return;
+                // Check nullptr
+                if (pNativeData == nint.Zero) return;
+                // Free native pointer
+                Marshal.FreeHGlobal(pNativeData);
+            }
+
+            public void CleanUpManagedData(object ManagedObj) {
+                // Do nothing, because managed data do not need any clean up.
+            }
+
+            public int GetNativeDataSize() {
+                // Return -1 to indicate the managed type this marshaler handles is not a value type.
+                return -1;
+            }
+
+            /// <summary>
+            /// Return the length in byte of given pointer represented C style string.
+            /// </summary>
+            /// <param name="ptr">The pointer for checking.</param>
+            /// <returns>The length of C style string (NUL exclusive).</returns>
+            internal static int GetCStringLength(nint ptr) {
+                int count = 0, unit = Marshal.SizeOf<byte>();
+                while (Marshal.ReadByte(ptr) != (byte)0) {
+                    ptr += unit;
+                    ++count;
+                }
+                return count;
+            }
+            
+            /// <summary>
+            /// Convert given string object to native data.
+            /// This function is shared by 2 marshalers.
+            /// </summary>
+            /// <param name="obj">String object. Caller must make sure this object is not null.</param>
+            /// <returns>The created native data pointer.</returns>
+            internal static nint ToNative(string obj) {
+                // Encode string first
+                byte[] encString = Encoding.UTF8.GetBytes(obj);
+                // Allocate string memory with extra NUL.
+                int szStringItemCount = encString.Length;
+                int szStringItemSize = Marshal.SizeOf<byte>();
+                nint pString = Marshal.AllocHGlobal(szStringItemSize * (szStringItemCount + 1));
+                // Copy encoded string data
+                Marshal.Copy(encString, 0, pString, szStringItemCount);
+                // Setup NUL
+                Marshal.WriteByte(pString + (szStringItemSize * szStringItemCount), (byte)0);
+                // Return value
+                return pString;
+            }
+            /// <summary>
+            /// Extract managed string from given native pointer holding C style string data.
+            /// This function is shared by 2 marshalers.
+            /// </summary>
+            /// <param name="ptr">Native pointer holding string data. Caller must make sure this pointer is not nullptr.</param>
+            /// <returns>The extracted managed string data.</returns>
+            internal static string ToManaged(nint ptr) {
+                // Get the length of given string.
+                int szStringItemCount = BMStringMarshaler.GetCStringLength(ptr);
+                int szStringItemSize = Marshal.SizeOf<byte>();
+                // Prepare cache and copy string data
+                byte[] encString = new byte[szStringItemCount];
+                Marshal.Copy(ptr, encString, 0, szStringItemCount);
+                // Decode string and return
+                return Encoding.UTF8.GetString(encString);
+            }
+        }
+
+        #endregion
+
+        /// <summary>The callback function of BMap.</summary>
+        /// <param name="msg">The message content need to be printed.</param>
+        internal delegate void OutputCallback([In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler))] string msg);
 
         // Decide the file name of loaded DLL.
 
@@ -203,7 +315,7 @@ namespace BMapSharp {
         /// <returns>True if no error, otherwise False.</returns>
         [DllImport(g_DllName, EntryPoint = "BMFile_Load", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
         [return: MarshalAs(UnmanagedType.U1)]
-        internal static extern bool BMFile_Load([In, MarshalAs(UnmanagedType.LPUTF8Str)] string file_name, [In, MarshalAs(UnmanagedType.LPUTF8Str)] string temp_folder, [In, MarshalAs(UnmanagedType.LPUTF8Str)] string texture_folder, [In, MarshalAs(UnmanagedType.FunctionPtr)] OutputCallback raw_callback, [In, MarshalAs(UnmanagedType.U4)] uint encoding_count, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringArrayMarshaler))] string[] encodings, [Out, MarshalAs(UnmanagedType.SysInt)] out IntPtr out_file);
+        internal static extern bool BMFile_Load([In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "In")] string file_name, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "In")] string temp_folder, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "In")] string texture_folder, [In, MarshalAs(UnmanagedType.FunctionPtr)] OutputCallback raw_callback, [In, MarshalAs(UnmanagedType.U4)] uint encoding_count, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringArrayMarshaler), MarshalCookie = "In")] string[] encodings, [Out, MarshalAs(UnmanagedType.SysInt)] out IntPtr out_file);
         /// <summary>BMFile_Create</summary>
         /// <param name="temp_folder">Type: LibCmo::CKSTRING. </param>
         /// <param name="texture_folder">Type: LibCmo::CKSTRING. </param>
@@ -214,7 +326,7 @@ namespace BMapSharp {
         /// <returns>True if no error, otherwise False.</returns>
         [DllImport(g_DllName, EntryPoint = "BMFile_Create", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
         [return: MarshalAs(UnmanagedType.U1)]
-        internal static extern bool BMFile_Create([In, MarshalAs(UnmanagedType.LPUTF8Str)] string temp_folder, [In, MarshalAs(UnmanagedType.LPUTF8Str)] string texture_folder, [In, MarshalAs(UnmanagedType.FunctionPtr)] OutputCallback raw_callback, [In, MarshalAs(UnmanagedType.U4)] uint encoding_count, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringArrayMarshaler))] string[] encodings, [Out, MarshalAs(UnmanagedType.SysInt)] out IntPtr out_file);
+        internal static extern bool BMFile_Create([In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "In")] string temp_folder, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "In")] string texture_folder, [In, MarshalAs(UnmanagedType.FunctionPtr)] OutputCallback raw_callback, [In, MarshalAs(UnmanagedType.U4)] uint encoding_count, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringArrayMarshaler), MarshalCookie = "In")] string[] encodings, [Out, MarshalAs(UnmanagedType.SysInt)] out IntPtr out_file);
         /// <summary>BMFile_Save</summary>
         /// <param name="map_file">Type: BMap::BMFile*. </param>
         /// <param name="file_name">Type: LibCmo::CKSTRING. </param>
@@ -224,7 +336,7 @@ namespace BMapSharp {
         /// <returns>True if no error, otherwise False.</returns>
         [DllImport(g_DllName, EntryPoint = "BMFile_Save", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
         [return: MarshalAs(UnmanagedType.U1)]
-        internal static extern bool BMFile_Save([In, MarshalAs(UnmanagedType.SysInt)] IntPtr map_file, [In, MarshalAs(UnmanagedType.LPUTF8Str)] string file_name, [In, MarshalAs(UnmanagedType.U4)] uint texture_save_opt, [In, MarshalAs(UnmanagedType.U1)] bool use_compress, [In, MarshalAs(UnmanagedType.I4)] int compreess_level);
+        internal static extern bool BMFile_Save([In, MarshalAs(UnmanagedType.SysInt)] IntPtr map_file, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "In")] string file_name, [In, MarshalAs(UnmanagedType.U4)] uint texture_save_opt, [In, MarshalAs(UnmanagedType.U1)] bool use_compress, [In, MarshalAs(UnmanagedType.I4)] int compreess_level);
         /// <summary>BMFile_Free</summary>
         /// <param name="map_file">Type: BMap::BMFile*. </param>
         /// <returns>True if no error, otherwise False.</returns>
@@ -459,7 +571,7 @@ namespace BMapSharp {
         /// <returns>True if no error, otherwise False.</returns>
         [DllImport(g_DllName, EntryPoint = "BMObject_GetName", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
         [return: MarshalAs(UnmanagedType.U1)]
-        internal static extern bool BMObject_GetName([In, MarshalAs(UnmanagedType.SysInt)] IntPtr bmfile, [In, MarshalAs(UnmanagedType.U4)] uint objid, [Out, MarshalAs(UnmanagedType.LPUTF8Str)] out string out_name);
+        internal static extern bool BMObject_GetName([In, MarshalAs(UnmanagedType.SysInt)] IntPtr bmfile, [In, MarshalAs(UnmanagedType.U4)] uint objid, [Out, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "Out")] out string out_name);
         /// <summary>BMObject_SetName</summary>
         /// <param name="bmfile">Type: BMap::BMFile*. The pointer to corresponding BMFile.</param>
         /// <param name="objid">Type: LibCmo::CK2::CK_ID. The CKID of object you accessing.</param>
@@ -467,7 +579,7 @@ namespace BMapSharp {
         /// <returns>True if no error, otherwise False.</returns>
         [DllImport(g_DllName, EntryPoint = "BMObject_SetName", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
         [return: MarshalAs(UnmanagedType.U1)]
-        internal static extern bool BMObject_SetName([In, MarshalAs(UnmanagedType.SysInt)] IntPtr bmfile, [In, MarshalAs(UnmanagedType.U4)] uint objid, [In, MarshalAs(UnmanagedType.LPUTF8Str)] string name);
+        internal static extern bool BMObject_SetName([In, MarshalAs(UnmanagedType.SysInt)] IntPtr bmfile, [In, MarshalAs(UnmanagedType.U4)] uint objid, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "In")] string name);
         /// <summary>BMGroup_AddObject</summary>
         /// <param name="bmfile">Type: BMap::BMFile*. The pointer to corresponding BMFile.</param>
         /// <param name="objid">Type: LibCmo::CK2::CK_ID. The CKID of object you accessing.</param>
@@ -500,7 +612,7 @@ namespace BMapSharp {
         /// <returns>True if no error, otherwise False.</returns>
         [DllImport(g_DllName, EntryPoint = "BMTexture_GetFileName", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
         [return: MarshalAs(UnmanagedType.U1)]
-        internal static extern bool BMTexture_GetFileName([In, MarshalAs(UnmanagedType.SysInt)] IntPtr bmfile, [In, MarshalAs(UnmanagedType.U4)] uint objid, [Out, MarshalAs(UnmanagedType.LPUTF8Str)] out string out_filename);
+        internal static extern bool BMTexture_GetFileName([In, MarshalAs(UnmanagedType.SysInt)] IntPtr bmfile, [In, MarshalAs(UnmanagedType.U4)] uint objid, [Out, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "Out")] out string out_filename);
         /// <summary>BMTexture_LoadImage</summary>
         /// <param name="bmfile">Type: BMap::BMFile*. The pointer to corresponding BMFile.</param>
         /// <param name="objid">Type: LibCmo::CK2::CK_ID. The CKID of object you accessing.</param>
@@ -508,7 +620,7 @@ namespace BMapSharp {
         /// <returns>True if no error, otherwise False.</returns>
         [DllImport(g_DllName, EntryPoint = "BMTexture_LoadImage", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
         [return: MarshalAs(UnmanagedType.U1)]
-        internal static extern bool BMTexture_LoadImage([In, MarshalAs(UnmanagedType.SysInt)] IntPtr bmfile, [In, MarshalAs(UnmanagedType.U4)] uint objid, [In, MarshalAs(UnmanagedType.LPUTF8Str)] string filename);
+        internal static extern bool BMTexture_LoadImage([In, MarshalAs(UnmanagedType.SysInt)] IntPtr bmfile, [In, MarshalAs(UnmanagedType.U4)] uint objid, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "In")] string filename);
         /// <summary>BMTexture_SaveImage</summary>
         /// <param name="bmfile">Type: BMap::BMFile*. The pointer to corresponding BMFile.</param>
         /// <param name="objid">Type: LibCmo::CK2::CK_ID. The CKID of object you accessing.</param>
@@ -516,7 +628,7 @@ namespace BMapSharp {
         /// <returns>True if no error, otherwise False.</returns>
         [DllImport(g_DllName, EntryPoint = "BMTexture_SaveImage", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
         [return: MarshalAs(UnmanagedType.U1)]
-        internal static extern bool BMTexture_SaveImage([In, MarshalAs(UnmanagedType.SysInt)] IntPtr bmfile, [In, MarshalAs(UnmanagedType.U4)] uint objid, [In, MarshalAs(UnmanagedType.LPUTF8Str)] string filename);
+        internal static extern bool BMTexture_SaveImage([In, MarshalAs(UnmanagedType.SysInt)] IntPtr bmfile, [In, MarshalAs(UnmanagedType.U4)] uint objid, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = "In")] string filename);
         /// <summary>BMTexture_GetSaveOptions</summary>
         /// <param name="bmfile">Type: BMap::BMFile*. The pointer to corresponding BMFile.</param>
         /// <param name="objid">Type: LibCmo::CK2::CK_ID. The CKID of object you accessing.</param>

BMapBindings/BMapSharp/BMapSharp/BMapWrapper.cs

@@ -229,7 +229,7 @@ namespace BMapSharp.BMapWrapper {
             BMapException.ThrowIfFailed(BMap.BMFile_GetMeshCount(this.getPointer(), out uint out_count));
             return out_count;
         }
-        public IEnumerable<BMMesh> GetMeshs() {
+        public IEnumerable<BMMesh> GetMeshes() {
             uint count = GetMeshCount();
             for (uint i = 0; i < count; ++i) {
                 BMapException.ThrowIfFailed(BMap.BMFile_GetMesh(this.getPointer(), i, out uint out_id));

BMapBindings/BMapSharp/BMapSharpTestbench/BMapSharpTestbench.csproj

@@ -1,10 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
+  <ItemGroup>
+    <ProjectReference Include="..\BMapSharp\BMapSharp.csproj" />
+  </ItemGroup>
+
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
   </PropertyGroup>
 
 </Project>

BMapBindings/BMapSharp/BMapSharpTestbench/Program.cs

@@ -1,12 +1,58 @@
 using System;
+using System.Text;
+
+namespace BMapSharpTestbench {
+    internal class Program {
+        static void Main(string[] args) {
+            // Check environment
+            Console.OutputEncoding = Encoding.UTF8;
+            if (!BMapSharp.BMapWrapper.Utils.IsBMapAvailable()) {
+                Console.WriteLine("Fail to initialize native BMap.");
+                Environment.Exit(0);
+            }
+
+            // Waiting debugger
+            int pid = System.Diagnostics.Process.GetCurrentProcess().Id;
+            Console.WriteLine($"C# PID is {pid}. Waiting debugger, press any key to continue...");
+            Console.ReadKey(true);
+
+            // Start testbench
+            string file_name = "Level_02.NMO";
+            string temp_folder = "Temp";
+            string texture_folder = "F:\\Ballance\\Ballance\\Textures";
+            string[] encodings = ["cp1252", "gb2312"];
+
+            using (var reader = new BMapSharp.BMapWrapper.BMFileReader(file_name, temp_folder, texture_folder, encodings)) {
+                Console.WriteLine("===== Groups =====");
+                foreach (var gp in reader.GetGroups()) {
+                    Console.WriteLine(gp.GetName());
+                }
+
+                Console.WriteLine("===== 3dObjects =====");
+                foreach (var obj in reader.Get3dObjects()) {
+                    Console.WriteLine(obj.GetName());
+                }
+
+                Console.WriteLine("===== Meshes =====");
+                foreach (var mesh in reader.GetMeshes()) {
+                    Console.WriteLine(mesh.GetName());
+                }
+
+                Console.WriteLine("===== Materials =====");
+                foreach (var mtl in reader.GetMaterials()) {
+                    Console.WriteLine(mtl.GetName());
+                }
+
+                Console.WriteLine("===== Textures =====");
+                foreach (var tex in reader.GetTextures()) {
+                    Console.WriteLine(tex.GetName());
+                }
+
+            }
+
+            Console.WriteLine("===== Done =====");
+            Console.ReadKey(true);
 
-namespace BMapSharpTestbench // Note: actual namespace depends on the project name.
-{
-    internal class Program
-    {
-        static void Main(string[] args)
-        {
-            Console.WriteLine("Hello World!");
         }
     }
 }

BMapBindings/PyBMap/testbench.py

@@ -13,7 +13,7 @@ def main() -> None:
         for gp in reader.get_groups():
             print(gp.get_name())
 
-        print('===== Objects =====')
+        print('===== 3dObjects =====')
         for obj in reader.get_3dobjects():
             print(obj.get_name())
         

CodeGen/BMapBindings/CSharpWriter.java

@@ -45,14 +45,22 @@ public class CSharpWriter {
 		// use "switch" to check variable type
 		switch (vt_base_type) {
 		case "CKSTRING":
+			// decide direction cookies
+			String direction_cookie = "";
+			if (paramdecl.mIsInput) {
+				direction_cookie = "In";
+			} else {
+				direction_cookie = "Out";
+			}
 			// only allow 0 and 1 pointer level for string.
 			switch (vt_pointer_level) {
 			case 0:
-				ret.mMarshalAs = "UnmanagedType.LPUTF8Str";
+				ret.mMarshalAs = "UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringMarshaler), MarshalCookie = \"" + direction_cookie + "\"";
+				// ret.mMarshalAs = "UnmanagedType.LPUTF8Str";
 				ret.mCsType = "string";
 				break;
 			case 1:
-				ret.mMarshalAs = "UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringArrayMarshaler)";
+				ret.mMarshalAs = "UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(BMStringArrayMarshaler), MarshalCookie = \"" + direction_cookie + "\"";
 				ret.mCsType = "string[]";
 				break;
 			}