public override bool TrySetMember(SetMemberBinder binder, object value)
{
string key = binder.Name;
if (storage.ContainsKey(key))
storage[key] = value;
else
storage.Add(key, value);
return true;
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
string name = binder.Name;
if (char.IsUpper(name[0]))
{
// Allows set (as noop) if it means that it's being given the same value the get
// above would return anyway.
if (value as string != name)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
return true;
}
return false;
}
public override DynamicMetaObject/*!*/ BindSetMember(SetMemberBinder/*!*/ member, DynamicMetaObject/*!*/ value) {
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Type SetMember " + Value.UnderlyingSystemType.FullName);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "Type SetMember");
BinderState state = BinderState.GetBinderState(member);
if (Value.IsSystemType) {
MemberTracker tt = MemberTracker.FromMemberInfo(Value.UnderlyingSystemType);
MemberGroup mg = state.Binder.GetMember(OldSetMemberAction.Make(state.Binder, member.Name), Value.UnderlyingSystemType, member.Name);
// filter protected member access against .NET types, these can only be accessed from derived types...
foreach (MemberTracker mt in mg) {
if (IsProtectedSetter(mt)) {
return new DynamicMetaObject(
BindingHelpers.TypeErrorForProtectedMember(Value.UnderlyingSystemType, member.Name),
Restrictions.Merge(value.Restrictions).Merge(BindingRestrictions.GetInstanceRestriction(Expression, Value))
);
}
}
// have the default binder perform it's operation against a TypeTracker and then
// replace the test w/ our own.
return new DynamicMetaObject(
state.Binder.SetMember(
member.Name,
new DynamicMetaObject(
AstUtils.Constant(tt),
BindingRestrictions.Empty,
tt
),
value,
AstUtils.Constant(state.Context)
).Expression,
Restrictions.Merge(value.Restrictions).Merge(BindingRestrictions.GetInstanceRestriction(Expression, Value))
);
}
return MakeSetMember(member, value);
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value) {
Debug.Assert(value.Value != Uninitialized.Instance);
switch (binder.Name) {
case "__dict__":
return new DynamicMetaObject(
Expression.Throw(
Expression.Call(
typeof(PythonOps).GetMethod("TypeError"),
Expression.Constant("readonly attribute"),
Expression.NewArrayInit(typeof(object))
),
typeof(object)
),
BindingRestrictions.GetTypeRestriction(Expression, Value.GetType())
);
case "__class__":
return new DynamicMetaObject(
Expression.Throw(
Expression.Call(
typeof(PythonOps).GetMethod("TypeError"),
Expression.Constant("__class__ assignment: only for heap types"),
Expression.NewArrayInit(typeof(object))
),
typeof(object)
),
BindingRestrictions.GetTypeRestriction(Expression, Value.GetType())
);
}
return new DynamicMetaObject(
Expression.Call(
typeof(PythonOps).GetMethod("ModuleSetMember"),
Utils.Convert(Expression, typeof(PythonModule)),
Expression.Constant(binder.Name),
value.Expression
),
BindingRestrictions.GetTypeRestriction(Expression, Value.GetType())
);
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
{
return(DoBindSetMember(this.Value as ExpressionContainer, binder.ReturnType, binder.Name, binder.IgnoreCase, value));
}
public override bool TrySetMember( SetMemberBinder binder, object value )
{
try {
int ix = _Record.Schema.IndexOf( _Table, binder.Name, anyTable: false );
if( ix >= 0 ) { _Record[ix] = value; return true; }
throw new KeyNotFoundException( "Column not found: " + string.Format( "{0}.{1}", _Table, binder.Name ) );
}
finally { Dispose(); }
}
public override DynamicMetaObject/*!*/ BindSetMember(SetMemberBinder/*!*/ member, DynamicMetaObject/*!*/ value) {
return MakeSetMember(member.Name, value);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
_values[binder.Name] = value;
return true;
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value) {
if (IsOverridden("TrySetMember")) {
return CallMethodReturnLast("TrySetMember", binder, GetArgs(value), (e) => binder.FallbackSetMember(this, value, e));
}
return base.BindSetMember(binder, value);
}
/// <summary>
/// Provides the implementation for operations that set member values. Classes derived from the
/// <see cref="T:System.Dynamic.DynamicObject" /> class can override this method to specify dynamic behavior for
/// operations such as setting a value for a property.
/// </summary>
/// <returns>
/// true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of
/// the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.)
/// </returns>
/// <param name="binder">
/// Provides information about the object that called the dynamic operation. The binder.Name property
/// provides the name of the member to which the value is being assigned. For example, for the statement
/// sampleObject.SampleProperty = "Test", where sampleObject is an instance of the class derived from the
/// <see cref="T:System.Dynamic.DynamicObject" /> class, binder.Name returns "SampleProperty". The binder.IgnoreCase
/// property specifies whether the member name is case-sensitive.
/// </param>
/// <param name="value">
/// The value to set to the member. For example, for sampleObject.SampleProperty = "Test", where
/// sampleObject is an instance of the class derived from the <see cref="T:System.Dynamic.DynamicObject" /> class, the
/// <paramref name="value" /> is "Test".
/// </param>
public override bool TrySetMember(SetMemberBinder binder, object value)
{
Set(binder.Name, value.ToString());
return(true);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
return(godot_icall_DynamicGodotObject_SetMember(Object.GetPtr(Value), binder.Name, value));
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
return (IsArray)
? TrySet(int.Parse(binder.Name), value)
: TrySet(binder.Name, value);
}
public virtual bool TrySetMember(T instance, SetMemberBinder binder, object value)
{
return(false);
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
{
Requires.NotNull(binder, nameof(binder));
return(binder.FallbackSetMember(UnwrapSelf(), value));
}
/// <summary>
/// Tries to perform binding of the dynamic set member operation.
/// </summary>
/// <remarks>
/// Always return false in CoreCLR.
/// </remarks>
public static bool TryBindSetMember(SetMemberBinder binder, DynamicMetaObject instance, DynamicMetaObject value, out DynamicMetaObject result)
{
result = null;
return(false);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
dictionary[binder.Name.ToLower()] = value;
return(true);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
if (!value.GetType().IsArray && value.GetType().Name.Contains("AnonymousType")) value = new ElasticObject(value);
this[binder.Name] = value;
return true;
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
{
ContractUtils.RequiresNotNull(binder, "binder");
return(binder.Defer(WrapSelf(), value));
}
public override bool TrySetMember( SetMemberBinder binder, object value )
{
Add( null, binder.Name, value );
return true;
}
/// <summary>
/// Provides dynamic resolution of properties and fields.
/// Cannot be used asynchronously.
/// If you need asynchronous access, please cast the object to an AppVar
/// and use a FriendlyOperation, or call it in the form of a method by specifying a
/// method name equal to the property name.
/// </summary>
/// <param name="binder">Binder.</param>
/// <param name="value">Value to set.</param>
/// <returns>Success or failure.</returns>
#else
/// <summary>
/// プロパティーへのアクセス(setter)の動的解決です。
/// 非同期実行はできません。
/// どうしても非同期実行が必要な場合はAppVarにキャストして、FriendlyOperationを使用するか、
/// メソッド形式の呼び出しを実行してください。
/// メソッド名称はプロパティー名称と同一です。
/// </summary>
/// <example>
/// dynamic form; //System.Windows.Forms.Formのオブジェクトが格納されているとします。
/// Async async = new Async();
/// form.Text(async, "text"); //メソッド形式で呼び出すことが出来ます。Asyncオブジェクトを指定することが出来ます。
/// </example>
/// <param name="binder">バインダー。</param>
/// <param name="value">設定値。</param>
/// <returns>成否。</returns>
#endif
public override bool TrySetMember(SetMemberBinder binder, object value)
{
_appVar[binder.Name](value);
return(true);
}
private DynamicMetaObject/*!*/ MakeSetMember(SetMemberBinder/*!*/ member, DynamicMetaObject/*!*/ value) {
DynamicMetaObject self = Restrict(typeof(PythonType));
return BindingHelpers.AddDynamicTestAndDefer(
member,
new DynamicMetaObject(
Ast.Call(
typeof(PythonOps).GetMethod("PythonTypeSetCustomMember"),
AstUtils.Constant(BinderState.GetBinderState(member).Context),
self.Expression,
AstUtils.Constant(SymbolTable.StringToId(member.Name)),
AstUtils.Convert(
value.Expression,
typeof(object)
)
),
self.Restrictions.Merge(value.Restrictions)
),
new DynamicMetaObject[] { this, value },
TestUserType()
);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
return(accessor.TrySetMember(binder, value, base.TrySetMember));
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value) {
ContractUtils.RequiresNotNull(binder, "binder");
return binder.FallbackSetMember(UnwrapSelf(), value);
}
private static CallSite <Func <CallSite, object, object, object> > CreateCallSiteSetter(string name)
{
SetMemberBinder binder = (SetMemberBinder)DynamicUtils.BinderWrapper.SetMember(name, typeof(DynamicUtils));
return(CallSite <Func <CallSite, object, object, object> > .Create(new NoThrowSetBinderMember(binder)));
}
public SetBindingInfo(SetMemberBinder/*!*/ action, DynamicMetaObject/*!*/[]/*!*/ args, ConditionalBuilder/*!*/ body, ValidationInfo/*!*/ validation)
: base(args, body, validation) {
Action = action;
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
this.Set(value, binder.Name);
return(true);
}
public override DynamicMetaObject/*!*/ BindSetMember(SetMemberBinder/*!*/ member, DynamicMetaObject/*!*/ value) {
return MakeMemberAccess(member, member.Name, MemberAccess.Set, this, value);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
ViewData[binder.Name] = value;
// you can always set a key in the dictionary so return true
return(true);
}
public override DynamicMetaObject BindSetMember( SetMemberBinder binder, DynamicMetaObject value )
{
DEBUG.IndentLine( "\n-- BindSetMember: {0} = {1}", binder.Name, value.Value == null ? "<null>" : value.Value.ToString() );
var obj = (DynamicNode)this.Value;
var node = new DynamicNode.SetMember( obj, binder.Name, value.Value ) { _Parser = obj._Parser };
obj._Parser._LastNode = node;
var par = Expression.Variable( typeof( DynamicNode ), "ret" );
var exp = Expression.Block(
new ParameterExpression[] { par },
Expression.Assign( par, Expression.Constant( node ) )
);
DEBUG.Unindent();
return new DynamicMetaNode( exp, this.Restrictions, node );
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
return(TrySetField(binder, value) || TrySetProperty(binder, value));
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
return true;
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
_scope.SetVariable(SymbolTable.StringToId(binder.Name), value);
return(true);
}
public static bool TryBindSetMember(SetMemberBinder binder, DynamicMetaObject instance, DynamicMetaObject value, out DynamicMetaObject result) {
ContractUtils.RequiresNotNull(binder, "binder");
ContractUtils.RequiresNotNull(instance, "instance");
ContractUtils.RequiresNotNull(value, "value");
if (TryGetMetaObject(ref instance)) {
//
// Demand Full Trust to proceed with the binding.
//
new PermissionSet(PermissionState.Unrestricted).Demand();
result = instance.BindSetMember(binder, value);
return true;
} else {
result = null;
return false;
}
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
return(true);
}
/// <summary>
/// Performs the binding of the dynamic set member operation.
/// </summary>
/// <param name="binder">An instance of the <see cref="SetMemberBinder"/> that represents the details of the dynamic operation.</param>
/// <param name="value">The <see cref="DynamicMetaObject"/> representing the value for the set member operation.</param>
/// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
public virtual DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value) {
ContractUtils.RequiresNotNull(binder, "binder");
return binder.FallbackSetMember(this, value);
}
public NoThrowSetBinderMember(SetMemberBinder innerBinder)
: base(innerBinder.Name, innerBinder.IgnoreCase)
{
_innerBinder = innerBinder;
}
/// <summary>
/// Provides the implementation of setting a member. Derived classes can override
/// this method to customize behavior. When not overridden the call site requesting the
/// binder determines the behavior.
/// </summary>
/// <param name="binder">The binder provided by the call site.</param>
/// <param name="value">The value to set.</param>
/// <returns>true if the operation is complete, false if the call site should determine behavior.</returns>
public virtual bool TrySetMember(SetMemberBinder binder, object value) {
return false;
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
var key = binder.Name;
return(SetPropertyValue(key, value));
}
public override bool TrySetMember( SetMemberBinder binder, object value )
{
_Builder.Add( _Table, binder.Name, value );
return true;
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
Console.WriteLine("TrySetMember: " + new { binder.Name, value });
return(true);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
return(TrySetMemberImpl(binder.Name, value));
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
SetProperty(binder.Name, value);
// TODO: Check if this was actually a property
return(true);
}
/// <summary>
/// Helper for falling back - if we have a base object fallback to it first (which can
/// then fallback to the calling site), otherwise fallback to the calling site.
/// </summary>
private DynamicMetaObject/*!*/ Fallback(SetMemberBinder/*!*/ action, DynamicMetaObject/*!*/ value) {
if (_baseMetaObject != null) {
return _baseMetaObject.BindSetMember(action, value);
}
return action.FallbackSetMember(this, value);
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
{
if (!_metadata.Schema.TryFindProperty(binder.Name, out var property))
{
return(base.BindSetMember(binder, value));
}
var arguments = new List <Expression>
{
Expression.Constant(_metadata.PropertyIndices[property.Name])
};
MethodInfo setter = null;
Type argumentType = null;
switch (property.Type)
{
case Schema.PropertyType.Int:
argumentType = typeof(long);
if (property.IsNullable)
{
setter = GetSetMethod <long?>(dummyHandle.SetNullableInt64);
}
else if (property.IsPrimaryKey)
{
setter = GetSetMethod <long>(dummyHandle.SetInt64Unique);
}
else
{
setter = GetSetMethod <long>(dummyHandle.SetInt64);
}
break;
case Schema.PropertyType.Bool:
argumentType = typeof(bool);
if (property.IsNullable)
{
setter = GetSetMethod <bool?>(dummyHandle.SetNullableBoolean);
}
else
{
setter = GetSetMethod <bool>(dummyHandle.SetBoolean);
}
break;
case Schema.PropertyType.Float:
argumentType = typeof(float);
if (property.IsNullable)
{
setter = GetSetMethod <float?>(dummyHandle.SetNullableSingle);
}
else
{
setter = GetSetMethod <float>(dummyHandle.SetSingle);
}
break;
case Schema.PropertyType.Double:
argumentType = typeof(double);
if (property.IsNullable)
{
setter = GetSetMethod <double?>(dummyHandle.SetNullableDouble);
}
else
{
setter = GetSetMethod <double>(dummyHandle.SetDouble);
}
break;
case Schema.PropertyType.String:
argumentType = typeof(string);
if (property.IsPrimaryKey)
{
setter = GetSetMethod <string>(dummyHandle.SetStringUnique);
}
else
{
setter = GetSetMethod <string>(dummyHandle.SetString);
}
break;
case Schema.PropertyType.Data:
argumentType = typeof(byte[]);
setter = GetSetMethod <byte[]>(dummyHandle.SetByteArray);
break;
case Schema.PropertyType.Date:
argumentType = typeof(DateTimeOffset);
if (property.IsNullable)
{
setter = GetSetMethod <DateTimeOffset?>(dummyHandle.SetNullableDateTimeOffset);
}
else
{
setter = GetSetMethod <DateTimeOffset>(dummyHandle.SetDateTimeOffset);
}
break;
case Schema.PropertyType.Object:
argumentType = typeof(RealmObject);
arguments.Insert(0, Expression.Field(GetLimitedSelf(), RealmObjectRealmField));
setter = GetSetMethod <RealmObject>(dummyHandle.SetObject);
break;
}
if (property.IsNullable && argumentType.GetTypeInfo().IsValueType)
{
argumentType = typeof(Nullable <>).MakeGenericType(argumentType);
}
var valueExpression = value.Expression;
if (valueExpression.Type != argumentType)
{
valueExpression = Expression.Convert(valueExpression, argumentType);
}
arguments.Add(valueExpression);
var expression = Expression.Block(Expression.Call(Expression.Field(GetLimitedSelf(), RealmObjectObjectHandleField), setter, arguments), Expression.Default(binder.ReturnType));
var argumentShouldBeDynamicRealmObject = BindingRestrictions.GetTypeRestriction(Expression, typeof(DynamicRealmObject));
var argumentShouldBeInTheSameRealm = BindingRestrictions.GetInstanceRestriction(Expression.Field(GetLimitedSelf(), RealmObjectRealmField), _realm);
return(new DynamicMetaObject(expression, argumentShouldBeDynamicRealmObject.Merge(argumentShouldBeInTheSameRealm)));
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value) {
Debug.Assert(value.Value != Uninitialized.Instance);
return new DynamicMetaObject(
Expression.Block(
Expression.Call(
Utils.Convert(Expression, typeof(PythonModule)),
typeof(PythonModule).GetMethod("__setattr__"),
PythonContext.GetCodeContext(binder),
Expression.Constant(binder.Name),
Expression.Convert(value.Expression, typeof(object))
),
Expression.Convert(value.Expression, typeof(object))
),
BindingRestrictions.GetTypeRestriction(Expression, Value.GetType())
);
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
{
return(IsOverridden("TrySetMember")
? CallMethodReturnLast("TrySetMember", binder, GetArgs(value), e => binder.FallbackSetMember(this, value, e))
: base.BindSetMember(binder, value));
}
public override bool TrySetMember( SetMemberBinder binder, object value )
{
var meta = _Schema.Find( null, binder.Name, anyTable: true, raise: false );
if( meta != null ) { int ix = _Schema.IndexOf( meta ); _Columns[ix] = value; }
// For compose specifications, the dynamic getter has taken care of the Table part...
else throw new KeyNotFoundException( "Member not found: " + binder.Name );
return true;
}
/// <summary>
/// Set arbitrary property
/// </summary>
/// <param name="binder">Name of arbitrary property</param>
/// <param name="value">Value for arbitrary property</param>
/// <returns>Returns true after setting property</returns>
public override bool TrySetMember(SetMemberBinder binder, object value)
{
this[binder.Name] = value;
return(true);
}
public override DynamicMetaObject/*!*/ BindSetMember(SetMemberBinder/*!*/ action, DynamicMetaObject/*!*/ value) {
DynamicMetaObject self = Restrict(Value.GetType());
CodeContext context = BinderState.GetBinderState(action).Context;
IPythonObject sdo = Value;
SetBindingInfo bindingInfo = new SetBindingInfo(
action,
new DynamicMetaObject[] { this, value },
new ConditionalBuilder(action),
BindingHelpers.GetValidationInfo(self.Expression, sdo.PythonType)
);
DynamicMetaObject res = null;
// call __setattr__ if it exists
PythonTypeSlot dts;
if (sdo.PythonType.TryResolveSlot(context, Symbols.SetAttr, out dts) && !IsStandardObjectMethod(dts)) {
// skip the fake __setattr__ on mixed new-style/old-style types
if (dts != null) {
MakeSetAttrTarget(bindingInfo, sdo, dts);
res = bindingInfo.Body.GetMetaObject(this, value);
}
}
if (res == null) {
// then see if we have a set descriptor
bool isOldStyle;
bool systemTypeResolution;
dts = FindSlot(context, action.Name, sdo, out isOldStyle, out systemTypeResolution);
ReflectedSlotProperty rsp = dts as ReflectedSlotProperty;
if (rsp != null) {
MakeSlotsSetTarget(bindingInfo, rsp, value.Expression);
res = bindingInfo.Body.GetMetaObject(this, value);
} else if (dts != null && dts.IsSetDescriptor(context, sdo.PythonType)) {
if (systemTypeResolution) {
res = Fallback(action, value);
} else {
res = MakeSlotSet(bindingInfo, dts);
}
}
}
if (res == null) {
// finally if we have a dictionary set the value there.
if (sdo.HasDictionary) {
MakeDictionarySetTarget(bindingInfo);
} else {
bindingInfo.Body.FinishCondition(
FallbackSetError(action, value).Expression
);
}
res = bindingInfo.Body.GetMetaObject(this, value);
}
res = new DynamicMetaObject(
res.Expression,
self.Restrictions.Merge(res.Restrictions)
);
return BindingHelpers.AddDynamicTestAndDefer(
action,
res,
new DynamicMetaObject[] { this, value },
bindingInfo.Validation
);
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value) {
ContractUtils.RequiresNotNull(binder, "binder");
return
// 1. Check for simple property put
TryPropertyPut(binder, value) ??
// 2. Check for event handler hookup where the put is dropped
TryEventHandlerNoop(binder, value) ??
// 3. Fallback
base.BindSetMember(binder, value);
}
/// <summary>
/// Helper for falling back - if we have a base object fallback to it first (which can
/// then fallback to the calling site), otherwise fallback to the calling site.
/// </summary>
private DynamicMetaObject/*!*/ FallbackSetError(SetMemberBinder/*!*/ action, DynamicMetaObject/*!*/ value) {
if (_baseMetaObject != null) {
return _baseMetaObject.BindSetMember(action, value);
} else if (action is PythonSetMemberBinder) {
return new DynamicMetaObject(
MakeTypeError(action.Name, Value.PythonType),
BindingRestrictions.Empty
);
}
return action.FallbackSetMember(this, value);
}
private DynamicMetaObject TryPropertyPut(SetMemberBinder binder, DynamicMetaObject value) {
ComMethodDesc method;
bool holdsNull = value.Value == null && value.HasValue;
if (_self.TryGetPropertySetter(binder.Name, out method, value.LimitType, holdsNull) ||
_self.TryGetPropertySetterExplicit(binder.Name, out method, value.LimitType, holdsNull)) {
BindingRestrictions restrictions = IDispatchRestriction();
Expression dispatch =
Expression.Property(
Helpers.Convert(Expression, typeof(IDispatchComObject)),
typeof(IDispatchComObject).GetProperty("DispatchObject")
);
var result = new ComInvokeBinder(
new CallInfo(1),
new[] { value },
new bool[] { false },
restrictions,
Expression.Constant(method),
dispatch,
method
).Invoke();
// Make sure to return the value; some languages need it.
return new DynamicMetaObject(
Expression.Block(result.Expression, Expression.Convert(value.Expression, typeof(object))),
result.Restrictions
);
}
return null;
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value) {
// fallback w/ an error suggestion that does a late bound set
return binder.FallbackSetMember(
this,
value,
new DynamicMetaObject(
Ast.Call(
typeof(PythonOps).GetMethod("PythonFunctionSetMember"),
AstUtils.Convert(
Expression,
typeof(PythonFunction)
),
Expression.Constant(binder.Name),
AstUtils.Convert(
value.Expression,
typeof(object)
)
),
BindingRestrictions.GetTypeRestriction(Expression, typeof(PythonFunction))
)
);
}
private DynamicMetaObject TryEventHandlerNoop(SetMemberBinder binder, DynamicMetaObject value) {
ComEventDesc @event;
if (_self.TryGetMemberEvent(binder.Name, out @event) && value.LimitType == typeof(BoundDispEvent)) {
// Drop the event property set.
return new DynamicMetaObject(
Expression.Constant(null),
value.Restrictions.Merge(IDispatchRestriction()).Merge(BindingRestrictions.GetTypeRestriction(value.Expression, typeof(BoundDispEvent)))
);
}
return null;
}
public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value) {
IScopeVariable variable = Value.GetVariable(binder.Name, binder.IgnoreCase);
var objExpression = ExpressionUtils.Convert(value.Expression, typeof(object));
return new DynamicMetaObject(
Expression.Block(
Expression.Call(
Variable(variable),
variable.GetType().GetMethod("SetValue"),
objExpression
),
objExpression
),
BindingRestrictions.GetInstanceRestriction(Expression, Value)
);
}
// dynamic attribute setting
public override bool TrySetMember(SetMemberBinder binder, object value)
{
setattr(binder.Name, value);
return(true);
}
