Question

I have an interface with a base class in C# — I’d like to be able to implement derived classes in IronPython for embedded extensibility.

In C# I would have something like:

public interface IInterface
{
    bool SomeProperty { get; set; }
    bool SomeMethod(DateTime atTime);
}

public abstract class BaseClass : IInterface
{
    public BaseClass() {}

    private bool someProperty = true;
    public virtual bool SomeProperty
    {
        get { return someProperty; }
        set { someProperty = value; }
    }

    public virtual bool SomeMethod(DateTime atTime)
    {
        return true;
    }
}

Then a controller type class

public class SomeOtherClass
{
    List<IInterface> interfaceCollection = new List<IInterface>();

    ... factory here to create C# classes and IPy classes derived from BaseClass or IInterface ...

    interfaceCollection.Add(somePytonDerivedClass);
    foreach (var intExersize in interfaceCollection)
    {
        if (intExersize.SomeProperty == true)
        {
            intExersize.SomeMethod(DateTime.Now);
        }
    }
}

I’d like to do an impl in IronPython — something like:

class BaseClassIPy (BaseClass):
def __new__(self):
    print("Made it into the class")
    return BaseClass.__new__(self)

def __init__(self):
    pass

def get_SomeProperty(self):
    return BaseClass.SomeProperty

def set_SomeProperty(self, value):
    BaseClass.SomeProperty = value

def SomeMethod(self, atTime):
    return BaseClass.SomeMethod(atTime)

The new and init methods being called correctly —

but when I call the properties and methods on the IPy class, the calls seem to go directly to the base classes…

Is it a syntax issue? i.e. the IPy code is wrong?

Or am I missing something altogether?

Regards, Chad

—————- Edit —– method to inst python class:

private IInterface GetScriptPlugInNode()
{

    IInterface node = null;

    string plugInScript = "c:\\BaseClassIPy.py";
    string plugInClass = "BaseClassIPy";

    var options = new Dictionary<string, object>();
    ScriptRuntimeSetup setup = Python.CreateRuntimeSetup(options);
    setup.HostType = typeof(SelfContainedScriptHost);  //PAL impl
    setup.DebugMode = true;

    var pyRuntime = new ScriptRuntime(setup);
    var engineInstance = Python.GetEngine(pyRuntime);

    // Redirect search path to use embedded resources
    engineInstance.SetSearchPaths(new[] { String.Empty });

    var scope = engineInstance.CreateScope();

    ScriptSource source = engineInstance.CreateScriptSourceFromFile(plugInScript);

    source.Execute(scope);
    var typeClass = scope.GetVariable(plugInClass);
    var instance = engineInstance.Operations.CreateInstance(typeClass);
    node = instance;

    return node;

}

Answer 1

You have to change the interface property/method in your abstract base class to be virtual in order to allow the IronPython class to properly inherit from that.

public abstract class BaseClass : IInterface
{
    public BaseClass() {}

    private bool someProperty = true;
    public virtual bool SomeProperty
    {
        get { return someProperty; }
        set { someProperty = value; }
    }

    public virtual bool SomeMethod(DateTime atTime)
    {
        return true;
    }
}