internal ProxyGenerator(TypeDefinitionInformation originalInterface, string generatedClientInterfaceName) { this.generatedClientInterfaceName = generatedClientInterfaceName; this.interfaceType = originalInterface; this.className = generatedClientInterfaceName + "_Implementation"; this.methods = originalInterface.Methods; }
public MethodInformation(string name, uint i, TypeDefinitionInformation returnType, bool isVoidMethod, bool isImpulseHandler, IEnumerable <ParameterInformation> parameters) { this.idNumber = i + 1; // this way 0 is always left open to use as the id for OnFirstStart this.Name = name; this.Parameters = parameters; // mi.GetParameters().ToArray(); this.ReturnType = returnType; // Utilities.GetCSharpSourceSyntax(mi.ReturnType); this.isImpulseHandler = isImpulseHandler; this.voidMethod = isVoidMethod; // mi.ReturnType.Equals(typeof(void)); }
public static string ComputeArgumentSize(TypeDefinitionInformation t, int position) { var sb = new StringBuilder(); if (t.IsByteArray) { sb.AppendLine($"arg{position}Bytes = p_{position};"); sb.AppendLine($"arg{position}Size = IntSize(arg{position}Bytes.Length) + arg{position}Bytes.Length;"); } else { sb.AppendLine($"arg{position}Bytes = Ambrosia.BinarySerializer.Serialize<{t.Namespace + "." + t.Name}>(p_{position});"); sb.AppendLine($"arg{position}Size = IntSize(arg{position}Bytes.Length) + arg{position}Bytes.Length;"); } return(sb.ToString()); }
/// <summary> /// Assumes that either the type of the value is a byte array or else has either is marked [DataContract] or [Serializable] /// </summary> /// <param name="typeName"> /// Must be a valid C# source syntax for the type name. /// </param> /// <param name="isByteArray"></param> /// <param name="variableToAssignTo"></param> /// <returns></returns> public static string DeserializeValue(TypeDefinitionInformation typeOfValue, string variableToAssignTo) { var sb = new StringBuilder(); sb.AppendLine($"var {variableToAssignTo}_ValueLength = buffer.ReadBufferedInt(cursor);"); sb.AppendLine($"cursor += IntSize({variableToAssignTo}_ValueLength);"); sb.AppendLine($"var {variableToAssignTo}_ValueBuffer = new byte[{variableToAssignTo}_ValueLength];"); sb.AppendLine($"Buffer.BlockCopy(buffer, cursor, {variableToAssignTo}_ValueBuffer, 0, {variableToAssignTo}_ValueLength);"); sb.AppendLine($"cursor += {variableToAssignTo}_ValueLength;"); if (typeOfValue.IsByteArray) { sb.AppendLine($"var {variableToAssignTo} = {variableToAssignTo}_ValueBuffer;"); } else { sb.AppendLine($"var {variableToAssignTo} = Ambrosia.BinarySerializer.Deserialize<{typeOfValue.Namespace + "." + typeOfValue.Name}>({variableToAssignTo}_ValueBuffer);"); } return(sb.ToString()); }
public static TypeDefinitionInformation GetTypeDefinitionInformation(Type t) { //if (!CanHandleType(t)) //{ // throw new NotImplementedException($"Need to handle the type: {GetCSharpSourceSyntax(t)}"); //} var iTypeInfo = new TypeDefinitionInformation() { //Name = Utilities.CleanUpIdentifierName(GetCSharpSourceSyntax(t)), Name = GetTypeDefinitionInformationName(t), Namespace = t.Namespace, Methods = t .GetMethods(BindingFlags.Instance | BindingFlags.Public) .Select((m, i) => GetMethodInformation(m, (uint)i)), IsByteArray = t.IsArray && t.GetElementType().Equals(typeof(byte)), }; return(iTypeInfo); }
internal DispatcherGenerator(TypeDefinitionInformation interfaceType) { this.interfaceType = interfaceType; this.className = Utilities.CleanUpIdentifierName(interfaceType.Name) + "_Dispatcher_Implementation"; this.methods = interfaceType.Methods; }
internal ProxyInterfaceGenerator(TypeDefinitionInformation interfaceType) { this.interfaceType = interfaceType; }