Пример #1
0
        internal static Func<IInspectable, object> CreateTypedRcwFactory(string runtimeClassName)
        {
            // If runtime class name is empty or "Object", then just use IInspectable.
            if (string.IsNullOrEmpty(runtimeClassName) || runtimeClassName == "Object")
            {
                return (IInspectable obj) => obj;
            }
            // PropertySet and ValueSet can return IReference<String> but Nullable<String> is illegal
            if (runtimeClassName == "Windows.Foundation.IReference`1<String>")
            {
                return (IInspectable obj) => new ABI.System.Nullable<String>(obj.ObjRef);
            }
            else if (runtimeClassName == "Windows.Foundation.IReference`1<Windows.UI.Xaml.Interop.TypeName>")
            {
                return (IInspectable obj) => new ABI.System.Nullable<Type>(obj.ObjRef);
            }

            Type implementationType = null;

            try
            {
                (implementationType, _) = TypeNameSupport.FindTypeByName(runtimeClassName.AsSpan());
            }
            catch (TypeLoadException)
            {
                // If we reach here, then we couldn't find a type that matches the runtime class name.
                // Fall back to using IInspectable directly.
                return (IInspectable obj) => obj;
            }

            if (implementationType.IsGenericType && implementationType.GetGenericTypeDefinition() == typeof(System.Collections.Generic.KeyValuePair<,>))
            {
                return CreateKeyValuePairFactory(implementationType);
            }

            if (implementationType.IsValueType)
            {
                if (IsNullableT(implementationType))
                {
                    return CreateNullableTFactory(implementationType);
                }
                else
                {
                    return CreateNullableTFactory(typeof(System.Nullable<>).MakeGenericType(implementationType));
                }
            }
            else if (IsIReferenceArray(implementationType))
            {
                return CreateArrayFactory(implementationType);
            }

            return CreateFactoryForImplementationType(runtimeClassName, implementationType);
        }
Пример #2
0
        internal static string GetRuntimeClassForTypeCreation(IInspectable inspectable, Type staticallyDeterminedType)
        {
            string runtimeClassName = inspectable.GetRuntimeClassName(noThrow: true);
            if (staticallyDeterminedType != null && staticallyDeterminedType != typeof(object))
            {
                // We have a static type which we can use to construct the object.  But, we can't just use it for all scenarios
                // and primarily use it for tear off scenarios and for scenarios where runtimeclass isn't accurate.
                // For instance if the static type is an interface, we return an IInspectable to represent the interface.
                // But it isn't convertable back to the class via the as operator which would be possible if we use runtimeclass.
                // Similarly for composable types, they can be statically retrieved using the parent class, but can then no longer
                // be cast to the sub class via as operator even if it is really an instance of it per rutimeclass.
                // To handle these scenarios, we use the runtimeclass if we find it is assignable to the statically determined type.
                // If it isn't, we use the statically determined type as it is a tear off.

                Type implementationType = null;
                if (!string.IsNullOrEmpty(runtimeClassName))
                {
                    try
                    {
                        (implementationType, _) = TypeNameSupport.FindTypeByName(runtimeClassName.AsSpan());
                    }
                    catch (TypeLoadException)
                    {
                    }
                }

                if (!(implementationType != null &&
                    (staticallyDeterminedType == implementationType ||
                     staticallyDeterminedType.IsAssignableFrom(implementationType) ||
                     staticallyDeterminedType.IsGenericType && implementationType.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == staticallyDeterminedType.GetGenericTypeDefinition()))))
                {
                    runtimeClassName = TypeNameSupport.GetNameForType(staticallyDeterminedType, TypeNameGenerationFlags.GenerateBoxedName);
                }
            }

            return runtimeClassName;
        }
Пример #3
0
 public static void RegisterProjectionAssembly(Assembly assembly) => TypeNameSupport.RegisterProjectionAssembly(assembly);
Пример #4
0
 internal InspectableInfo(Type type, Guid[] iids)
 {
     runtimeClassName = new Lazy<string>(() => TypeNameSupport.GetNameForType(type, TypeNameGenerationFlags.GenerateBoxedName | TypeNameGenerationFlags.NoCustomTypeName));
     IIDs = iids;
 }