public override void CreateInstance(NetTypeInfo typeInfo, ref IntPtr instance) { var o = Activator.CreateInstance(Type.GetType(typeInfo.GetFullTypeName())); var handle = GCHandle.Alloc(o); instance = GCHandle.ToIntPtr(handle); }
internal static void OnNetTypeInfoCreated(NetTypeInfo netTypeInfo, Type forType) { foreach (var behavior in GetApplicableInteropBehaviors(forType)) { behavior.OnNetTypeInfoCreated(netTypeInfo, forType); } }
public override void CreateInstance(NetTypeInfo typeInfo, ref IntPtr instance) { var type = Type.GetType(typeInfo.GetFullTypeName()); var typeCreator = NetTypeInfoManager.TypeCreator; var handle = GCHandle.Alloc(typeCreator != null ? typeCreator.Create(type) : Activator.CreateInstance(type)); instance = GCHandle.ToIntPtr(handle); }
public static NetTypeInfo GetTypeInfo(NetCmdType type) { ushort size = (ushort)TypeSize <T> .SIZE; NetTypeInfo nti = new NetTypeInfo(); nti.CmdType = type; nti.StructType = TypeSize <T> .RUN_TYPE; nti.StructSize = size; nti.TypeHashCode = TypeSize <T> .HASH; return(nti); }
public void Can_add_signals() { var type = new NetTypeInfo("test"); var signal = new NetSignalInfo(type, "signalName"); signal.AddParameter(NetVariantType.Bool); type.GetSignal(0).Should().BeNull(); type.SignalCount.Should().Be(0); type.AddSignal(signal); type.SignalCount.Should().Be(1); type.GetSignal(0).Name.Should().Be("signalName"); type.GetSignal(0).GetParameter(0).Should().Be(NetVariantType.Bool); }
public void Can_create_signal_info() { using (var type = new NetTypeInfo("full type name")) using (var signal = new NetSignalInfo(type, "testSignal")) { signal.ParentType.FullTypeName.Should().Be("full type name"); signal.Name.Should().Be("testSignal"); signal.ParameterCount.Should().Be(0); signal.GetParameter(0).Should().Be(NetVariantType.Invalid); signal.AddParameter(NetVariantType.Double); signal.ParameterCount.Should().Be(1); signal.GetParameter(0).Should().Be(NetVariantType.Double); signal.GetParameter(1).Should().Be(NetVariantType.Invalid); } }
public void CreateLazyTypeInfo(IntPtr t) { using (var type = new NetTypeInfo(t)) { var typeInfo = Type.GetType(type.FullTypeName); if (typeInfo == null) { throw new InvalidOperationException(); } type.ClassName = typeInfo.Name; type.PrefVariantType = GetPrefVariantType(typeInfo); // All the methods/properties/signals are later populated when needed. } }
public void OnNetTypeInfoCreated(NetTypeInfo netTypeInfo, Type forType) { if (!IsApplicableFor(forType)) { return; } var mvvmTypeInfo = new MvvmTypeInfo(); TypeInfos.Add(forType, mvvmTypeInfo); for (var i = 0; i < netTypeInfo.PropertyCount; i++) { int?existingSignalIndex = null; var property = netTypeInfo.GetProperty(i); if (property.NotifySignal != null) { // In this case some other behavior or the user has already set up a notify signal for this property. // We don't want to destroy that. mvvmTypeInfo.AddPropertyInfo(property.Name, property.NotifySignal.Name); continue; } var signalName = CalculateSignalNameFromPropertyName(property.Name); mvvmTypeInfo.AddPropertyInfo(property.Name, signalName); // Check if this signal already has been registered. for (var signalIndex = 0; signalIndex < netTypeInfo.SignalCount; signalIndex++) { var signal = netTypeInfo.GetSignal(signalIndex); if (string.Equals(signalName, signal.Name)) { existingSignalIndex = signalIndex; break; } } if (existingSignalIndex.HasValue) { // Signal for this property is already existent but not registered (we check that above). property.NotifySignal = netTypeInfo.GetSignal(existingSignalIndex.Value); continue; } // Create a new signal and link it to the property. var notifySignalInfo = new NetSignalInfo(netTypeInfo, signalName); netTypeInfo.AddSignal(notifySignalInfo); property.NotifySignal = notifySignalInfo; } }
public void CreateLazyTypeInfo(IntPtr t) { using (var type = new NetTypeInfo(t)) { var typeInfo = Type.GetType(type.FullTypeName); if (typeInfo == null) { throw new InvalidOperationException(); } var baseType = typeInfo.BaseType; if (baseType != null) { type.BaseType = baseType.AssemblyQualifiedName; } type.ClassName = typeInfo.Name; // All the methods/properties/signals are later populated when needed. } }
public static NetCmdBase ByteToCmd(byte[] byteData, int offset, int length) { if (length < 4) { return(null); } int t1 = (int)byteData[offset + 3]; int t2 = (int)byteData[offset + 2]; t1 = t1 << 8 | t2; NetCmdType cmdType = (NetCmdType)(t1); if (cmdType >= NetCmdType.CMD_MAX) { return(null); } NetTypeInfo typeInfo = NetCmdMapping.GetTypeInfo(cmdType); if (typeInfo == null) { LogMgr.Log("未注册的命令:" + cmdType.ToString()); return(null); } if (length < typeInfo.StructSize) { LogMgr.Log("命令大小与结构体大小不匹配:" + length.ToString() + " : " + typeInfo.StructSize.ToString() + " :" + cmdType.ToString()); return(null); } NetCmdBase cmd = (NetCmdBase)TypeReflector.BytesToObj( typeInfo.TypeHashCode, byteData, offset, length ); return(cmd); }
public void LoadTypeInfo(IntPtr t) { using (var type = new NetTypeInfo(t)) { var typeInfo = Type.GetType(type.FullTypeName); if (typeInfo == null) { throw new InvalidOperationException($"Invalid type {type.FullTypeName}"); } // Don't grab properties and methods for system-level types. if (Helpers.IsPrimitive(typeInfo)) { return; } if (typeInfo.IsArray) { type.IsArray = true; } else { if (typeof(IList).IsAssignableFrom(typeInfo)) { type.IsList = true; } else if (typeInfo.IsGenericType) { if (typeof(IList <>).IsAssignableFrom(typeInfo.GetGenericTypeDefinition())) { type.IsList = true; } } } if (typeof(IQmlComponentCompleted).IsAssignableFrom(typeInfo)) { type.HasComponentCompleted = true; } if (typeof(IQmlObjectDestroyed).IsAssignableFrom(typeInfo)) { type.HasObjectDestroyed = true; } foreach (var methodInfo in typeInfo.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly)) { if (methodInfo.IsGenericMethod) { continue; // No generics supported. } if (Helpers.IsPrimitive(methodInfo.DeclaringType)) { continue; } if (methodInfo.IsSpecialName) { continue; // Ignore the property get/set methods. } NetTypeInfo returnType = null; if (methodInfo.ReturnParameter != null && methodInfo.ReturnParameter.ParameterType != typeof(void)) { returnType = NetTypeManager.GetTypeInfo(methodInfo.ReturnParameter.ParameterType); } var method = new NetMethodInfo(type, methodInfo.Name, returnType, methodInfo.IsStatic); foreach (var parameter in methodInfo.GetParameters()) { method.AddParameter(parameter.Name, NetTypeManager.GetTypeInfo(parameter.ParameterType)); } type.AddMethod(method); } var signals = new Dictionary <string, NetSignalInfo>(); foreach (var signalAttribute in typeInfo.GetCustomAttributes(false).OfType <SignalAttribute>()) { if (string.IsNullOrEmpty(signalAttribute.Name)) { throw new InvalidOperationException($"Signal name was null for {typeInfo.Name}"); } if (!char.IsLower(signalAttribute.Name[0])) { throw new InvalidOperationException($"Signal {signalAttribute.Name} for {typeInfo.Name} must begin with a lower case letter."); } var signal = new NetSignalInfo(type, signalAttribute.Name); foreach (var parameter in signalAttribute.Parameters) { signal.AddParameter(parameter); } type.AddSignal(signal); signals.Add(signal.Name, signal); } foreach (var propertyInfo in typeInfo.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)) { if (Helpers.IsPrimitive(propertyInfo.DeclaringType)) { continue; } NetSignalInfo notifySignal = null; var notifySignalAttribute = propertyInfo.GetCustomAttribute <NotifySignalAttribute>(); if (notifySignalAttribute != null) { var name = notifySignalAttribute.Name; if (string.IsNullOrEmpty(name)) { name = $"{propertyInfo.Name}Changed"; name = char.ToLower(name[0]) + name.Substring(1); } if (signals.ContainsKey(name)) { notifySignal = signals[name]; // Make sure the signal we are referencing has no parameters. if (notifySignal.ParameterCount != 0) { // TODO: They can actually of parameters, but not implemented yet. throw new Exception("Notify signals must have no parameters."); } } else { if (!char.IsLower(name[0])) { throw new InvalidOperationException($"Signal {name} for {typeInfo.Name} must begin with a lower case letter."); } notifySignal = new NetSignalInfo(type, name); type.AddSignal(notifySignal); } } using (var property = new NetPropertyInfo( type, propertyInfo.Name, NetTypeManager.GetTypeInfo(propertyInfo.PropertyType), propertyInfo.CanRead, propertyInfo.CanWrite, notifySignal)) { foreach (var indexParameter in propertyInfo.GetIndexParameters()) { property.AddIndexParameter(indexParameter.Name, NetTypeManager.GetTypeInfo(indexParameter.ParameterType)); } type.AddProperty(property); } } // NOTE: This type is going to get a typeInfo object // with IsLoading=true and IsLoaded=false. It technically // is loaded, but it's misleading. InteropBehaviors.OnNetTypeInfoCreated(type, typeInfo); } }
protected CodeGenBase() { _mock = new Mock <T>(); _typeInfo = NetTypeManager.GetTypeInfo <T>(); _typeInfo.EnsureLoaded(); }
public override void BuildTypeInfo(NetTypeInfo typeInfo) { var type = Type.GetType(typeInfo.GetFullTypeName()); typeInfo.SetClassName(type.Name); if (type == typeof(bool)) { typeInfo.SetPrefVariantType(NetVariantTypeEnum.NetVariantTypeEnum_Bool); } else if (type == typeof(char)) { typeInfo.SetPrefVariantType(NetVariantTypeEnum.NetVariantTypeEnum_Char); } else if (type == typeof(int)) { typeInfo.SetPrefVariantType(NetVariantTypeEnum.NetVariantTypeEnum_Int); } else if (type == typeof(uint)) { typeInfo.SetPrefVariantType(NetVariantTypeEnum.NetVariantTypeEnum_UInt); } else if (type == typeof(double)) { typeInfo.SetPrefVariantType(NetVariantTypeEnum.NetVariantTypeEnum_Double); } else if (type == typeof(string)) { typeInfo.SetPrefVariantType(NetVariantTypeEnum.NetVariantTypeEnum_String); } else if (type == typeof(DateTime)) { typeInfo.SetPrefVariantType(NetVariantTypeEnum.NetVariantTypeEnum_DateTime); } else { typeInfo.SetPrefVariantType(NetVariantTypeEnum.NetVariantTypeEnum_Object); } if (type.Namespace == "System") { return; // built in type! } foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance)) { if (method.DeclaringType == typeof(Object)) { continue; } NetTypeInfo returnType = null; if (method.ReturnParameter.ParameterType != typeof(void)) { returnType = NetTypeInfoManager.GetTypeInfo(method.ReturnParameter.ParameterType); } var methodInfo = NetTypeInfoManager.NewMethodInfo(typeInfo, method.Name, returnType); foreach (var parameter in method.GetParameters()) { methodInfo.AddParameter(parameter.Name, NetTypeInfoManager.GetTypeInfo(parameter.ParameterType)); } typeInfo.AddMethod(methodInfo); } foreach (var property in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)) { typeInfo.AddProperty(NetTypeInfoManager.NewPropertyInfo( typeInfo, property.Name, NetTypeInfoManager.GetTypeInfo(property.PropertyType), property.CanRead, property.CanWrite)); } }
internal static int RegisterType(NetTypeInfo type, string uri, string qmlName, int versionMajor = 1, int versionMinor = 0) { return(Interop.QQmlApplicationEngine.RegisterType(type.Handle, uri, versionMajor, versionMinor, qmlName)); }
public void Can_create_type() { var typeInfo = new NetTypeInfo("fullTypeName"); typeInfo.FullTypeName.Should().Be("fullTypeName"); }