Type.GetConstructor returns null on Iphone

Question

I am developing an app in Xamarin for Iphone, android version of similar app is ready for Google play. I am using jabber-net library in my app for chat functionality. But having some issue on device(Iphone 5 - IOS 7.0.3). this issue doesn't occur in emulator following is the method code.

public class QnameType
{
    /// <summary>
    /// Element name
    /// </summary>
    protected internal string Name;
    /// <summary>
    /// Element namespace URI
    /// </summary>
    protected internal string NS;
    /// <summary>
    /// Type to create for NS/Name pair
    /// </summary>
    protected internal Type  ElementType;

    /// <summary>
    /// Create a QnameType
    /// </summary>
    /// <param name="name"></param>
    /// <param name="ns"></param>
    /// <param name="typ"></param>
    public QnameType(string name, string ns, Type typ)
    {
        this.Name  = name;
        this.NS    = ns;
        this.ElementType = typ;
    }

    /// <summary>
    /// Is this the same qname by element name and namespace?
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public override bool Equals(object obj)
    {
        if (obj == (object)this)
            return true;
        QnameType other = obj as QnameType;
        if (other == null)
            return false;
        return (other.Name == Name) && (other.NS == NS);
    }

    /// <summary>
    /// Get a hash over the name and namespace.
    /// </summary>
    /// <returns></returns>
    public override int GetHashCode()
    {
        return ToString().GetHashCode();
    }

    /// <summary>
    /// Namespace|Name
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return NS + "|" + Name;
    }
}
public interface IPacketTypes
{
    /// <summary>
    /// QName to type mappings.
    /// </summary>
    QnameType[] Types { get; }
}
public class ElementFactory
{
    private Hashtable m_types = new Hashtable();
    private static readonly Type[] s_constructorTypes =
        new Type[] { typeof(string),
                       typeof(XmlQualifiedName),
                       typeof(XmlDocument) };
    public void AddType(IPacketTypes list)
    {
        foreach (QnameType qn in list.Types)
        {
        this.AddType(qn.Name, qn.NS, qn.ElementType);
        }
    }
    public void AddType(string localName, string ns, Type t)
    {
         Debug.Assert(t.IsSubclassOf(typeof(Element)));
         ConstructorInfo ci = t.GetConstructor(s_constructorTypes);
         Debug.Assert(ci != null);
         AddType(new XmlQualifiedName(localName, ns), ci);
    }
    public Element GetElement(string prefix, XmlQualifiedName qname, XmlDocument doc)
    {
        ConstructorInfo ci = (ConstructorInfo) m_types[qname];
        if (ci == null)
        {
            return new Element(prefix, qname, doc);
        }
        return (Element) ci.Invoke
            (new object[] {prefix, qname, doc});
    }

    /// <summary>
    /// Get a constructor for the appropriate type for the given qname.
    /// </summary>
    public ConstructorInfo this[XmlQualifiedName qname]
    {
        get { return (ConstructorInfo) m_types[qname]; }
    }
}

t.GetConstructor() returns null on Iphone but works fine on simulator.

Edit: added more detail,

Any help will be highly appreciated.

Thanks

Answer 1

That's likely normal, depending on t itself - what type does it represent ?

By default the managed linker is disabled (Don't link) on the simulator builds. That means every type will be part of the application.

However the default for device builds is Link SDK. This means unused types (found using static analysis) are removed from the application. This allow reducing the size of the application (by not compiling/shipping the whole .NET BCL inside each app).

Static analysis cannot find detect dynamic use of code, e.g. reflection. If your application depends on reflection is needs to preserve the code: using the [Preserve] attribute, an XML file or adding some extra code that will give an hint to the linker to keep the required members.

See documentation for further details.