Esempio n. 1
0
        /// <summary>
        /// Converts from representation.
        /// </summary>
        /// <param name="memberInfoRepresentation">The representation.</param>
        /// <returns>
        /// Converted <see cref="MemberInfo" />.
        /// </returns>
        public static MemberInfo FromRepresentation(
            this MemberInfoRepresentation memberInfoRepresentation)
        {
            if (memberInfoRepresentation == null)
            {
                throw new ArgumentNullException(nameof(memberInfoRepresentation));
            }

            var type    = memberInfoRepresentation.Type.ResolveFromLoadedTypes();
            var results = type.GetMembers()
                          .Where(_ => _.GetSignatureHash().Equals(memberInfoRepresentation.MemberHash, StringComparison.OrdinalIgnoreCase))
                          .ToList();

            if (!results.Any())
            {
                throw new ArgumentException(Invariant($"Could not find a member that matched hash '{memberInfoRepresentation.MemberHash}' on type '{type}'."));
            }

            if (results.Count > 1)
            {
                var foundAddIn = string.Join(",", results.Select(_ => _.ToString()));
                throw new ArgumentException(Invariant($"Found too many members that matched hash '{memberInfoRepresentation.MemberHash}' on type '{type}'; {foundAddIn}."));
            }

            var result = results.Single();

            return(result);
        }
Esempio n. 2
0
        public override MemberBindingRepresentationBase DeepCloneWithMemberInfo(MemberInfoRepresentation memberInfo)
        {
            var result = new MemberAssignmentRepresentation(
                this.Type?.DeepClone(),
                memberInfo,
                this.ExpressionRepresentation?.DeepClone());

            return(result);
        }
        public override MemberBindingRepresentationBase DeepCloneWithMemberInfo(MemberInfoRepresentation memberInfo)
        {
            var result = new MemberListBindingRepresentation(
                this.Type?.DeepClone(),
                memberInfo,
                this.Initializers?.DeepClone());

            return(result);
        }
Esempio n. 4
0
        public MemberExpressionRepresentation DeepCloneWithMemberInfo(MemberInfoRepresentation memberInfo)
        {
            var result = new MemberExpressionRepresentation(
                this.Type?.DeepClone(),
                this.Expression?.DeepClone(),
                memberInfo);

            return(result);
        }
Esempio n. 5
0
        /// <summary>
        /// Initializes a new instance of the <see cref="MemberAssignmentRepresentation"/> class.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="memberInfo">The member hash.</param>
        /// <param name="expressionRepresentation">The expression.</param>
        public MemberAssignmentRepresentation(
            TypeRepresentation type,
            MemberInfoRepresentation memberInfo,
            ExpressionRepresentationBase expressionRepresentation)
            : base(type, memberInfo, MemberBindingType.Assignment)
        {
            if (expressionRepresentation == null)
            {
                throw new ArgumentNullException(nameof(expressionRepresentation));
            }

            this.ExpressionRepresentation = expressionRepresentation;
        }
Esempio n. 6
0
        /// <summary>
        /// Converts to representation.
        /// </summary>
        /// <param name="memberInfo">The member information.</param>
        /// <returns>
        /// Converted <see cref="MemberInfoRepresentation" />.
        /// </returns>
        public static MemberInfoRepresentation ToRepresentation(
            this MemberInfo memberInfo)
        {
            if (memberInfo == null)
            {
                throw new ArgumentNullException(nameof(memberInfo));
            }

            var type = memberInfo.DeclaringType.ToRepresentation();

            var memberHash = memberInfo.GetSignatureHash();

            var result = new MemberInfoRepresentation(type, memberHash);

            return(result);
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="MemberBindingRepresentationBase"/> class.
        /// </summary>
        /// <param name="type">The type with member.</param>
        /// <param name="memberInfo">The member info representation.</param>
        /// <param name="bindingType">Type of the binding.</param>
        protected MemberBindingRepresentationBase(
            TypeRepresentation type,
            MemberInfoRepresentation memberInfo,
            MemberBindingType bindingType)
        {
            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }

            if (memberInfo == null)
            {
                throw new ArgumentNullException(nameof(memberInfo));
            }

            this.Type        = type;
            this.MemberInfo  = memberInfo;
            this.BindingType = bindingType;
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="MemberExpressionRepresentation"/> class.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="expression">The expression.</param>
        /// <param name="memberInfo">The member info representation.</param>
        public MemberExpressionRepresentation(
            TypeRepresentation type,
            ExpressionRepresentationBase expression,
            MemberInfoRepresentation memberInfo)
            : base(type, ExpressionType.MemberAccess)
        {
            if (expression == null)
            {
                throw new ArgumentNullException(nameof(expression));
            }

            if (memberInfo == null)
            {
                throw new ArgumentNullException(nameof(memberInfo));
            }

            this.Expression = expression;
            this.MemberInfo = memberInfo;
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="MemberMemberBindingRepresentation"/> class.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="memberInfo">The member hash.</param>
        /// <param name="bindings">The bindings.</param>
        public MemberMemberBindingRepresentation(
            TypeRepresentation type,
            MemberInfoRepresentation memberInfo,
            IReadOnlyCollection <MemberBindingRepresentationBase> bindings)
            : base(type, memberInfo, MemberBindingType.MemberBinding)
        {
            if (bindings == null)
            {
                throw new ArgumentNullException(nameof(bindings));
            }

            if (!bindings.Any())
            {
                throw new ArgumentException(Invariant($"'{nameof(bindings)}' is an empty enumerable"));
            }

            if (bindings.Any(_ => _ == null))
            {
                throw new ArgumentException(Invariant($"'{nameof(bindings)}' contains at least one null element"));
            }

            this.Bindings = bindings;
        }
Esempio n. 10
0
        /// <summary>
        /// Initializes a new instance of the <see cref="MemberListBindingRepresentation"/> class.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="memberInfo">The member hash.</param>
        /// <param name="initializers">The initializers.</param>
        public MemberListBindingRepresentation(
            TypeRepresentation type,
            MemberInfoRepresentation memberInfo,
            IReadOnlyList <ElementInitRepresentation> initializers)
            : base(type, memberInfo, MemberBindingType.ListBinding)
        {
            if (initializers == null)
            {
                throw new ArgumentNullException(nameof(initializers));
            }

            if (!initializers.Any())
            {
                throw new ArgumentException(Invariant($"'{nameof(initializers)}' is an empty enumerable"));
            }

            if (initializers.Any(_ => _ == null))
            {
                throw new ArgumentException(Invariant($"'{nameof(initializers)}' contains at least one null element"));
            }

            this.Initializers = initializers;
        }
Esempio n. 11
0
 public virtual MemberBindingRepresentationBase DeepCloneWithMemberInfo(MemberInfoRepresentation memberInfo)
 {
     throw new NotImplementedException("This method should be abstract.  It was generated as virtual so that you aren't forced to override it when you create a new model that derives from this model.  It will be overridden in the generated designer file.");
 }