private MemberBinding Convert(LinqExp.MemberBinding linqBinding) { switch (linqBinding.BindingType) { case LinqExp.MemberBindingType.Assignment: var linqMemberAssignment = (LinqExp.MemberAssignment)linqBinding; return(Expression.Bind( linqMemberAssignment.Member, ConvertExp(linqMemberAssignment.Expression))); case LinqExp.MemberBindingType.MemberBinding: var linqMemberBinding = (LinqExp.MemberMemberBinding)linqBinding; return(Expression.MemberBind( linqMemberBinding.Member, linqMemberBinding.Bindings.Project(Convert))); case LinqExp.MemberBindingType.ListBinding: var linqListBinding = (LinqExp.MemberListBinding)linqBinding; return(Expression.ListBind( linqListBinding.Member, linqListBinding.Initializers.Project(Convert))); default: throw new ArgumentOutOfRangeException(); } }
public static EditableMemberBinding CreateEditableMemberBinding(MemberBinding member) { if (member is MemberAssignment) return new EditableMemberAssignment(member as MemberAssignment); else if (member is MemberListBinding) return new EditableMemberListBinding(member as MemberListBinding); else if (member is MemberMemberBinding) return new EditableMemberMemberBinding(member as MemberMemberBinding); else return null; }
public static Expression CreateExpression(IContainerContext containerContext, ResolutionConstructor resolutionConstructor, ResolutionInfo resolutionInfo, Expression resolutionInfoExpression, ResolutionMember[] members = null) { var length = resolutionConstructor.Parameters.Length; var arguments = new Expression[length]; for (var i = 0; i < length; i++) { var parameter = resolutionConstructor.Parameters[i]; arguments[i] = containerContext.ResolutionStrategy.GetExpressionForResolutionTarget(parameter, resolutionInfo, resolutionInfoExpression); } var newExpression = Expression.New(resolutionConstructor.Constructor, arguments); if (members == null || members.Length == 0) return newExpression; { var propLength = members.Length; var propertyExpressions = new MemberBinding[propLength]; for (var i = 0; i < propLength; i++) { var member = members[i]; var propertyExpression = Expression.Bind(member.MemberInfo, containerContext.ResolutionStrategy.GetExpressionForResolutionTarget(member.ResolutionTarget, resolutionInfo, resolutionInfoExpression)); propertyExpressions[i] = propertyExpression; } return Expression.MemberInit(newExpression, propertyExpressions); } }
public static CreateInstance CreateConstructorExpression(IContainerContext containerContext, ResolutionConstructor resolutionConstructor, ResolutionMember[] members = null) { var strategyParameter = Expression.Constant(containerContext.ResolutionStrategy, typeof(IResolutionStrategy)); var resolutionInfoParameter = Expression.Parameter(typeof(ResolutionInfo), "resolutionInfo"); var arguments = CreateExpressionFromResolutionTargets(resolutionConstructor.Parameters, strategyParameter, resolutionInfoParameter); var newExpression = Expression.New(resolutionConstructor.Constructor, arguments); if (members == null || members.Length == 0) return Expression.Lambda<CreateInstance>(newExpression, resolutionInfoParameter).Compile(); var length = members.Length; var propertyExpressions = new MemberBinding[length]; for (var i = 0; i < length; i++) { var member = members[i]; var propertyExpression = Expression.Bind(member.MemberInfo, CreateResolutionTargetExpression(member.ResolutionTarget, strategyParameter, resolutionInfoParameter)); propertyExpressions[i] = propertyExpression; } var initExpression = Expression.MemberInit(newExpression, propertyExpressions); return Expression.Lambda<CreateInstance>(initExpression, resolutionInfoParameter).Compile(); }
protected override MemberBinding VisitMemberBinding(MemberBinding memberBinding) { if(memberBinding.BindingType == MemberBindingType.Assignment) { #if PORTABLE var propertyInfo = memberBinding.Member as PropertyInfo; var assignment = memberBinding as MemberAssignment; if (propertyInfo != null && assignment != null && assignment.Expression.Type.IsValueType && !propertyInfo.PropertyType.IsValueType) { var valueExpression = Expression.TypeAs(VisitExpression(assignment.Expression), propertyInfo.PropertyType); return Expression.Bind(memberBinding.Member, valueExpression); } #else if (memberBinding.Member.MemberType == MemberTypes.Property) { var propertyInfo = memberBinding.Member as PropertyInfo; var assignment = memberBinding as MemberAssignment; if (assignment.Expression.Type.IsValueType && !propertyInfo.PropertyType.IsValueType) { var valueExpression = Expression.TypeAs(VisitExpression(assignment.Expression), propertyInfo.PropertyType); return Expression.Bind(memberBinding.Member, valueExpression); } } #endif } return base.VisitMemberBinding(memberBinding); }
/// <summary> /// Transforms a call to <code>entity.Mixin<T>()</code> to <code>new MixinType { Properties, ... }</code> /// </summary> /// <param name="method">The method call expression.</param> /// <returns>The</returns> public Expression TransformMixinMethodExpression(MethodCallExpression method) { var mixinType = method.Type; var entityType = method.Object.Type; string prefix = $"{mixinType.Name}_"; // Get the available properties of the mixin. var entity = _model.GetEntityType(entityType); var properties = entity .GetProperties() .Where(p => p.Name.StartsWith(prefix)) .ToArray(); // Create an object initializer expression. var ctor = Expression.New(mixinType); var memberBindings = new MemberBinding[properties.Length]; for (int i = 0; i < properties.Length; i++) { var property = properties[i]; string propertyName = property.Name.Replace(prefix, ""); var member = mixinType.GetProperty(propertyName); var value = Expression.Call( EntityQueryModelVisitor.PropertyMethodInfo.MakeGenericMethod(member.PropertyType), method.Object, Expression.Constant(property.Name)); memberBindings[i] = Expression.Bind(member, value); } return Expression.MemberInit(ctor, memberBindings); }
private static void BindToProjectedWrapperMany(Expression[] bindingExpressions, int expressionStartIndex, MemberBinding[] bindings, int bindingStartIndex) { int propertyIndex = 0; while ((propertyIndex < (precreatedProjectedWrapperTypes.Length - 1)) && ((propertyIndex + expressionStartIndex) < bindingExpressions.Length)) { bindings[bindingStartIndex + propertyIndex] = BindToProjectedProperty(typeof(ProjectedWrapperMany), propertyIndex, bindingExpressions[expressionStartIndex + propertyIndex]); propertyIndex++; } if (bindingExpressions.Length <= ((precreatedProjectedWrapperTypes.Length - 1) + expressionStartIndex)) { while (propertyIndex < (precreatedProjectedWrapperTypes.Length - 1)) { bindings[bindingStartIndex + propertyIndex] = BindToProjectedProperty(typeof(ProjectedWrapperMany), propertyIndex, Expression.Constant(string.Empty, typeof(string))); propertyIndex++; } bindings[(bindingStartIndex + precreatedProjectedWrapperTypes.Length) - 1] = Expression.Bind(typeof(ProjectedWrapperMany).GetProperty("Next"), Expression.MemberInit(Expression.New(typeof(ProjectedWrapperManyEnd)), new MemberBinding[] { Expression.Bind(typeof(ProjectedWrapperManyEnd).GetProperty("ResourceTypeName"), Expression.Constant(string.Empty, typeof(string))) })); } else { int length = bindingExpressions.Length - ((precreatedProjectedWrapperTypes.Length - 1) + expressionStartIndex); if (length > (precreatedProjectedWrapperTypes.Length - 1)) { length = precreatedProjectedWrapperTypes.Length; } MemberBinding[] bindingArray = new MemberBinding[precreatedProjectedWrapperTypes.Length + 2]; bindingArray[0] = Expression.Bind(typeof(ProjectedWrapperMany).GetProperty("ResourceTypeName"), Expression.Constant(string.Empty, typeof(string))); bindingArray[1] = Expression.Bind(typeof(ProjectedWrapperMany).GetProperty("PropertyNameList"), Expression.Constant(string.Empty, typeof(string))); BindToProjectedWrapperMany(bindingExpressions, (expressionStartIndex + precreatedProjectedWrapperTypes.Length) - 1, bindingArray, 2); Expression expression = Expression.MemberInit(Expression.New(typeof(ProjectedWrapperMany)), bindingArray); bindings[(bindingStartIndex + precreatedProjectedWrapperTypes.Length) - 1] = Expression.Bind(typeof(ProjectedWrapperMany).GetProperty("Next"), expression); } }
protected override MemberBinding VisitBinding(MemberBinding binding) { var save = receivingMember; receivingMember = binding.Member; var result = base.VisitBinding(binding); receivingMember = save; return result; }
protected override MemberBinding VisitBinding(MemberBinding node) { var elementName = BsonClassMap.LookupClassMap(_classes.Peek()).GetMemberMap(node.Member.Name).ElementName; _assigments.Push(elementName); MemberBinding visitMemberBinding = base.VisitBinding(node); _assigments.Pop(); return visitMemberBinding; }
private static MemberInitExpression CreateMemberInitExpression(ParameterExpression left, Type entityType, Type dtoType, Tuple <Type, string>[] linkEntityNames) { System.Linq.Expressions.NewExpression newAnimal = System.Linq.Expressions.Expression.New(dtoType); List <MemberBinding> bindings = new List <MemberBinding>(); var members = dtoType.GetProperties();//获取Dto的各个属性 members.ToList().ForEach(p => { try { if (linkEntityNames != null && linkEntityNames.Length > 0) { var container = linkEntityNames.ToList().FirstOrDefault(x => p.Name.Contains(x.Item2)); if (container != null) { var rightStr = p.Name.Replace(container.Item2, ""); Expression right = Expression.Property(left, entityType.GetProperty(container.Item2)); MemberExpression mem = Expression.Property(right, rightStr); //这里传的mem是 用 a.name给它赋值 System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind(p, mem); bindings.Add(speciesMemberBinding); } else { MemberExpression mem = Expression.Property(left, p.Name); //这里传的mem是 用 a.name给它赋值 System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind(p, mem); bindings.Add(speciesMemberBinding); } } else { try { MemberExpression mem = Expression.Property(left, p.Name); //这里传的mem是 用 a.name给它赋值 System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind(p, mem); bindings.Add(speciesMemberBinding); } catch (Exception ex) { } } } catch { } }); System.Linq.Expressions.MemberInitExpression memberInitExpression = System.Linq.Expressions.Expression.MemberInit(newAnimal, bindings.ToArray()); return(memberInitExpression); }
public MemberBinding[] Decode(ref byte* data, ref int remainingBytes, bool doNotCheckBounds) { int count = intCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds); if (count == -1) return null; var result = new MemberBinding[count]; for (int i = 0; i < count; i++) result[i] = memberBindingCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds); return result; }
protected virtual MemberBinding VisitBinding (MemberBinding binding) { switch (binding.BindingType) { case MemberBindingType.Assignment: return VisitMemberAssignment ((MemberAssignment)binding); default: throw new ArgumentException (string.Format ("Unhandled binding type '{0}'", binding.BindingType)); } }
public static IMemberBindingMutator GetMutator(MemberBinding memberBinding) { if (memberBinding is MemberAssignment) return new MemberAssignmentMutator((MemberAssignment)memberBinding); if (memberBinding is MemberMemberBinding) return new MemberMemberBindingMutator((MemberMemberBinding)memberBinding); if (memberBinding is MemberListBinding) return new MemberListBindingMutator((MemberListBinding)memberBinding); throw Error.BadArgument("S0040: Unknown Expression Type '{0}'", memberBinding.GetType()); }
public static void CreateMemberInitExpression() { System.Linq.Expressions.NewExpression newAnimal = System.Linq.Expressions.Expression.New(typeof(Animal)); System.Reflection.MemberInfo speciesMember = typeof(Animal).GetMember("Species")[0]; System.Reflection.MemberInfo ageMember = typeof(Animal).GetMember("Age")[0]; // Create a MemberBinding object for each member // that you want to initialize. System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind( speciesMember, System.Linq.Expressions.Expression.Constant("horse")); System.Linq.Expressions.MemberBinding ageMemberBinding = System.Linq.Expressions.Expression.Bind( ageMember, System.Linq.Expressions.Expression.Constant(12)); // Create a MemberInitExpression that represents initializing // two members of the 'Animal' class. System.Linq.Expressions.MemberInitExpression memberInitExpression = System.Linq.Expressions.Expression.MemberInit( newAnimal, speciesMemberBinding, ageMemberBinding); //// Create a MemberInitExpression that represents initializing //// two members of the 'Animal' class. //System.Linq.Expressions.MemberInitExpression memberInitExpression = // System.Linq.Expressions.Expression.MemberInit( // newAnimal, // speciesMemberBinding); Console.WriteLine(memberInitExpression.ToString()); var expression = Expression.Lambda <Func <Dog, Animal> >(memberInitExpression); var compile = expression.Compile(); var dog = new Dog() { Species = "DOG" }; var test = compile(dog); Console.WriteLine(test.ToJson()); // This code produces the following output: // // new Animal() {Species = "horse", Age = 12} }
internal static Expression ReduceMemberBinding(ParameterExpression objVar, MemberBinding binding) { MemberExpression member = Expression.MakeMemberAccess(objVar, binding.Member); switch (binding.BindingType) { case MemberBindingType.Assignment: return Expression.Assign(member, ((MemberAssignment)binding).Expression); case MemberBindingType.ListBinding: return ReduceListInit(member, ((MemberListBinding)binding).Initializers, false); case MemberBindingType.MemberBinding: return ReduceMemberInit(member, ((MemberMemberBinding)binding).Bindings, false); default: throw Assert.Unreachable; } }
internal virtual MemberBinding VisitBinding(MemberBinding binding) { switch (binding.BindingType) { case MemberBindingType.Assignment: return this.VisitMemberAssignment((MemberAssignment)binding); case MemberBindingType.MemberBinding: return this.VisitMemberMemberBinding((MemberMemberBinding)binding); case MemberBindingType.ListBinding: return this.VisitMemberListBinding((MemberListBinding)binding); default: throw Error.UnhandledBindingType(binding.BindingType); } }
protected virtual MemberBinding VisitBinding(MemberBinding binding, Stack<string> stack, Stack<IElasticPropertyAttribute> properties) { switch (binding.BindingType) { case MemberBindingType.Assignment: return this.VisitMemberAssignment((MemberAssignment)binding, stack, properties); case MemberBindingType.MemberBinding: return this.VisitMemberMemberBinding((MemberMemberBinding)binding, stack, properties); case MemberBindingType.ListBinding: return this.VisitMemberListBinding((MemberListBinding)binding, stack, properties); default: throw new Exception(string.Format("Unhandled binding type '{0}'", binding.BindingType)); } }
protected virtual MemberBinding VisitBinding(MemberBinding binding) { switch (binding.BindingType) { case MemberBindingType.Assignment: return this.VisitMemberAssignment((MemberAssignment)binding); case MemberBindingType.MemberBinding: return this.VisitMemberMemberBinding((MemberMemberBinding)binding); case MemberBindingType.ListBinding: return this.VisitMemberListBinding((MemberListBinding)binding); default: throw new Exception($"Unhandled binding type '{binding.BindingType}'"); } }
internal static MemberBindingNode Create(INodeFactory factory, MemberBinding memberBinding) { MemberBindingNode memberBindingNode = null; if (memberBinding is MemberAssignment) memberBindingNode = new MemberAssignmentNode(factory, (MemberAssignment)memberBinding); else if (memberBinding is MemberListBinding) memberBindingNode = new MemberListBindingNode(factory, (MemberListBinding)memberBinding); else if (memberBinding is MemberMemberBinding) memberBindingNode = new MemberMemberBindingNode(factory, (MemberMemberBinding)memberBinding); else if (memberBinding != null) throw new ArgumentException("Unknown member binding of type " + memberBinding.GetType(), "memberBinding"); return memberBindingNode; }
internal static Expression ReduceMemberBinding(ParameterExpression objVar, MemberBinding binding) { MemberExpression left = Expression.MakeMemberAccess(objVar, binding.Member); switch (binding.BindingType) { case MemberBindingType.Assignment: return Expression.Assign(left, ((MemberAssignment) binding).Expression); case MemberBindingType.MemberBinding: return ReduceMemberInit(left, ((MemberMemberBinding) binding).Bindings, false); case MemberBindingType.ListBinding: return ReduceListInit(left, ((MemberListBinding) binding).Initializers, false); } throw ContractUtils.Unreachable; }
protected virtual bool AreEqualBinding(MemberBinding x, MemberBinding y) { if (x.BindingType != y.BindingType) return false; switch (x.BindingType) { case MemberBindingType.Assignment: return this.AreEqualMemberAssignment((MemberAssignment)x, (MemberAssignment)y); case MemberBindingType.MemberBinding: return this.AreEqualMemberMemberBinding((MemberMemberBinding)x, (MemberMemberBinding)y); case MemberBindingType.ListBinding: return this.AreEqualMemberListBinding((MemberListBinding)x, (MemberListBinding)y); default: throw new Exception(string.Format("Unhandled binding type '{0}'", y.BindingType)); } }
public static MemberBinding Serialize(E.MemberBinding binding) { switch (binding.BindingType) { case E.MemberBindingType.Assignment: return(MemberAssignment.Serialize((E.MemberAssignment)binding)); case E.MemberBindingType.MemberBinding: return(MemberMemberBinding.Serialize((E.MemberMemberBinding)binding)); case E.MemberBindingType.ListBinding: return(MemberListBinding.Serialize((E.MemberListBinding)binding)); default: throw new ArgumentOutOfRangeException("binding.BindingType"); } }
internal static MemberBinding[] Bind(Expression[] bindingExpressions, Type projectedWrapperType) { MemberBinding[] bindingArray; int length = bindingExpressions.Length; if (length <= (precreatedProjectedWrapperTypes.Length + 1)) { bindingArray = new MemberBinding[length]; BindResourceTypeAndPropertyNameList(projectedWrapperType, bindingArray, bindingExpressions); for (int i = 0; i < (length - 2); i++) { bindingArray[i + 2] = BindToProjectedProperty(projectedWrapperType, i, bindingExpressions[i + 2]); } return bindingArray; } bindingArray = new MemberBinding[precreatedProjectedWrapperTypes.Length + 2]; BindResourceTypeAndPropertyNameList(projectedWrapperType, bindingArray, bindingExpressions); BindToProjectedWrapperMany(bindingExpressions, 2, bindingArray, 2); return bindingArray; }
protected object Visit(object obj, MemberBinding binding) { switch (binding.BindingType) { case MemberBindingType.Assignment: var assignment = ((MemberAssignment)binding); var value = this.Visit(assignment.Expression); if (value == InterpretFailed) { return value; } var fieldInfo = assignment.Member as FieldInfo; if (fieldInfo != null) { fieldInfo.SetValue(obj, value); return binding; } var propertyInfo = assignment.Member as PropertyInfo; if (propertyInfo != null) { propertyInfo.SetValue(obj, value, null); return binding; } return InterpretFailed; } return InterpretFailed; }
private Expression ParseNew() { NextToken(); ValidateToken(TokenId.OpenParen, Res.OpenParenExpected); NextToken(); List<DynamicProperty> properties = new List<DynamicProperty>(); List<Expression> expressions = new List<Expression>(); while (true) { int exprPos = token.pos; Expression expr = ParseExpression(); string propName; if (TokenIdentifierIs("as")) { NextToken(); propName = GetIdentifier(); NextToken(); } else { MemberExpression me = expr as MemberExpression; if (me == null) throw ParseError(exprPos, Res.MissingAsClause); propName = me.Member.Name; } expressions.Add(expr); properties.Add(new DynamicProperty(propName, expr.Type)); if (token.id != TokenId.Comma) break; NextToken(); } ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected); NextToken(); Type type = DynamicExpression.CreateClass(properties); MemberBinding[] bindings = new MemberBinding[properties.Count]; for (int i = 0; i < bindings.Length; i++) bindings[i] = Expression.Bind(type.GetProperty(properties[i].Name), expressions[i]); return Expression.MemberInit(Expression.New(type), bindings); }
/// <summary> /// MemberBinding visit method /// </summary> /// <param name="binding">The MemberBinding expression to visit</param> /// <returns>The visited MemberBinding expression </returns> public virtual MemberBinding VisitBinding(MemberBinding binding) { switch (binding.BindingType) { case MemberBindingType.Assignment: return this.VisitMemberAssignment((MemberAssignment)binding); case MemberBindingType.MemberBinding: return this.VisitMemberMemberBinding((MemberMemberBinding)binding); case MemberBindingType.ListBinding: return this.VisitMemberListBinding((MemberListBinding)binding); default: throw new NotSupportedException(); } }
private static MemberBinding VisitMemberBinding(MemberBinding node) { throw new NotImplementedException(); }
/// <summary> /// Returns the <see cref="TypeRegistration"/> entry for the actual trace listener represented by this /// configuration object. /// </summary> /// <returns>A registry entry.</returns> protected TypeRegistration GetTraceListenerTypeRegistration() { IEnumerable<MemberBinding> extraBindings; Expression creationExpression = GetCreationExpression().Body; NewExpression newExpression = creationExpression as NewExpression; if (newExpression != null) { extraBindings = new MemberBinding[0]; } else { MemberInitExpression memberInitExpression = creationExpression as MemberInitExpression; if (memberInitExpression != null) { newExpression = memberInitExpression.NewExpression; extraBindings = memberInitExpression.Bindings; } else { throw new NotSupportedException(Logging.Properties.Resources.ExceptionCreationLinqExpressionMustBeNew); } } MemberInitExpression memberInit = LambdaExpression.MemberInit(newExpression, GetSharedBindings().Concat(extraBindings)); TypeRegistration registration = new TypeRegistration<TraceListener>(LambdaExpression.Lambda<Func<TraceListener>>(memberInit)) { Name = this.WrappedTraceListenerName, Lifetime = TypeRegistrationLifetime.Transient }; return registration; }
protected override MemberBinding VisitBinding(MemberBinding binding) { // we need to visit the original expression tree first in order to collect all // necessary informations base.VisitBinding(binding); // now we replace the original member binding for our // GetValues call to the ResponseCatalogue if (binding is MemberAssignment) { var assignment = (MemberAssignment) binding; var type = assignment.Expression.Type; var identifier = _processor.Items.Last().Identifier; var expression = CreateSurrogateExpression(type, identifier); var surrogate = assignment.Update(expression); return surrogate; } throw new NotSupportedException(); }
public ScriptBuilderException(CSharpToJSExceptionType type, Expression root, MemberBinding binding, Exception innerException) : base(root, binding, innerException) { Type = type; }
public virtual MemberBinding VisitBinding(MemberBinding binding) { switch (binding.BindingType) { case MemberBindingType.Assignment: return this.VisitMemberAssignment((MemberAssignment)binding); case MemberBindingType.MemberBinding: return this.VisitMemberMemberBinding((MemberMemberBinding)binding); case MemberBindingType.ListBinding: return this.VisitMemberListBinding((MemberListBinding)binding); default: throw new Exception(string.Format("Unhandled binding type '{0}'", binding.BindingType)); } }
protected virtual bool CompareBinding(MemberBinding a, MemberBinding b) { if (a == b) return true; if (a == null || b == null) return false; if (a.BindingType != b.BindingType) return false; if (a.Member != b.Member) return false; switch (a.BindingType) { case MemberBindingType.Assignment: return this.CompareMemberAssignment((MemberAssignment)a, (MemberAssignment)b); case MemberBindingType.ListBinding: return this.CompareMemberListBinding((MemberListBinding)a, (MemberListBinding)b); case MemberBindingType.MemberBinding: return this.CompareMemberMemberBinding((MemberMemberBinding)a, (MemberMemberBinding)b); default: throw new Exception(string.Format("Unhandled binding type: '{0}'", a.BindingType)); } }
/// <summary> /// Visit a bindingExp expression. /// </summary> /// <param name="bindingExp"></param> /// <returns></returns> protected virtual MemberBinding VisitBinding(MemberBinding bindingExp) { switch (bindingExp.BindingType) { case MemberBindingType.Assignment: return VisitMemberAssignment((MemberAssignment)bindingExp); case MemberBindingType.MemberBinding: return VisitMemberMemberBinding((MemberMemberBinding)bindingExp); case MemberBindingType.ListBinding: return VisitMemberListBinding((MemberListBinding)bindingExp); default: throw new NotSupportedException(string.Format("Unhandled binding type '{0}'", bindingExp.BindingType)); } }
/// <summary> /// Visits a MemberBinding. /// </summary> /// <param name="node">The MemberBinding.</param> /// <returns>The MemberBinding (possibly modified).</returns> protected override MemberBinding VisitMemberBinding(MemberBinding node) { throw new NotImplementedException(); }
public MemberBindingExpressionTree Visit(MemberBinding node) => base.VisitMemberBinding(node);