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");
}
