public override DynamicMetaObject BindGetMember(GetMemberBinder binder) {
ComBinder.ComGetMemberBinder comBinder = binder as ComBinder.ComGetMemberBinder;
bool canReturnCallables = comBinder == null ? false : comBinder._CanReturnCallables;
ContractUtils.RequiresNotNull(binder, "binder");
ComMethodDesc method;
ComEventDesc @event;
// 1. Try methods
if (_self.TryGetMemberMethod(binder.Name, out method)) {
return BindGetMember(method, canReturnCallables);
}
// 2. Try events
if (_self.TryGetMemberEvent(binder.Name, out @event)) {
return BindEvent(@event);
}
// 3. Try methods explicitly by name
if (_self.TryGetMemberMethodExplicit(binder.Name, out method)) {
return BindGetMember(method, canReturnCallables);
}
// 4. Fallback
return base.BindGetMember(binder);
}
public static bool TryBindGetMember(GetMemberBinder binder, DynamicMetaObject instance, out DynamicMetaObject result, bool delayInvocation) {
ContractUtils.RequiresNotNull(binder, "binder");
ContractUtils.RequiresNotNull(instance, "instance");
if (TryGetMetaObject(ref instance)) {
//
// Demand Full Trust to proceed with the binding.
//
new PermissionSet(PermissionState.Unrestricted).Demand();
var comGetMember = new ComGetMemberBinder(binder, delayInvocation);
result = instance.BindGetMember(comGetMember);
if (result.Expression.Type.IsValueType) {
result = new DynamicMetaObject(
Expression.Convert(result.Expression, typeof(object)),
result.Restrictions
);
}
return true;
} else {
result = null;
return false;
}
}
public static DynamicMetaObject TryBind(RubyContext/*!*/ context, GetMemberBinder/*!*/ binder, DynamicMetaObject/*!*/ target) {
Assert.NotNull(context, target);
var metaBuilder = new MetaObjectBuilder();
var contextExpression = AstUtils.Constant(context);
RubyClass targetClass = context.GetImmediateClassOf(target.Value);
MethodResolutionResult method;
RubyMemberInfo methodMissing = null;
using (targetClass.Context.ClassHierarchyLocker()) {
metaBuilder.AddTargetTypeTest(target.Value, targetClass, target.Expression, context, contextExpression);
method = targetClass.ResolveMethodForSiteNoLock(binder.Name, RubyClass.IgnoreVisibility);
if (method.Found) {
methodMissing = targetClass.ResolveMethodForSiteNoLock(Symbols.MethodMissing, RubyClass.IgnoreVisibility).Info;
}
}
if (method.Found) {
// we need to create a bound member:
metaBuilder.Result = AstUtils.Constant(new RubyMethod(target.Value, method.Info, binder.Name));
} else {
// TODO:
// We need to throw an exception if we don't find method_missing so that our version update optimization works:
// This limits interop with other languages.
//
// class B CLR type with method 'foo'
// class C < B Ruby class
// x = C.new
//
// 1. x.GET("foo") from Ruby
// No method found or CLR method found -> fallback to Python
// Python might see its method foo or might just fallback to .NET,
// in any case it will add rule [1] with restriction on type of C w/o Ruby version check.
// 2. B.define_method("foo")
// This doesn't update C due to the optimization (there is no overridden method foo in C).
// 3. x.GET("foo") from Ruby
// This will not invoke the binder since the rule [1] is still valid.
//
object symbol = SymbolTable.StringToId(binder.Name);
RubyCallAction.BindToMethodMissing(metaBuilder,
new CallArguments(
new DynamicMetaObject(contextExpression, BindingRestrictions.Empty, context),
new[] {
target,
new DynamicMetaObject(AstUtils.Constant(symbol), BindingRestrictions.Empty, symbol)
},
RubyCallSignature.Simple(1)
),
binder.Name,
methodMissing,
method.IncompatibleVisibility,
false
);
}
// TODO: we should return null if we fail, we need to throw exception for now:
return metaBuilder.CreateMetaObject(binder, DynamicMetaObject.EmptyMetaObjects);
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
if (storage.ContainsKey(binder.Name))
{
result = storage[binder.Name];
return true;
}
result = null;
return false;
}
// Returns the name of the property back as the result, but is a stickler for .NET naming
// conventions and returns false if the first character isn't uppercase
// (Correct handling of Unicode category Lt omitted)
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
string name = binder.Name;
if (char.IsUpper(name[0]))
{
result = binder.Name;
return true;
}
result = null;
return false;
}
public static MetaObject TryBind(RubyContext/*!*/ context, GetMemberBinder/*!*/ binder, MetaObject/*!*/ target) {
Assert.NotNull(context, target);
var metaBuilder = new MetaObjectBuilder();
var contextExpression = Ast.Constant(context);
metaBuilder.AddTargetTypeTest(target.Value, target.Expression, context, contextExpression);
RubyMemberInfo method = context.ResolveMethod(target.Value, binder.Name, true).InvalidateSitesOnOverride();
if (method != null && RubyModule.IsMethodVisible(method, false)) {
// we need to create a bound member:
metaBuilder.Result = Ast.Constant(new RubyMethod(target.Value, method, binder.Name));
} else {
// TODO:
// We need to throw an exception if we don't find method_missing so that our version update optimization works:
// This limits interop with other languages.
//
// class B CLR type with method 'foo'
// class C < B Ruby class
// x = C.new
//
// 1. x.GET("foo") from Ruby
// No method found or CLR method found -> fallback to Python
// Python might see its method foo or might just fallback to .NET,
// in any case it will add rule [1] with restriction on type of C w/o Ruby version check.
// 2. B.define_method("foo")
// This doesn't update C due to the optimization (there is no overridden method foo in C).
// 3. x.GET("foo") from Ruby
// This will not invoke the binder since the rule [1] is still valid.
//
object symbol = SymbolTable.StringToId(binder.Name);
RubyCallAction.BindToMethodMissing(metaBuilder, binder.Name,
new CallArguments(
new MetaObject(contextExpression, Restrictions.Empty, context),
new[] {
target,
new MetaObject(Ast.Constant(symbol), Restrictions.Empty, symbol)
},
RubyCallSignature.Simple(1)
),
method != null
);
}
// TODO: we should return null if we fail, we need to throw exception for now:
return metaBuilder.CreateMetaObject(binder, MetaObject.EmptyMetaObjects);
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = null;
if (_object is JArray)
{
JArray jArray = _object as JArray;
switch (binder.Name)
{
case "Length":
case "Count": result = jArray.Count; break;
case "ToList": result = (Func<List<string>>)(() => jArray.Values().Select(x => x.ToString()).ToList()); break;
case "ToArray": result = (Func<string[]>)(() => jArray.Values().Select(x => x.ToString()).ToArray()); break;
}
return true;
}
JObject jObject = _object as JObject;
object obj = jObject.SelectToken(binder.Name);
if (obj == null) return true;
if (obj is JValue)
result = GetValue(obj);
else
result = new JsonObject(obj);
return true;
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
throw new Exception();
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = _tracker[binder.Name];
return true;
}
public override DynamicMetaObject BindGetMember( GetMemberBinder binder )
{
DEBUG.IndentLine( "\n-- BindGetMember: {0}", binder.Name );
var obj = (DynamicNode)this.Value;
var node = new DynamicNode.GetMember( obj, binder.Name ) { _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 TryGetMember(GetMemberBinder binder, out object result)
{
if (_values.TryGetValue(binder.Name, out result)) {
return true;
}
// finds an element of given name:
switch (binder.Name) {
case "element1": result = "e1"; return true;
case "element2": result = "e2"; return true;
}
result = null;
return false;
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
{
return(IsOverridden("TryGetMember")
? CallMethodWithResult("TryGetMember", binder, NoArgs, e => binder.FallbackGetMember(this, e))
: base.BindGetMember(binder));
}
public NoThrowGetBinderMember(GetMemberBinder innerBinder)
: base(innerBinder.Name, innerBinder.IgnoreCase)
{
_innerBinder = innerBinder;
}
/// <summary>
/// Performs the binding of the dynamic get member operation.
/// </summary>
/// <param name="binder">An instance of the <see cref="GetMemberBinder"/> that represents the details of the dynamic operation.</param>
/// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
public virtual DynamicMetaObject BindGetMember(GetMemberBinder binder) {
ContractUtils.RequiresNotNull(binder, "binder");
return binder.FallbackGetMember(this);
}
// Forward all dynamic operations or some of them as needed //
public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
{
return(AddRestrictions(_metaForwardee.BindGetMember(binder)));
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = Instance;
return(true);
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
return(TryGetMemberImpl(binder.Name, out result));
}
public override bool TryGetMember(JObject instance, GetMemberBinder binder, out object result)
{
// result can be null
result = instance[binder.Name];
return(true);
}
public override bool TryGetMember(GetMemberBinder binder, out object result) => accessor.TryGetMember(binder, out result, base.TryGetMember);
/// <summary>
/// Tries to perform binding of the dynamic get member operation.
/// </summary>
/// <param name="binder">An instance of the <see cref="GetMemberBinder"/> that represents the details of the dynamic operation.</param>
/// <param name="instance">The target of the dynamic operation. </param>
/// <param name="result">The new <see cref="DynamicMetaObject"/> representing the result of the binding.</param>
/// <returns>true if operation was bound successfully; otherwise, false.</returns>
public static bool TryBindGetMember(GetMemberBinder binder, DynamicMetaObject instance, out DynamicMetaObject result) {
return TryBindGetMember(binder, instance, out result, false);
}
public virtual bool TryGetMember(T instance, GetMemberBinder binder, out object result)
{
result = null;
return(false);
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder) => BaseMetaObject.BindGetMember(binder);
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = CheckNone(this.GetAttr(binder.Name));
return(true);
}
public virtual bool TryGetMember(GetMemberBinder binder, out object result) {
result = null;
return false;
}
private static CallSite <Func <CallSite, object, object> > CreateCallSiteGetter(string name)
{
GetMemberBinder getMemberBinder = (GetMemberBinder)DynamicUtils.BinderWrapper.GetMember(name, typeof(DynamicUtils));
return(CallSite <Func <CallSite, object, object> > .Create(new NoThrowGetBinderMember(getMemberBinder)));
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
{
Requires.NotNull(binder, nameof(binder));
return(binder.FallbackGetMember(UnwrapSelf()));
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
string name = binder.Name;
XmlNode firstNode = _element.SelectSingleNode(name);
if (firstNode != null && firstNode.NodeType == XmlNodeType.Element)
{
result = GetResultFromElement(firstNode as XmlElement, _autoType);
return(true);
}
switch (name)
{
case "Text":
case "Value":
result = _element.InnerText;
return(true);
case "Name":
case "Tag":
result = _element.Name;
return(true);
case "Count":
case "Length":
result = GetElements(_element.ParentNode, _element.Name).Count();
return(true);
default:
if (name.EndsWith("Attr"))
{
foreach (string n in PossibleNames(name.Substring(0, name.Length - 4), FuzzyNames, true))
{
if (_element.HasAttribute(n))
{
string s = _element.GetAttribute(n);
result = !_autoType ? s : GetObjectFromString(s);
return(true);
}
}
}
switch (_element.Name)
{
// special case to support appSettings section in app/web.configs
case "appSettings":
{
foreach (string n in PossibleNames(name, FuzzyNames, true))
{
// no need to sanitize xpath to prevent injection,
// because n is value of variable name and
// it cannot contain characters required for injection
XmlNode node = _element.SelectSingleNode($"add[@key='{n}']");
if (node != null && node.NodeType == XmlNodeType.Element)
{
string s = (node as XmlElement)?.GetAttribute("value");
result = !_autoType ? s : GetObjectFromString(s);
return(true);
}
}
break;
}
// special case to support connectionStrings section in app/web.configs
case "connectionStrings":
{
foreach (string n in PossibleNames(name, FuzzyNames, true))
{
// no need to sanitize xpath to prevent injection,
// because n is value of variable name and
// it cannot contain characters required for injection
XmlNode node = _element.SelectSingleNode($"add[@name='{n}']");
if (node != null && node.NodeType == XmlNodeType.Element)
{
result = (node as XmlElement)?.GetAttribute("connectionString");
return(true);
}
}
break;
}
}
foreach (string n in PossibleNames(name, FuzzyNames, true))
{
XmlNode node = _element.SelectSingleNode(n);
if (node != null && node.NodeType == XmlNodeType.Element)
{
result = GetResultFromElement(node as XmlElement, _autoType);
return(true);
}
}
break;
}
result = null;
return(NullOnNotFound);
}
public override DynamicMetaObject/*!*/ BindGetMember(GetMemberBinder/*!*/ member) {
return MakeMemberAccess(member, member.Name, MemberAccess.Get, this);
}
/// <summary>
/// Provides the implementation for operations that get 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 getting a value for a property.
/// </summary>
/// <param name="binder"> Provides information about the object that called the dynamic operation. The binder.Name property provides the name of the member on which the dynamic operation is performed. For example, for the Console.WriteLine(sampleObject.SampleProperty) statement, 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="result"> The result of the get operation. For example, if the method is called for a property, you can assign the property value to <paramref
/// name="result" /> . </param>
/// <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 run-time exception is thrown.) </returns>
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = null;
return(this.MassageResultBasedOnInterface(binder.Name, true, ref result));
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
return((IsArray)
? TryGet(xml.Elements().ElementAtOrDefault(int.Parse(binder.Name)), out result)
: TryGet(xml.Element(binder.Name), out result));
}
/// <summary>
/// Tries to perform binding of the dynamic get member operation.
/// </summary>
/// <param name="binder">An instance of the <see cref="GetMemberBinder"/> that represents the details of the dynamic operation.</param>
/// <param name="instance">The target of the dynamic operation. </param>
/// <param name="result">The new <see cref="DynamicMetaObject"/> representing the result of the binding.</param>
/// <returns>true if operation was bound successfully; otherwise, false.</returns>
public static bool TryBindGetMember(GetMemberBinder binder, DynamicMetaObject instance, out DynamicMetaObject result)
{
return(TryBindGetMember(binder, instance, out result, false));
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder) {
if (binder.Name == "__dict__") {
return new DynamicMetaObject(
Expression.Property(
Utils.Convert(Expression, typeof(PythonModule)),
typeof(PythonModule).GetProperty("__dict__")
),
BindingRestrictions.GetTypeRestriction(Expression, Value.GetType())
);
}
var tmp = Expression.Variable(typeof(object), "res");
return new DynamicMetaObject(
Expression.Block(
new[] { tmp },
Expression.Condition(
Expression.Call(
typeof(PythonOps).GetMethod("ModuleGetMember"),
Utils.Convert(Expression, typeof(PythonModule)),
Expression.Constant(binder.Name),
tmp
),
tmp,
binder.FallbackGetMember(this).Expression
)
),
BindingRestrictions.GetTypeRestriction(Expression, Value.GetType())
);
}
internal ComGetMemberBinder(GetMemberBinder originalBinder, bool CanReturnCallables) :
base(originalBinder.Name, originalBinder.IgnoreCase)
{
_originalBinder = originalBinder;
_CanReturnCallables = CanReturnCallables;
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
for (int idx = 0; idx != Names.Length; ++idx)
{
if (binder.Name == Names[idx])
{
result = idx;
return true;
}
}
result = null;
return false;
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = ViewData[binder.Name];
// since ViewDataDictionary always returns a result even if the key does not exist, always return true
return(true);
}
public override DynamicMetaObject /*!*/ BindGetMember(GetMemberBinder /*!*/ binder)
{
return(InteropBinder.GetMember.Bind(CreateMetaContext(), binder, this, binder.FallbackGetMember));
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
string name = binder.Name;
if (String.CompareOrdinal(name, "Name") == 0)
{
result = _element.Name.LocalName;
return(true);
}
else if (String.CompareOrdinal(name, "Parent") == 0)
{
XElement parent = _element.Parent;
if (parent != null)
{
result = new XmlNode(parent);
return(true);
}
result = null;
return(false);
}
else if (String.CompareOrdinal(name, "Value") == 0)
{
result = _element.Value;
return(true);
}
else if (String.CompareOrdinal(name, "Nodes") == 0)
{
result = new XmlNodeList(_element.Elements());
return(true);
}
else if (String.CompareOrdinal(name, "Xml") == 0)
{
StringWriter sw = new StringWriter();
_element.Save(sw, SaveOptions.None);
result = sw.ToString();
return(true);
}
else
{
XAttribute attribute = _element.Attribute(name);
if (attribute != null)
{
result = attribute.Value;
return(true);
}
XElement childNode = _element.Element(name);
if (childNode != null)
{
if (childNode.HasElements == false)
{
result = childNode.Value;
return(true);
}
result = new XmlNode(childNode);
return(true);
}
}
return(base.TryGetMember(binder, out result));
}
internal ComGetMemberBinder(GetMemberBinder originalBinder, bool CanReturnCallables) :
base(originalBinder.Name, originalBinder.IgnoreCase) {
_originalBinder = originalBinder;
_CanReturnCallables = CanReturnCallables;
}
public override DynamicMetaObject/*!*/ BindGetMember(GetMemberBinder/*!*/ member) {
return GetMemberWorker(member, BinderState.GetCodeContext(member));
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = this[binder.Name];
return true;
}
public override DynamicMetaObject/*!*/ BindGetMember(GetMemberBinder/*!*/ member) {
return MakeGetMember(member, PythonContext.GetCodeContextMO(member));
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder) {
if (IsOverridden("TryGetMember")) {
return CallMethodWithResult("TryGetMember", binder, NoArgs, (e) => binder.FallbackGetMember(this, e));
}
return base.BindGetMember(binder);
}
public override bool TryGetMember( GetMemberBinder binder, out object result )
{
var meta = _Schema.Find( null, binder.Name, anyTable: true, raise: false );
if( meta != null ) { int ix = _Schema.IndexOf( meta ); result = _Columns[ix]; }
// We defer the getter to be located using the binder's name as the table name...
else result = new KRecordDynamicTable( this, binder.Name );
return true;
}
public override bool TryGetMember( GetMemberBinder binder, out object result )
{
// Only invoked in forms of type "x => x.Table.Column" ...
result = new KRecordBuilderDynamicTable( this, binder.Name );
return true;
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder) {
IScopeVariable variable = Value.GetVariable(binder.Name, binder.IgnoreCase);
var tmp = Expression.Parameter(typeof(object));
return new DynamicMetaObject(
Expression.Block(
new[] { tmp },
Expression.Condition(
Expression.Call(
Expression.Constant(variable),
variable.GetType().GetMethod("TryGetValue"),
tmp
),
tmp,
binder.FallbackGetMember(this).Expression
)
),
BindingRestrictions.GetInstanceRestriction(Expression, Value)
);
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = this.Get(binder.ReturnType, binder.Name);
return(true);
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
{
Schema.Property property;
if (!_metadata.Schema.TryFindProperty(binder.Name, out property))
{
return(base.BindGetMember(binder));
}
var arguments = new List <Expression>
{
WeakConstant(_metadata.Table),
Expression.Constant(_metadata.ColumnIndices[property.Name]),
Expression.Property(Expression.Field(GetLimitedSelf(), RealmObjectRowHandleField), RowHandleRowIndexProperty),
};
MethodInfo getter = null;
switch (property.Type)
{
case Schema.PropertyType.Int:
if (property.IsNullable)
{
getter = GetGetMethod(NativeTable.GetNullableInt64);
}
else
{
getter = GetGetMethod(NativeTable.GetInt64);
}
break;
case Schema.PropertyType.Bool:
if (property.IsNullable)
{
getter = GetGetMethod(NativeTable.GetNullableBoolean);
}
else
{
getter = GetGetMethod(NativeTable.GetBoolean);
}
break;
case Schema.PropertyType.Float:
if (property.IsNullable)
{
getter = GetGetMethod(NativeTable.GetNullableSingle);
}
else
{
getter = GetGetMethod(NativeTable.GetSingle);
}
break;
case Schema.PropertyType.Double:
if (property.IsNullable)
{
getter = GetGetMethod(NativeTable.GetNullableDouble);
}
else
{
getter = GetGetMethod(NativeTable.GetDouble);
}
break;
case Schema.PropertyType.String:
getter = GetGetMethod(NativeTable.GetString);
break;
case Schema.PropertyType.Data:
getter = GetGetMethod(NativeTable.GetByteArray);
break;
case Schema.PropertyType.Date:
if (property.IsNullable)
{
getter = GetGetMethod(NativeTable.GetNullableDateTimeOffset);
}
else
{
getter = GetGetMethod(NativeTable.GetDateTimeOffset);
}
break;
case Schema.PropertyType.Object:
arguments.Insert(0, Expression.Field(GetLimitedSelf(), RealmObjectRealmField));
arguments.Add(Expression.Constant(property.ObjectType));
getter = GetGetMethod(RealmObjectOps.GetObject <DynamicRealmObject>);
break;
case Schema.PropertyType.Array:
arguments.Insert(0, Expression.Field(GetLimitedSelf(), RealmObjectRealmField));
arguments.Add(Expression.Constant(property.ObjectType));
getter = GetGetMethod(RealmObjectOps.GetList <DynamicRealmObject>);
break;
}
Expression expression = Expression.Call(getter, arguments);
if (binder.ReturnType != expression.Type)
{
expression = Expression.Convert(expression, 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 bool TryGetMember(GetMemberBinder binder, out object result)
{
result = GetSetting(binder.Name);
return true;
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = Context.Properties[binder.Name];
return(true);
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder) {
ContractUtils.RequiresNotNull(binder, "binder");
return binder.FallbackGetMember(UnwrapSelf());
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
return(data.TryGetValue(binder.Name, out result));
}
public override bool TryGetMember( GetMemberBinder binder, out object result )
{
try {
int ix = _Record.Schema.IndexOf( _Table, binder.Name, anyTable: false );
if( ix >= 0 ) { result = _Record[ix]; return true; }
throw new KeyNotFoundException( "Column not found: " + string.Format( "{0}.{1}", _Table, binder.Name ) );
}
finally { Dispose(); }
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = GetValue(binder.Name);
return(true);
}
public override DynamicMetaObject/*!*/ BindGetMember(GetMemberBinder/*!*/ action) {
return GetMemberWorker(action, BinderState.GetCodeContext(action));
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = this[binder.Name];
return(true);
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder) {
return BindGetMemberWorker(binder, binder.Name, PythonContext.GetCodeContextMO(binder));
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
{
return(TryBindGetMember(binder.Name) ?? base.BindGetMember(binder));
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder) {
return DynamicTryGetValue(binder.Name, binder.IgnoreCase,
binder.FallbackGetMember(this).Expression,
(tmp) => tmp
);
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = new MemberAccessWrapper(HttpClientWrapper, BaseUri, binder.Name, new Dictionary <string, string>());
return(true);
}
