Beispiel #1
0
        //
        // ManagedTypeInvokeFromManagedType
        //
        // This managed representation is used when invoking managed methods
        //
        // Generates a managed type alias from a given managed type.
        // This may be as simple as :System.String -> string.
        // or it may be more complex like:
        // IEnumerator`1<KeyValuePair`2<System.String, System.Int32>> ->
        // IEnumerator`1<KeyValuePair`2<string, int>>
        //
        public string ManagedTypeInvokeFromManagedType(string managedType)
        {
            StringBuilder result = new StringBuilder(managedType);

            foreach (KeyValuePair <string, ManagedTypeAssociation> entry in ManagedTypeAssociations)
            {
                ManagedTypeAssociation mta = entry.Value;

                string replacementType = mta.ManagedTypeInvoke;

                /*if (mta.ManagedTypeInvoke != null)
                 * {
                 * replacementType = mta.ManagedTypeInvoke;
                 * } else if (mta.ManagedTypeAlias != null)
                 * {
                 * replacementType = mta.ManagedTypeAlias;
                 * }*/

                if (replacementType != null)
                {
                    result.Replace(mta.ManagedType, replacementType);
                }
            }

            return(result.ToString());
        }
        //
        // ObjCValueToManaged
        //
        // Return an ObjC expression that converts an ObjC object to its corresponding managed representation
        //
        public string ObjCValueToManaged(string objCVarName, string objCTypeDecl, CodeFacet managedFacet)
        {
            string exp = null;

            // extract type info in a format suitable for association
            string managedType = ManagedTypeForAssociation(managedFacet);

            // if type is an enum then use its underlying type
            if (managedFacet.IsEnum)
            {
                managedType = managedFacet.UnderlyingType;
            }

            // retrieve an ObjCTypeAssociation for the given managedType
            string key = ObjCTypeAssociation.UniqueTypeName(objCTypeDecl, managedType);

            if (ManagedTypeAssociations.ContainsKey(key))
            {
                ManagedTypeAssociation managedTypeAssoc = ManagedTypeAssociations[key];
                ObjCTypeAssociation    objCTypeAssoc    = ObjCTypeAssociations[managedType];

                // use the value object format specifier if available
                string setterFormat = objCTypeAssoc.SetterFormat;
                if (setterFormat != null)
                {
                    if (managedFacet.IsPointer)
                    {
                        setterFormat = "&{0}";
                    }
                    exp = string.Format(setterFormat, objCVarName);
                }

                // use custom method
                else if (objCTypeAssoc.SetterMethod != null)
                {
                    string     methodName = objCTypeAssoc.SetterMethod;
                    Type       type       = GetType();
                    MethodInfo method     = type.GetMethod(methodName);
                    if (method != null)
                    {
                        exp = (string)method.Invoke(this, new object[] { objCVarName, objCTypeDecl });
                    }
                }
            }

            // no ObjC expression defined.
            // generate default object representation expression.
            if (exp == null)
            {
                if (ObjCRepresentationIsPrimitive(managedFacet))
                {
                    exp = string.Format("&{0}", objCVarName);
                }
                else
                {
                    exp = string.Format("[{0} monoObject]", objCVarName);
                }
            }
            return(exp);
        }
