IronPython中的默认成员/属性

Question

Is there a possibility to make IronPython access the default property of an object if the object instance is (directly) used?

The values accessed by IronPython are (in our program) wrapped in some class Variable<T> object, always having a property of type T named Value. When I write

if someBoolVariable:
    print "Hello World"

IronPython checks if someBoolVariable != null , which in our case always is true. Instead, I would prefer if it checks someBoolVariable.Value .

The same is true for numeric variables:

Temp = someDoubleVariable + someDoubleVariable

returns an error that the add operator is not implemented in the type. I would like to have it automatically evaluated to Temp = someDoubleVariable.Value + someDoubleVariable.Value .

I still want to be able to access the other properties of the object. Therefore, it is not posssible to convert the object when passing out of the scope. I've already tried to attach the DefaultMemberAttribute and/or the DefaultPropertyAttribute, but that does not seem to have any effect...

Edit:

For bool variables (which is one important group of them), I have found my answer. However, for numeric values, this would be nice too. In theory, I could create methods for all arithmetic operations, but there are a very large number of them - especially when mixing different types... It would be nicer to have something like a __value__() or __self__() method (which do not seem to exist) which simply returns the value to be used instead of the object...

Answer 1

I found a partial solution for boolean statements and expressions: To make variables behave the way I expect them, you only have to implement a special function named __nonzero__() :

public bool __nonzero__()
{
     return EqualityComparer<T>.Default.Equals(_value, default(T)) == false;
}

If the object is now used in boolean statements and expressions, it's value is evaluated instead of checking if it is null .

One drawback: The object that is implementing this method has to be public, otherwise it is ignored by python. There is maybe also be a possibility to implement it as a static function, however I'm not sure how to register it to python so that it is used.

Answer 2

IronPython doesn't support default properties (I think VB is the only language that does). Your best bet is to implement the operators on Variable<T> using dynamic , which should make it manageable. If you overload them in normal C# style IronPython will use them, or you can implement Python's __*__ methods.

For example (untested):

public static dynamic operator +(Value<t> v, dynamic d) {
  return v._value + d;
}

(Heh, static dynamic .)