/// <summary> /// Initializes a new instance of the <see cref="ElementInitRepresentation"/> class. /// </summary> /// <param name="type">Type with method.</param> /// <param name="addMethod">The add method.</param> /// <param name="arguments">The arguments.</param> public ElementInitRepresentation( TypeRepresentation type, MethodInfoRepresentation addMethod, IReadOnlyList <ExpressionRepresentationBase> arguments) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (addMethod == null) { throw new ArgumentNullException(nameof(addMethod)); } if (arguments == null) { throw new ArgumentNullException(nameof(arguments)); } if (!arguments.Any()) { throw new ArgumentException(Invariant($"'{nameof(arguments)}' is an empty enumerable")); } if (arguments.Any(_ => _ == null)) { throw new ArgumentException(Invariant($"'{nameof(arguments)}' contains at least one null element")); } this.Type = type; this.AddMethod = addMethod; this.Arguments = arguments; }
public ElementInitRepresentation DeepCloneWithAddMethod(MethodInfoRepresentation addMethod) { var result = new ElementInitRepresentation( this.Type?.DeepClone(), addMethod, this.Arguments?.DeepClone()); return(result); }
public MethodCallExpressionRepresentation DeepCloneWithMethod(MethodInfoRepresentation method) { var result = new MethodCallExpressionRepresentation( this.Type?.DeepClone(), this.NodeType.DeepClone(), this.ParentObject?.DeepClone(), method, this.Arguments?.DeepClone()); return(result); }
/// <summary> /// Converts to representation. /// </summary> /// <param name="methodInfo">The method information.</param> /// <returns> /// Converted <see cref="MethodInfoRepresentation" />. /// </returns> public static MethodInfoRepresentation ToRepresentation( this MethodInfo methodInfo) { if (methodInfo == null) { throw new ArgumentNullException(nameof(methodInfo)); } var methodHash = methodInfo.GetSignatureHash(); var genericArguments = methodInfo.GetGenericArguments().Select(_ => _.ToRepresentation()).ToList(); var result = new MethodInfoRepresentation(methodInfo.DeclaringType.ToRepresentation(), methodHash, genericArguments); return(result); }
/// <summary> /// Converts from representation. /// </summary> /// <param name="methodInfoRepresentation">The representation.</param> /// <returns> /// Converted <see cref="MemberInfo" />. /// </returns> public static MethodInfo FromRepresentation( this MethodInfoRepresentation methodInfoRepresentation) { if (methodInfoRepresentation == null) { throw new ArgumentNullException(nameof(methodInfoRepresentation)); } var methodHash = methodInfoRepresentation.MethodHash; var genericArguments = methodInfoRepresentation.GenericArguments.Select(_ => _.ResolveFromLoadedTypes()).ToArray(); var type = methodInfoRepresentation.Type.ResolveFromLoadedTypes(); var methodInfos = type.GetAllMethodInfos(); var methodHashAndInfoTupleSet = methodInfos.Select(methodInfo => { var localMethodInfo = methodInfo.IsGenericMethod ? methodInfo.MakeGenericMethod(genericArguments) : methodInfo; var localMethodHash = localMethodInfo.GetSignatureHash(); return(new Tuple <string, MethodInfo>(localMethodHash, localMethodInfo)); }); var results = methodHashAndInfoTupleSet.Where(_ => _.Item1.Equals(methodHash, StringComparison.OrdinalIgnoreCase)).ToList(); if (!results.Any()) { throw new ArgumentException(Invariant($"Could not find a member that matched hash '{methodInfoRepresentation.MethodHash}' on type '{type}'.")); } if (results.Count > 1) { var foundAddIn = string.Join(",", results.Select(_ => _.Item2.ToString())); throw new ArgumentException(Invariant($"Found too many members that matched hash '{methodInfoRepresentation.MethodHash}' on type '{type}'; {foundAddIn}.")); } var result = results.Single().Item2; return(result); }
/// <summary> /// Initializes a new instance of the <see cref="MethodCallExpressionRepresentation"/> class. /// </summary> /// <param name="type">The type.</param> /// <param name="nodeType">Type of the node.</param> /// <param name="parentObject">The object.</param> /// <param name="method">The method.</param> /// <param name="arguments">The arguments.</param> public MethodCallExpressionRepresentation( TypeRepresentation type, ExpressionType nodeType, ExpressionRepresentationBase parentObject, MethodInfoRepresentation method, IReadOnlyList <ExpressionRepresentationBase> arguments) : base(type, nodeType) { if (parentObject == null) { throw new ArgumentNullException(nameof(parentObject)); } if (method == null) { throw new ArgumentNullException(nameof(method)); } if (arguments == null) { throw new ArgumentNullException(nameof(arguments)); } if (!arguments.Any()) { throw new ArgumentException(Invariant($"'{nameof(arguments)}' is an empty enumerable")); } if (arguments.Any(_ => _ == null)) { throw new ArgumentException(Invariant($"'{nameof(arguments)}' contains at least one null element")); } this.ParentObject = parentObject; this.Method = method; this.Arguments = arguments; }