Beispiel #3
0
        //
        // AssociateTypes()
        //
        void AssociateTypes(ManagedTypeAssociation managedTA, ObjCTypeAssociation objcTA)
        {
            objcTA.ManagedTypeAssociate = managedTA;

            // 1:1 association from managed type to objc type
            // the managed type name key is undecorated
            ObjCTypeAssociations.Add(managedTA.ManagedType, objcTA);

            // 1:N association from objc declaration to managed type.
            // hence we qualify the objc declaration with the managed type name.
            string objCKey = objcTA.UniqueTypeNameForManagedType(managedTA.ManagedType);

            ManagedTypeAssociations.Add(objCKey, managedTA);
        }
        private void ProcessParameters(Net2ObjC n2c, EventFacet facet, Dictionary <string, object> options = null)
        {
            int idx    = 0;
            int idxMax = facet.Parameters.Count > 0 ? facet.Parameters.Count - 1 : 0;

            foreach (ParameterFacet parameter in facet.Parameters)
            {
                // Known issues:
                //
                // 1. Rendering of T[]& fails as in System.Array:Resize<T>(ref T[], int)
                // <Parameter Name="array" Type="T[]&" ElementType="T[]" IsByRef="True" ContainsGenericParameters="True"/>
                // Issue : T[]& renders as T**
                // Workaround: exclude in config.objc.xml like so <string>System.Array:Resize</string>
                // Suggested fix: provide a separate Element xml element to detail the ElementType more fully.

                // if the mono parameters is passed by ref then strip
                // the suffix to enable type association
                string monoParameterType = parameter.Type;
                if (parameter.IsByRef || parameter.IsPointer)
                {
                    monoParameterType = parameter.ElementType;
                }

                //
                // build the ObjC method interleaved parameter representation
                // eg: name1:(int32_t)p1 name2:(int64_t)p2 name3:(NSString *)p3
                //
                string objCParamTypeDecl     = null;
                bool   objCParameterIsObject = true;

                //
                // Get the ObjC type associated with the parameter.
                //
                ObjCTypeAssociation    objCTypeAssociate    = n2c.ObjCTypeAssociate(parameter);
                ManagedTypeAssociation managedTypeAssociate = null;
                if (objCTypeAssociate != null)
                {
                    //
                    // If the parameter is an array, say Int64[], then its Obj-C rep will be System.Array
                    // The mono type association however must reflect the represented type, Int64.
                    //
                    if (parameter.IsArray)
                    {
                        ObjCTypeAssociation objCRepresentedTypeAssociate = n2c.ObjCTypeAssociate(parameter.ElementType);
                        if (objCRepresentedTypeAssociate != null)
                        {
                            managedTypeAssociate = objCRepresentedTypeAssociate.ManagedTypeAssociate;
                        }
                    }

                    if (managedTypeAssociate == null)
                    {
                        managedTypeAssociate = objCTypeAssociate.ManagedTypeAssociate;
                    }

                    objCParamTypeDecl     = objCTypeAssociate.ObjCTypeDecl;
                    objCParameterIsObject = objCTypeAssociate.IsNSObject;
                }
                else
                {
                    //
                    // Generate default objC representations
                    //
                    objCParamTypeDecl     = n2c.ObjCTypeDeclFromManagedFacet(parameter);
                    objCParameterIsObject = n2c.ObjCRepresentationIsObject(parameter);
                }

                ObjCEventBlockParameterGetters[idx] = objCTypeAssociate?.GetterFormat ?? string.Empty;

                // if parameter is an interface then use adoption conforming type ie: id <typename>
                if (parameter.IsInterface)
                {
                    objCParamTypeDecl = n2c.ObjCConformingTypeFromObjCTypeDecl(objCParamTypeDecl, false);
                }
                if (parameter.IsByRef || parameter.IsPointer)
                {
                    objCParamTypeDecl += "*";                       // add additional indirection
                }

                //
                // Build the mono method argument invocation signature
                //
                if (idx > 0)
                {
                    MonoSigBuilder.Append(",");
                }
                string monoParameterTypeInvoke = null;

                // if type is a GenericParameter defined by the class, as opposed to via a method like so Method<T>(T).
                // in this case we want to identify the parameter by its position as this makes it simple
                // to build the required signature at run time
                if (parameter.IsGenericParameter && !parameter.DeclaredByMethod)
                {
                    // generic parameters must have an associate
                    if (managedTypeAssociate == null)
                    {
                        throw new Exception("Missing managed type association for generic parameter.");
                    }

                    monoParameterTypeInvoke = managedTypeAssociate.ManagedTypeInvoke;
                    if (parameter.IsArray)
                    {
                        monoParameterTypeInvoke += "[]";
                    }

                    // in order for the C api to substitute the correct type at run time
                    // the generic parameter position needs to be indicated.
                    monoParameterTypeInvoke = string.Format(monoParameterTypeInvoke, parameter.GenericParameterPosition);
                }

                // if parameter is declared by the method like so Method<T>(T) then we want to preserve the type name
                // as this constitutes part of the method signature this is used to lookup the generic method for inflation
                else if (parameter.IsGenericParameter && parameter.DeclaredByMethod)
                {
                    // we expect to be operating on a generic method definition
                    if (!facet.IsGenericMethodDefinition)
                    {
                        throw new Exception("Generic method definition expected.");
                    }

                    // the type sig will be something like Declaring.Type+T but the embedded API sig
                    // uses just the type parameter name T
                    int symbolIndex = monoParameterType.IndexOf('+');
                    if (symbolIndex == -1)
                    {
                        throw new Exception("Missing nested type symbol for generic parameter.");
                    }
                    monoParameterTypeInvoke = monoParameterType.Substring(symbolIndex + 1);
                    if (parameter.IsArray)
                    {
                        monoParameterTypeInvoke += "[]";
                    }
                }
                else
                {
                    monoParameterTypeInvoke = n2c.ManagedTypeInvokeFromManagedType(monoParameterType);
                }

                // Note that we use a separate variable to hold the actual type sig used in the in mono_method_desc call
                // as the signature may need to be specfically modified for the mono_method_desc API.
                string monoParameterTypeInvoke_ = monoParameterTypeInvoke;

                // The mono_method_desc * APIs prefix nested classes with a '/' rather than a '+' to conform with IL/CTS conventions
                // The approach used here is trivial and is likely fragile.
                // We probably need a separate mono param type builder like that found in debug-helpers.c append_class_name().
                // Note that Delegates will present as nested classes.
                // Also note that although we have an IsNested property we shouldn't use it as a conditional test for this operation
                // as generic types with nested type paramaters such as System.Collections.Generic.IEnumerable`1<A.B+C>
                // won't identify as nested.
                monoParameterTypeInvoke_ = monoParameterTypeInvoke_.Replace("+", "/");

                // add type signature and access modifier
                MonoSigBuilder.Append(monoParameterTypeInvoke_);
                if (parameter.IsPointer)
                {
                    MonoSigBuilder.Append("*");
                }
                if (parameter.IsByRef)
                {
                    MonoSigBuilder.Append("&"); // the signature needs to express by ref
                }

                // Build ObjC parameter name.
                // In order to represent overloaded methods effectively the
                // ObjC paramter name is constructed as follows:
                // Managed parameter name + Managed parameter type + Ref
                string objCParamName = ObjCIdentifierFromManagedIdentifier(parameter.Name);

                // If the method is overloaded by parameter then make the ObjC method
                // name unique by including type info in the name.
                //
                // Managed methods are overloaded by name only.
                // The Obj-C metjods representation uses interleaved parameters which may
                // be sufficient to produce a unique method signature.
                //
                // If however a managed method overload differs only in the type of its parameters
                // (the managed method name, parameter count and parameter names all being equal)
                // then the Obj-C interleaved parameters will include type info.
                string objCParamOverloadSuffix = "";
                if (facet.IsOverloadedParameterMethod)
                {
                    // We adopt a minimal as opposed to a full type repesentation here in order
                    // to minimize the parameter length.
                    // Time will tell how it flies.
                    objCParamOverloadSuffix = n2c.ObjCMinimalIdentifierFromManagedIdentifier(monoParameterTypeInvoke);

                    if (parameter.IsArray)
                    {
                        objCParamOverloadSuffix += "Array";
                    }

                    if (parameter.IsPointer)
                    {
                        objCParamOverloadSuffix += "Ptr";
                    }
                }
                if (parameter.IsByRef)
                {
                    objCParamOverloadSuffix += "Ref";
                }

                if (objCParamOverloadSuffix.Length > 0)
                {
                    objCParamName += objCParamOverloadSuffix.FirstCharacterToUpper();
                }

                // append the complete interleaved parameter expression
                if (idx == 0)
                {
                    if (n2c.AppendFirstArgSignatureToMethodName)
                    {
                        // the leading underscore helps identify the preceding characters as the managed method name
                        ObjCMethodName += "_with";
                        ObjCParameterBuilder.AppendFormat("{0}", objCParamName.FirstCharacterToUpper());
                    }
                }
                else
                {
                    ObjCParameterBuilder.AppendFormat(" {0}", objCParamName.FirstCharacterToLower());
                }
                ObjCParameterBuilder.AppendFormat(":({0})p{1}", objCParamTypeDecl, idx + 1);

                // build C parameter list
                string cParamDelim = idxMax > 0 && idx < idxMax ? ", " : "";
                CParameterBuilder.AppendFormat($"{objCParamTypeDecl} {objCParamName.FirstCharacterToLower()}{cParamDelim}");

                idx++;
            }
        }
