[IronPython] Problem calling proper version of function

[Steve Baer]

Hi Dino,
Thanks for the quick feedback. That's what I had feared may be the answer. 
I'll just have to rethink how we'll make IronPython available to Rhino.

It is good to know that there is an alternate way to call the interface 
property.

Thanks,
-Steve

Steve Baer
Robert McNeel & Associates
www.rhino3d.com
www.mcneel.com

----- Original Message ----- 
From: "Dino Viehland" <dinov at microsoft.com>
To: "Discussion of IronPython" <users at lists.ironpython.com>
Sent: Tuesday, September 02, 2008 8:22 PM
Subject: Re: [IronPython] Problem calling proper version of function


> We never have strong typing so we'll never see the difference between 
> GetInterface() and GetClass(). Instead we'll always just see that we have 
> a MyClass and do the lookup based upon that.  The worst case scenario here 
> is you'll need to do IMyInterface.MyProperty.GetValue(instance).
>
> OTOH if you can make MyClass or "public string MyProperty" internal then 
> they'd just not be visible to IronPython.  That'd mean we'd pick up the 
> explicit interface implementation as of the IronPython 2.0B4 I believe.
>
> -----Original Message-----
> From: users-bounces at lists.ironpython.com 
> [mailto:users-bounces at lists.ironpython.com] On Behalf Of Steve Baer
> Sent: Tuesday, September 02, 2008 8:02 PM
> To: Users at lists.ironpython.com
> Subject: [IronPython] Problem calling proper version of function
>
> This may just be how Python works, but I wanted to check with you guys
> first.
>
> Say I have an assembly named MyLibrary that contains the following code:
> namespace MyLibrary
> {
>  public interface IMyInterface
>  {
>    string MyProperty{ get;}
>  }
>  public class MyClass : IMyInterface
>  {
>    string IMyInterface.MyProperty
>    {
>      get { return "MyInterface version of MyProperty"; }
>    }
>    public string MyProperty
>    {
>      get { return "MyClass version of MyProperty"; }
>    }
>    public static IMyInterface GetInterface(){ return new MyClass();}
>    public static MyClass GetClass() { return new MyClass(); }
>  }
> }
> -------------------------------------------------------------
> A console application with the following code
>  MyLibrary.IMyInterface a = MyLibrary.MyClass.GetInterface();
>  Console.WriteLine("MyInterface call = " + a.MyProperty);
>  MyLibrary.MyClass b = MyLibrary.MyClass.GetClass();
>  Console.WriteLine("MyClass call = " + b.MyProperty);
>
> Will produce the following output:
>  MyInterface call = MyInterface version of MyProperty
>  MyClass call = MyClass version of MyProperty
> -------------------------------------------------------------
>
> Now if I use IronPython and write a script that looks like the following
>
> import clr
> clr.AddReference("MyLibrary")
> import MyLibrary
> a = MyLibrary.MyClass.GetInterface()
> print "MyInterface call = ", a.MyProperty
> b = MyLibrary.MyClass.GetClass()
> print "MyClass call = ", b.MyProperty
>
> The output of this script is
> MyInterface call = MyClass version of MyProperty
> MyClass call = MyClass version of MyProperty
>
> I've been testing IronPython on our CAD application and everything has 
> been
> working great except for this issue. It is actually a pretty big issue for
> me because the way I wrapped our C++ SDK for .NET uses this feature quite 
> a
> bit. If this is the expected result in python, is there a way to force the
> interface version of the property_get function to be called?
>
> Thanks,
> -Steve
>
> Steve Baer
> Robert McNeel & Associates
> www.rhino3d.com
> www.mcneel.com
>
> _______________________________________________
> Users mailing list
> Users at lists.ironpython.com
> http://lists.ironpython.com/listinfo.cgi/users-ironpython.com
> _______________________________________________
> Users mailing list
> Users at lists.ironpython.com
> http://lists.ironpython.com/listinfo.cgi/users-ironpython.com
>