- Incorporated reference-style links to issues and pull requests in the CHANGELOG ([#608][i608])

- Added detailed comments about aproaches and dangers to handle multi-app-domains ([#625][p625])

- Python 3.7 support, builds and testing added. Defaults changed from Python 3.6 to 3.7 ([#698][p698])

- Added support for C# types to provide `__repr__` ([#680][p680])

}

try

{

//As per python doc:

//The return value must be a string object. If a class defines __repr__() but not __str__(),

//then __repr__() is also used when an “informal” string representation of instances of that

//class is required.

//In C#, everything provides ToString(), so the check here will be whether the type explicitly

//provides ToString() or if it is language provided (i.e. the fully qualified type name as a string)

//First check which type in the object hierarchy provides ToString()

//ToString has two "official" overloads so loop over GetMethods to get the one without parameters

var instType = co.inst.GetType();

foreach (var method in instType.GetMethods())

{

//TODO this could probably be done more cleanly with Linq

if (!method.IsPublic) continue; //skip private/protected methods

if (method.Name != "ToString") continue; //only look for ToString

if (method.DeclaringType == typeof(object)) continue; //ignore default from object

if (method.GetParameters().Length != 0) continue; //ignore Formatter overload of ToString

//match! something other than object provides a parameter-less overload of ToString

return Runtime.PyString_FromString(co.inst.ToString());

}

//If the object defines __repr__, call it.

System.Reflection.MethodInfo reprMethodInfo = instType.GetMethod("__repr__");

if (reprMethodInfo != null && reprMethodInfo.IsPublic)

{

var reprString = reprMethodInfo.Invoke(co.inst, null) as string;

return Runtime.PyString_FromString(reprString);

}

//otherwise fallback to object's ToString() implementation

return Runtime.PyString_FromString(co.inst.ToString());

}

catch (Exception e)

{

if (e.InnerException != null)

{

e = e.InnerException;

}

Exceptions.SetError(e);

return IntPtr.Zero;

}

}

public static IntPtr tp_repr(IntPtr ob)

{

var co = GetManagedObject(ob) as CLRObject;

if (co == null)

{

return Exceptions.RaiseTypeError("invalid object");

}

try

{

//if __repr__ is defined, use it

var instType = co.inst.GetType();

System.Reflection.MethodInfo methodInfo = instType.GetMethod("__repr__");

if (methodInfo != null && methodInfo.IsPublic)

{

var reprString = methodInfo.Invoke(co.inst, null) as string;

return Runtime.PyString_FromString(reprString);

}

//otherwise use the standard object.__repr__(inst)

IntPtr args = Runtime.PyTuple_New(1);

Runtime.PyTuple_SetItem(args, 0, ob);

IntPtr reprFunc = Runtime.PyObject_GetAttrString(Runtime.PyBaseObjectType, "__repr__");

return Runtime.PyObject_Call(reprFunc, args, IntPtr.Zero);

}

catch (Exception e)

{

return e;

}

/// <summary>

/// Exception __repr__ implementation

/// </summary>

public static IntPtr tp_repr(IntPtr ob)

{

Exception e = ToException(ob);

if (e == null)

{

return Exceptions.RaiseTypeError("invalid object");

}

string name = e.GetType().Name;

string message;

if (e.Message != String.Empty)

{

message = String.Format("{0}('{1}')", name, e.Message);

}

else

{

message = String.Format("{0}()", name);

}

return Runtime.PyUnicode_FromString(message);

}

/// <summary>

/// Exception __str__ implementation

/// </summary>

<Compile Include="threadtest.cs" />

<Compile Include="doctest.cs" />

<Compile Include="subclasstest.cs" />

<Compile Include="reprtest.cs" />

</ItemGroup>

<ItemGroup>

<Reference Include="Microsoft.CSharp" />

using System;

using System.Text;

namespace Python.Test

/// <summary>

/// Supports repr unit tests.

/// </summary>

public class ReprTest

{

public class Point

{

public Point(double x, double y)

{

X = x;

Y = y;

}

public double X { get; set; }

public double Y { get; set; }

public override string ToString()

{

return base.ToString() + ": X=" + X.ToString() + ", Y=" + Y.ToString();

}

public string __repr__()

{

return "Point(" + X.ToString() + "," + Y.ToString() + ")";

}

}

public class Foo

{

public string __repr__()

{

return "I implement __repr__() but not ToString()!";

}

}

public class Bar

{

public override string ToString()

{

return "I implement ToString() but not __repr__()!";

}

}

public class BazBase

{

public override string ToString()

{

return "Base class implementing ToString()!";

}

}

public class BazMiddle : BazBase

{

public override string ToString()

{

return "Middle class implementing ToString()!";

}

}

//implements ToString via BazMiddle

public class Baz : BazMiddle

{

}

public class Quux

{

public string ToString(string format)

{

return "I implement ToString() with an argument!";

}

}

public class QuuzBase

{

protected string __repr__()

{

return "I implement __repr__ but it isn't public!";

}

}

public class Quuz : QuuzBase

{

}

public class Corge

{

public string __repr__(int i)

{

return "__repr__ implemention with input parameter!";

}

}

public class Grault

{

public int __repr__()

{

return "__repr__ implemention with wrong return type!".Length;

}

}

}

import System

import pytest

from Python.Test import ReprTest

def test_basic():

"""Test Point class which implements both ToString and __repr__ without inheritance"""

ob = ReprTest.Point(1,2)

# point implements ToString() and __repr__()

assert ob.__repr__() == "Point(1,2)"

assert str(ob) == "Python.Test.ReprTest+Point: X=1, Y=2"

def test_system_string():

"""Test system string"""

ob = System.String("hello")

assert str(ob) == "hello"

assert "<System.String object at " in ob.__repr__()

def test_repr_only():

"""Test class implementing __repr__() but not ToString()"""

ob = ReprTest.Foo()

assert str(ob) == "I implement __repr__() but not ToString()!"

assert ob.__repr__() == "I implement __repr__() but not ToString()!"

def test_str_only():

"""Test class implementing ToString() but not __repr__()"""

ob = ReprTest.Bar()

assert str(ob) == "I implement ToString() but not __repr__()!"

assert "<Python.Test.Bar object at " in ob.__repr__()

def test_hierarchy1():

"""Test inheritance heirarchy with base & middle class implementing ToString"""

ob1 = ReprTest.BazBase()

assert str(ob1) == "Base class implementing ToString()!"

assert "<Python.Test.BazBase object at " in ob1.__repr__()

ob2 = ReprTest.BazMiddle()

assert str(ob2) == "Middle class implementing ToString()!"

assert "<Python.Test.BazMiddle object at " in ob2.__repr__()

ob3 = ReprTest.Baz()

assert str(ob3) == "Middle class implementing ToString()!"

assert "<Python.Test.Baz object at " in ob3.__repr__()

def bad_tostring():

"""Test ToString that can't be used by str()"""

ob = ReprTest.Quux()

assert str(ob) == "Python.Test.ReprTest+Quux"

assert "<Python.Test.Quux object at " in ob.__repr__()

def bad_repr():

"""Test incorrect implementation of repr"""

ob1 = ReprTest.QuuzBase()

assert str(ob1) == "Python.Test.ReprTest+QuuzBase"

assert "<Python.Test.QuuzBase object at " in ob.__repr__()

ob2 = ReprTest.Quuz()

assert str(ob2) == "Python.Test.ReprTest+Quuz"

assert "<Python.Test.Quuz object at " in ob.__repr__()

ob3 = ReprTest.Corge()

with pytest.raises(Exception):

str(ob3)

with pytest.raises(Exception):

ob3.__repr__()

ob4 = ReprTest.Grault()

with pytest.raises(Exception):

str(ob4)

with pytest.raises(Exception):

ob4.__repr__()

<Compile Include="test_recursive_types.py" />

<Compile Include="test_subclass.py" />

<Compile Include="test_thread.py" />

<Compile Include="test_repr.py" />

<Compile Include="utils.py" />

<Compile Include="fixtures\argv-fixture.py" />

</ItemGroup>