Beispiel #5
0
        //
        // AssociateTypes()
        //
        void AssociateTypes(ManagedTypeAssociation managedTA, ObjCTypeAssociation objcTA)
        {
            objcTA.ManagedTypeAssociate = managedTA;

            // 1:1 association from managed type to objc type
            // the managed type name key is undecorated
            ObjCTypeAssociations.Add(managedTA.ManagedType, objcTA);

            // 1:N association from objc declaration to managed type.
            // hence we qualify the objc declaration with the managed type name.
            string objCKey = objcTA.UniqueTypeNameForManagedType(managedTA.ManagedType);
            ManagedTypeAssociations.Add(objCKey, managedTA);
        }
Beispiel #6
0
        //
        // BuildTypeAssociations()
        //
        // Provide associations between ObjC and managed types.
        //
        // The managed built in types require that their aliases be used when
        // constructing method signatures.
        // Built in type list: http://msdn.microsoft.com/en-us/library/ya5y69ds.aspx
        // 
        // See source mono/metadata/debug-helpers.c find_system_class (const char *name)
        // https://github.com/mono/mono/blob/master/mono/metadata/debug-helpers.c#L90
        //
        void BuildTypeAssociations()
        {
            ObjCTypeAssociations = new Dictionary<string, ObjCTypeAssociation>();
            ManagedTypeAssociations = new Dictionary<string, ManagedTypeAssociation>();

            ObjCTypeAssociation objcTA = null;
            ManagedTypeAssociation manTA = null;

            //===============================================================================================
            // reference types
            //===============================================================================================

            // generic parameter
            manTA = new ManagedTypeAssociation { ManagedType = GenericTypePlaceholder };
            objcTA = new ObjCTypeAssociation { ObjCType = "System_Object", GetterFormat = "[System_Object subclassObjectWithMonoObject:{0}]" };
            AssociateTypes(manTA, objcTA);

            // System.Object
            manTA = new ManagedTypeAssociation { ManagedType = "System.Object", ManagedTypeAlias = "object" };
            objcTA = new ObjCTypeAssociation { ObjCType = "System_Object", GetterFormat = "[System_Object objectWithMonoObject:{0}]" };
            AssociateTypes(manTA, objcTA);

            // System.String
            manTA = new ManagedTypeAssociation { ManagedType = "System.String", ManagedTypeAlias = "string" };
            objcTA = new ObjCTypeAssociation { ObjCType = "NSString", GetterFormat = "[NSString stringWithMonoString:DB_STRING({0})]" };
            AssociateTypes(manTA, objcTA);

            // System.Array
            manTA = new ManagedTypeAssociation { ManagedType = "System.Array"};
            objcTA = new ObjCTypeAssociation { ObjCType = "DBSystem_Array", GetterFormat = "[DBSystem_Array arrayWithMonoArray:DB_ARRAY({0})]" };
            AssociateTypes(manTA, objcTA);

            // System.Collections.ArrayList
            manTA = new ManagedTypeAssociation { ManagedType = "System.Collections.ArrayList" };
            objcTA = new ObjCTypeAssociation { ObjCType = "DBSystem_Collections_ArrayList", GetterFormat = "[DBSystem_Collections_ArrayList listWithMonoObject:{0}]" };
            AssociateTypes(manTA, objcTA);

            // System.Collections.Generic.List
            manTA = new ManagedTypeAssociation { ManagedType = "System.Collections.Generic.List`1" };
            objcTA = new ObjCTypeAssociation { ObjCType = "DBSystem_Collections_Generic_ListA1" };
            AssociateTypes(manTA, objcTA);

            // System.Collections.Generic.Dictionary
            manTA = new ManagedTypeAssociation { ManagedType = "System.Collections.Generic.Dictionary`2" };
            objcTA = new ObjCTypeAssociation { ObjCType = "DBSystem_Collections_Generic_DictionaryA2" };
            AssociateTypes(manTA, objcTA);

            // System.Byte[]
            manTA = new ManagedTypeAssociation { ManagedType = "System.Byte[]" };
            objcTA = new ObjCTypeAssociation { ObjCType = "NSData", GetterFormat = "[NSData dataWithMonoArray:DB_ARRAY({0})]" };
            AssociateTypes(manTA, objcTA);

            // ObjectSet
            manTA = new ManagedTypeAssociation { ManagedType = "System.Data.Entity.Core.Objects.ObjectSet`1"};
            objcTA = new ObjCTypeAssociation { ObjCType = "DBSystem_Data_Entity_Core_Objects_ObjectSetA1", GetterFormat = "[DBSystem_Data_Entity_Core_Objects_ObjectSetA1 objectSetWithMonoObject:{0}]" };
            AssociateTypes(manTA, objcTA);

            // ObjectContext
            manTA = new ManagedTypeAssociation { ManagedType = "System.Data.Entity.Core.Objects.ObjectContext" };
            objcTA = new ObjCTypeAssociation { ObjCType = "DBSystem_Data_Entity_Core_Objects_ObjectContext" };
            AssociateTypes(manTA, objcTA);

            //===============================================================================================
            // value types
            //===============================================================================================

            // System.ValueType - struct
            manTA = new ManagedTypeAssociation { ManagedType = "System.ValueType" };
            objcTA = new ObjCTypeAssociation { ObjCType = "DBManagedObject", GetterFormat = "[DBManagedObject objectWithMonoObject:{0}]" };
            AssociateTypes(manTA, objcTA);

            // System.Void
            manTA = new ManagedTypeAssociation { ManagedType = "System.Void", ManagedTypeAlias = "void"};
            objcTA = new ObjCTypeAssociation { ObjCType = "void", GetterFormat = "" };
            AssociateTypes(manTA, objcTA);

            // System.Int64
            manTA = new ManagedTypeAssociation { ManagedType = "System.Int64", ManagedTypeAlias = "long"};
            objcTA = new ObjCTypeAssociation { ObjCType = "int64_t", GetterFormat = "DB_UNBOX_INT64({0})" };
            AssociateTypes(manTA, objcTA);

            // System.Int32
            manTA = new ManagedTypeAssociation { ManagedType = "System.Int32", ManagedTypeAlias = "int"};
            objcTA = new ObjCTypeAssociation { ObjCType = "int32_t", GetterFormat = "DB_UNBOX_INT32({0})" };
            AssociateTypes(manTA, objcTA);

            // System.Int16
            manTA = new ManagedTypeAssociation { ManagedType = "System.Int16", ManagedTypeAlias = "short", ManagedTypeInvoke = "int16"};
            objcTA = new ObjCTypeAssociation { ObjCType = "int16_t", GetterFormat = "DB_UNBOX_INT16({0})" };
            AssociateTypes(manTA, objcTA);

            // System.SByte
            manTA = new ManagedTypeAssociation { ManagedType = "System.SByte", ManagedTypeAlias = "sbyte"};
            objcTA = new ObjCTypeAssociation { ObjCType = "int8_t", GetterFormat = "DB_UNBOX_INT8({0})" };
            AssociateTypes(manTA, objcTA);

            // System.IntPtr
            manTA = new ManagedTypeAssociation { ManagedType = "System.IntPtr", ManagedTypeInvoke = "intptr" };
            objcTA = new ObjCTypeAssociation { ObjCType = "void *", GetterFormat = "DB_UNBOX_PTR({0})" };
            AssociateTypes(manTA, objcTA);

            // System.UInt64
            manTA = new ManagedTypeAssociation { ManagedType = "System.UInt64", ManagedTypeAlias = "ulong"};
            objcTA = new ObjCTypeAssociation { ObjCType = "uint64_t", GetterFormat = "DB_UNBOX_UINT64({0})" };
            AssociateTypes(manTA, objcTA);
            
            // System.UInt32
            manTA = new ManagedTypeAssociation { ManagedType = "System.UInt32", ManagedTypeAlias = "uint"};
            objcTA = new ObjCTypeAssociation { ObjCType = "uint32_t", GetterFormat = "DB_UNBOX_UINT32({0})" };
            AssociateTypes(manTA, objcTA);

            // System.UInt16
            manTA = new ManagedTypeAssociation { ManagedType = "System.UInt16", ManagedTypeAlias = "ushort", ManagedTypeInvoke = "uint16" };
            objcTA = new ObjCTypeAssociation { ObjCType = "uint16_t", GetterFormat = "DB_UNBOX_UINT16({0})" };
            AssociateTypes(manTA, objcTA);

            // System.Byte
            manTA = new ManagedTypeAssociation { ManagedType = "System.Byte", ManagedTypeAlias = "byte" };
            objcTA = new ObjCTypeAssociation { ObjCType = "uint8_t", GetterFormat = "DB_UNBOX_UINT8({0})" };
            AssociateTypes(manTA, objcTA);

            // System.UIntPtr
            manTA = new ManagedTypeAssociation { ManagedType = "System.UIntPtr", ManagedTypeInvoke = "uintptr" };
            objcTA = new ObjCTypeAssociation { ObjCType = "void *", GetterFormat = "DB_UNBOX_UPTR({0})" };
            AssociateTypes(manTA, objcTA);

            // System.Char
            manTA = new ManagedTypeAssociation { ManagedType = "System.Char", ManagedTypeAlias = "char" };
            objcTA = new ObjCTypeAssociation { ObjCType = "uint16_t", GetterFormat = "DB_UNBOX_UINT16({0})" };
            AssociateTypes(manTA, objcTA);

            // System.Double
            manTA = new ManagedTypeAssociation { ManagedType = "System.Double", ManagedTypeAlias = "double" };
            objcTA = new ObjCTypeAssociation { ObjCType = "double", GetterFormat = "DB_UNBOX_DOUBLE({0})" };
            AssociateTypes(manTA, objcTA);

            // System.Single
            manTA = new ManagedTypeAssociation { ManagedType = "System.Single", ManagedTypeAlias = "float", ManagedTypeInvoke = "single" };
            objcTA = new ObjCTypeAssociation { ObjCType = "float", GetterFormat = "DB_UNBOX_FLOAT({0})" };
            AssociateTypes(manTA, objcTA);

            // System.Boolean
            manTA = new ManagedTypeAssociation { ManagedType = "System.Boolean", ManagedTypeAlias = "bool" };
            objcTA = new ObjCTypeAssociation { ObjCType = "BOOL", GetterFormat = "DB_UNBOX_BOOLEAN({0})" };
            AssociateTypes(manTA, objcTA);

            // System.DateTime
            manTA = new ManagedTypeAssociation { ManagedType = "System.DateTime" };
            objcTA = new ObjCTypeAssociation { ObjCType = "NSDate", GetterFormat = "[NSDate dateWithMonoDateTime:{0}]" };
            AssociateTypes(manTA, objcTA);

            // System.Decimal
            manTA = new ManagedTypeAssociation { ManagedType = "System.Decimal", ManagedTypeAlias = "decimal" };
            objcTA = new ObjCTypeAssociation { ObjCType = "NSDecimalNumber", GetterFormat = "[NSDecimalNumber decimalNumberWithMonoDecimal:{0}]" };
            AssociateTypes(manTA, objcTA);

            // System.Enum
            manTA = new ManagedTypeAssociation { ManagedType = "System.Enum" };
            objcTA = new ObjCTypeAssociation { ObjCType = "DBSystem_Enum", GetterFormat = "[DBSystem_Enum objectWithMonoObject:{0}]" };
            AssociateTypes(manTA, objcTA);
        }
