Added a facade to help hide the complexity of invoking a .NET array.

src/native/QmlNet/QmlNet/qml/JsNetArray.cpp

@@ -1,6 +1,7 @@
 #include <QmlNet/qml/JsNetArray.h>
 #include <QmlNet/types/NetMethodInfo.h>
 #include <QmlNet/types/Callbacks.h>
+#include <QmlNet/types/NetTypeArrayFacade.h>
 #include <QVariant>
 #include <private/qv4qobjectwrapper_p.h>
 
@@ -37,7 +38,21 @@ ReturnedValue NetArray::create(ExecutionEngine *engine, NetValue* netValue)
 ReturnedValue NetArray::method_length(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
 {
     Scope scope(b);
-    return Encode(scope.engine->newNumberObject(1));
+
+    Scoped<QV4::NetArray> netArray(scope, thisObject->as<QV4::NetArray>());
+    Scoped<QV4::QObjectWrapper> wrapper(scope, netArray->d()->object);
+    if (!wrapper) {
+        THROW_GENERIC_ERROR("No reference to the wrapped QObject exists.");
+    }
+
+    NetValue* netValue = reinterpret_cast<NetValue*>(wrapper->d()->object());
+    QSharedPointer<NetTypeArrayFacade> arrayFacade = netValue->getNetReference()->getTypeInfo()->getArrayFacade();
+
+    if(arrayFacade == nullptr) {
+        THROW_GENERIC_ERROR("The wrapped object can't be treated as an array.");
+    }
+
+    return Encode(scope.engine->newNumberObject(arrayFacade->getLength(netValue->getNetReference())));
 }
 
 ReturnedValue NetArray::getIndexed(const Managed *m, uint index, bool *hasProperty)
@@ -47,8 +62,6 @@ ReturnedValue NetArray::getIndexed(const Managed *m, uint index, bool *hasProper
     if(hasProperty)
         *hasProperty = true;
 
-    // Find the "Get" method for this type.
-
     QV4::Scoped<QV4::QObjectWrapper> wrapper(scope, netArray->d()->object);
     if (!wrapper) {
         THROW_GENERIC_ERROR("No reference to the wrapped QObject exists.");

src/native/QmlNet/QmlNet/types/NetTypeArrayFacade.cpp

@@ -0,0 +1,27 @@
+#include <QmlNet/types/NetTypeArrayFacade.h>
+#include <QmlNet/types/NetTypeArrayFacadeArray.h>
+#include <QmlNet/types/NetTypeInfo.h>
+
+NetTypeArrayFacade::NetTypeArrayFacade()
+{
+
+}
+
+QSharedPointer<NetTypeArrayFacade> NetTypeArrayFacade::fromType(QSharedPointer<NetTypeInfo> type)
+{
+    if(type->isArray()) {
+        QSharedPointer<NetTypeArrayFacade_Array> facade = QSharedPointer<NetTypeArrayFacade_Array>(new NetTypeArrayFacade_Array(type));
+        if(facade->isIncomplete()) {
+            return nullptr;
+        }
+        return facade.dynamicCast<NetTypeArrayFacade>();
+    }
+
+    return nullptr;
+}
+
+
+int NetTypeArrayFacade::getLength(QSharedPointer<NetReference>)
+{
+    return 0;
+}

src/native/QmlNet/QmlNet/types/NetTypeArrayFacade.h

@@ -0,0 +1,19 @@
+#ifndef NETTYPEARRAYFACADE_H
+#define NETTYPEARRAYFACADE_H
+
+#include <QmlNet.h>
+#include <QSharedPointer>
+
+class NetTypeInfo;
+class NetReference;
+
+class NetTypeArrayFacade
+{
+public:
+    NetTypeArrayFacade();
+    virtual ~NetTypeArrayFacade() {}
+    static QSharedPointer<NetTypeArrayFacade> fromType(QSharedPointer<NetTypeInfo> type);
+    virtual int getLength(QSharedPointer<NetReference> reference);
+};
+
+#endif // NETTYPEARRAYFACADE_H

src/native/QmlNet/QmlNet/types/NetTypeArrayFacadeArray.cpp

@@ -0,0 +1,35 @@
+#include <QmlNet/types/NetTypeArrayFacadeArray.h>
+#include <QmlNet/types/NetTypeInfo.h>
+#include <QmlNet/types/NetMethodInfo.h>
+#include <QmlNet/types/NetPropertyInfo.h>
+#include <QmlNet/qml/NetVariant.h>
+#include <QmlNet/qml/NetVariantList.h>
+#include <QmlNet/types/Callbacks.h>
+
+NetTypeArrayFacade_Array::NetTypeArrayFacade_Array(QSharedPointer<NetTypeInfo> type) :
+    _isIncomplete(false)
+{
+    for(int x = 0; x < type->getPropertyCount(); x++) {
+        QSharedPointer<NetPropertyInfo> property = type->getProperty(x);
+        if(property->getPropertyName().compare("Length") == 0) {
+            _lengthProperty = property;
+        }
+    }
+
+    if(_lengthProperty == nullptr) {
+        _isIncomplete = true;
+        return;
+    }
+}
+
+bool NetTypeArrayFacade_Array::isIncomplete()
+{
+    return _isIncomplete;
+}
+
+int NetTypeArrayFacade_Array::getLength(QSharedPointer<NetReference> reference)
+{
+    QSharedPointer<NetVariant> result = QSharedPointer<NetVariant>(new NetVariant());
+    readProperty(_lengthProperty, reference, result);
+    return result->getInt();
+}

src/native/QmlNet/QmlNet/types/NetTypeArrayFacadeArray.h

@@ -0,0 +1,20 @@
+#ifndef NETTYPEARRAYFACADEARRAY_H
+#define NETTYPEARRAYFACADEARRAY_H
+
+#include <QmlNet/types/NetTypeArrayFacade.h>
+
+class NetMethodInfo;
+class NetPropertyInfo;
+
+class NetTypeArrayFacade_Array : public NetTypeArrayFacade
+{
+public:
+    NetTypeArrayFacade_Array(QSharedPointer<NetTypeInfo> type);
+    bool isIncomplete();
+    int getLength(QSharedPointer<NetReference> reference);
+private:
+    bool _isIncomplete;
+    QSharedPointer<NetPropertyInfo> _lengthProperty;
+};
+
+#endif // NETTYPEARRAYFACADEARRAY_H

src/native/QmlNet/QmlNet/types/NetTypeInfo.cpp

@@ -3,6 +3,7 @@
 #include <QmlNet/types/NetPropertyInfo.h>
 #include <QmlNet/types/NetSignalInfo.h>
 #include <QmlNet/types/Callbacks.h>
+#include <QmlNet/types/NetTypeArrayFacade.h>
 #include <QmlNetUtilities.h>
 
 NetTypeInfo::NetTypeInfo(QString fullTypeName) :
@@ -10,6 +11,7 @@ NetTypeInfo::NetTypeInfo(QString fullTypeName) :
     _fullTypeName(fullTypeName),
     _variantType(NetVariantTypeEnum_Invalid),
     _isArray(false),
+    _arrayFacadeLoaded(false),
     _lazyLoaded(false),
     _isLoading(false) {
 
@@ -121,6 +123,17 @@ QSharedPointer<NetSignalInfo> NetTypeInfo::getSignal(int index) {
     return _signals.at(index);
 }
 
+QSharedPointer<NetTypeArrayFacade> NetTypeInfo::getArrayFacade()
+{
+    if(_arrayFacadeLoaded) {
+        return _arrayFacade;
+    }
+    ensureLoaded();
+    _arrayFacade = NetTypeArrayFacade::fromType(sharedFromThis());
+    _arrayFacadeLoaded = true;
+    return _arrayFacade;
+}
+
 bool NetTypeInfo::isLoaded() {
     return _lazyLoaded;
 }

src/native/QmlNet/QmlNet/types/NetTypeInfo.h

@@ -10,6 +10,7 @@
 class NetMethodInfo;
 class NetPropertyInfo;
 class NetSignalInfo;
+class NetTypeArrayFacade;
 
 class NetTypeInfo : public QEnableSharedFromThis<NetTypeInfo> {
 public:
@@ -45,6 +46,8 @@ public:
     int getSignalCount();
     QSharedPointer<NetSignalInfo> getSignal(int index);
 
+    QSharedPointer<NetTypeArrayFacade> getArrayFacade();
+
     bool isLoaded();
     bool isLoading();
     void ensureLoaded();
@@ -61,6 +64,8 @@ private:
     QList<QSharedPointer<NetMethodInfo>> _methodsStatic;
     QList<QSharedPointer<NetPropertyInfo>> _properties;
     QList<QSharedPointer<NetSignalInfo>> _signals;
+    QSharedPointer<NetTypeArrayFacade> _arrayFacade;
+    bool _arrayFacadeLoaded;
     bool _lazyLoaded;
     bool _isLoading;
 };

src/native/QmlNet/QmlNet/types/types.pri

@@ -6,7 +6,9 @@ SOURCES += \
     $$PWD/NetPropertyInfo.cpp \
     $$PWD/NetReference.cpp \
     $$PWD/NetSignalInfo.cpp \
-    $$PWD/NetDelegate.cpp
+    $$PWD/NetDelegate.cpp \
+    $$PWD/NetTypeArrayFacade.cpp \
+    $$PWD/NetTypeArrayFacadeArray.cpp
 
 HEADERS += \
     $$PWD/NetTypeInfo.h \
@@ -16,4 +18,6 @@ HEADERS += \
     $$PWD/NetPropertyInfo.h \
     $$PWD/NetReference.h \
     $$PWD/NetSignalInfo.h \
-    $$PWD/NetDelegate.h
+    $$PWD/NetDelegate.h \
+    $$PWD/NetTypeArrayFacade.h \
+    $$PWD/NetTypeArrayFacadeArray.h

src/net/Qml.Net/Internal/Helpers.cs

@@ -19,6 +19,10 @@ namespace Qml.Net.Internal
                 {
                     return false;
                 }
+                if (type.Name == "Array")
+                {
+                    return false;
+                }
                 return true;
             }