Beispiel #7
0
        //
        // BuildTypeAssociations()
        //
        // Provide associations between ObjC and managed types.
        //
        // The managed built in types require that their aliases be used when
        // constructing method signatures.
        // Built in type list: http://msdn.microsoft.com/en-us/library/ya5y69ds.aspx
        //
        // See source mono/metadata/debug-helpers.c find_system_class (const char *name)
        // https://github.com/mono/mono/blob/master/mono/metadata/debug-helpers.c#L90
        //
        void BuildTypeAssociations()
        {
            ObjCTypeAssociations    = new Dictionary <string, ObjCTypeAssociation>();
            ManagedTypeAssociations = new Dictionary <string, ManagedTypeAssociation>();

            ObjCTypeAssociation    objcTA = null;
            ManagedTypeAssociation manTA  = null;

            //===============================================================================================
            // reference types
            //===============================================================================================

            // generic parameter
            manTA = new ManagedTypeAssociation {
                ManagedType = GenericTypePlaceholder
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "System_Object", GetterFormat = "[System_Object bestObjectWithMonoObject:{0}]"
            };
            AssociateTypes(manTA, objcTA);

            // System.Object
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Object", ManagedTypeAlias = "object"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "System_Object", GetterFormat = "[System_Object bestObjectWithMonoObject:{0}]"
            };
            AssociateTypes(manTA, objcTA);

            // System.String
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.String", ManagedTypeAlias = "string"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "NSString", GetterFormat = "[NSString stringWithMonoString:DB_STRING({0})]"
            };
            AssociateTypes(manTA, objcTA);

            // System.Array
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Array"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "System_Array", GetterFormat = "[System_Array arrayWithMonoArray:DB_ARRAY({0})]"
            };
            AssociateTypes(manTA, objcTA);

            // System.Collections.ArrayList
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Collections.ArrayList"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "System_Collections_ArrayList", GetterFormat = "[System_Collections_ArrayList listWithMonoObject:{0}]"
            };
            AssociateTypes(manTA, objcTA);

            // System.Collections.Generic.List
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Collections.Generic.List`1"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "System_Collections_Generic_ListA1"
            };
            AssociateTypes(manTA, objcTA);

            // System.Collections.Generic.Dictionary
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Collections.Generic.Dictionary`2"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "System_Collections_Generic_DictionaryA2"
            };
            AssociateTypes(manTA, objcTA);

            // System.Byte[]
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Byte[]"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "NSData", GetterFormat = "[NSData dataWithMonoArray:DB_ARRAY({0})]"
            };
            AssociateTypes(manTA, objcTA);

            // ObjectSet
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Data.Entity.Core.Objects.ObjectSet`1"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "System_Data_Entity_Core_Objects_ObjectSetA1", GetterFormat = "[System_Data_Entity_Core_Objects_ObjectSetA1 objectSetWithMonoObject:{0}]"
            };
            AssociateTypes(manTA, objcTA);

            // ObjectContext
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Data.Entity.Core.Objects.ObjectContext"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "System_Data_Entity_Core_Objects_ObjectContext"
            };
            AssociateTypes(manTA, objcTA);

            //===============================================================================================
            // value types
            //===============================================================================================

            // System.ValueType - struct
            //manTA = new ManagedTypeAssociation { ManagedType = "System.ValueType" };
            //objcTA = new ObjCTypeAssociation { ObjCType = "DBManagedObject", GetterFormat = "[DBManagedObject objectWithMonoObject:{0}]" };
            //AssociateTypes(manTA, objcTA);

            // System.Void
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Void", ManagedTypeAlias = "void"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "void", GetterFormat = ""
            };
            AssociateTypes(manTA, objcTA);

            // System.Int64
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Int64", ManagedTypeAlias = "long"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "int64_t", GetterFormat = "DB_UNBOX_INT64({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.Int32
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Int32", ManagedTypeAlias = "int"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "int32_t", GetterFormat = "DB_UNBOX_INT32({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.Int16
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Int16", ManagedTypeAlias = "short", ManagedTypeInvoke = "int16"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "int16_t", GetterFormat = "DB_UNBOX_INT16({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.SByte
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.SByte", ManagedTypeAlias = "sbyte"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "int8_t", GetterFormat = "DB_UNBOX_INT8({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.IntPtr
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.IntPtr", ManagedTypeInvoke = "intptr"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "void *", GetterFormat = "DB_UNBOX_PTR({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.UInt64
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.UInt64", ManagedTypeAlias = "ulong"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "uint64_t", GetterFormat = "DB_UNBOX_UINT64({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.UInt32
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.UInt32", ManagedTypeAlias = "uint"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "uint32_t", GetterFormat = "DB_UNBOX_UINT32({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.UInt16
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.UInt16", ManagedTypeAlias = "ushort", ManagedTypeInvoke = "uint16"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "uint16_t", GetterFormat = "DB_UNBOX_UINT16({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.Byte
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Byte", ManagedTypeAlias = "byte"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "uint8_t", GetterFormat = "DB_UNBOX_UINT8({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.UIntPtr
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.UIntPtr", ManagedTypeInvoke = "uintptr"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "void *", GetterFormat = "DB_UNBOX_UPTR({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.Char
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Char", ManagedTypeAlias = "char"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "uint16_t", GetterFormat = "DB_UNBOX_UINT16({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.Double
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Double", ManagedTypeAlias = "double"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "double", GetterFormat = "DB_UNBOX_DOUBLE({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.Single
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Single", ManagedTypeAlias = "float", ManagedTypeInvoke = "single"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "float", GetterFormat = "DB_UNBOX_FLOAT({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.Boolean
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Boolean", ManagedTypeAlias = "bool"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "BOOL", GetterFormat = "DB_UNBOX_BOOLEAN({0})"
            };
            AssociateTypes(manTA, objcTA);

            // System.DateTime
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.DateTime"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "NSDate", GetterFormat = "[NSDate dateWithMonoDateTime:{0}]"
            };
            AssociateTypes(manTA, objcTA);

            // System.Decimal
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Decimal", ManagedTypeAlias = "decimal", ManagedTypeInvoke = "System.Decimal"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "NSDecimalNumber", GetterFormat = "[NSDecimalNumber decimalNumberWithMonoDecimal:{0}]"
            };
            AssociateTypes(manTA, objcTA);

            // System.Enum
            manTA = new ManagedTypeAssociation {
                ManagedType = "System.Enum"
            };
            objcTA = new ObjCTypeAssociation {
                ObjCType = "System_Enum", GetterFormat = "[System_Enum objectWithMonoObject:{0}]"
            };
            AssociateTypes(manTA, objcTA);
        }