Aug 31, 2017 · Sep 2, 2017 · Sep 2, 2017 · Sep 2, 2017 · Sep 5, 2017 · Sep 6, 2017
diff --git a/CHANGELOG.md b/CHANGELOG.md
 ## [unreleased][]

 ### Added

 -   Improved performance. String marshaling between python and clr now cached.
    Cache reduces GC pressure and saves from extensive memory copying.
 -   Added support for embedding python into dotnet core 2.0 (NetStandard 2.0)
 -   Added new build system (pythonnet.15.sln) based on dotnetcore-sdk/xplat(crossplatform msbuild).
    Currently there two side-by-side build systems that produces the same output (net40) from the same sources.
diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
    <Compile Include="TestPyWith.cs" />
    <Compile Include="TestRuntime.cs" />
    <Compile Include="TestPyScope.cs" />
    <Compile Include="TestsSuite.cs" />
    <Compile Include="TestTypeManager.cs" />
    <Compile Include="GlobalTestsSetup.cs" />
  </ItemGroup>
diff --git a/src/embed_tests/TestPythonEngineProperties.cs b/src/embed_tests/TestPythonEngineProperties.cs
 using System;
 using System.Diagnostics;
 using NUnit.Framework;
 using Python.Runtime;

diff --git a/src/embed_tests/TestRuntime.cs b/src/embed_tests/TestRuntime.cs

            // Don't shut down the runtime: if the python engine was initialized
            // but not shut down by another test, we'd end up in a bad state.
 }
 }

        [Test]
        public static void Py_IsInitializedValue()
diff --git a/src/embed_tests/TestsSuite.cs b/src/embed_tests/TestsSuite.cs
 using NUnit.Framework;
 using Python.Runtime;

 namespace Python.EmbeddingTest
 {
    [SetUpFixture]
    public class TestsSuite
    {
        [OneTimeTearDown]
        public void FinalCleanup()
        {
            if (PythonEngine.IsInitialized)
            {
                PythonEngine.Shutdown();
            }
        }
    }
 }
diff --git a/src/runtime/CustomMarshaler.cs b/src/runtime/CustomMarshaler.cs

        public abstract IntPtr MarshalManagedToNative(object managedObj);

        public void CleanUpNativeData(IntPtr pNativeData)
        publicvirtualvoid CleanUpNativeData(IntPtr pNativeData)
        {
            Marshal.FreeHGlobal(pNativeData);
        }
        private static readonly MarshalerBase Instance = new UcsMarshaler();
        private static readonly Encoding PyEncoding = Runtime.PyEncoding;

        public override IntPtr MarshalManagedToNative(object managedObj)
        private const int MaxStringLength = 100;
        private const int MaxItemSize = 4 * (MaxStringLength + 1);
        private static readonly EncodedStringsFifoDictionary EncodedStringsDictionary =
            new EncodedStringsFifoDictionary(10000, MaxItemSize);

        public override unsafe IntPtr MarshalManagedToNative(object managedObj)
        {
            var s = managedObj as string;

                return IntPtr.Zero;
            }

 byte[] bStr = PyEncoding.GetBytes(s + "\0");
 IntPtr mem = Marshal.AllocHGlobal(bStr.Length);
 try
 IntPtr mem;
 int stringBytesCount;
 if (s.Length <= MaxStringLength)
            {
                Marshal.Copy(bStr, 0, mem, bStr.Length);
                if (EncodedStringsDictionary.TryGetValue(s, out mem))
                {
                    return mem;
                }

                stringBytesCount = PyEncoding.GetByteCount(s);
                mem = EncodedStringsDictionary.AddUnsafe(s);
            }
 catch (Exception)
 else
            {
                Marshal.FreeHGlobal(mem);
                throw;
                stringBytesCount = PyEncoding.GetByteCount(s);
                mem = Marshal.AllocHGlobal(stringBytesCount + 4);
            }

            fixed (char* str = s)
            {
                try
                {
                    PyEncoding.GetBytes(str, s.Length, (byte*)mem, stringBytesCount);
                }
                catch
                {
                    // Do nothing with this. Very strange problem.
                }

                *(int*)(mem + stringBytesCount) = 0;
            }

            return mem;
            }
        }

        public override void CleanUpNativeData(IntPtr pNativeData)
        {
            if (!EncodedStringsDictionary.IsKnownPtr(pNativeData))
            {
                base.CleanUpNativeData(pNativeData);
            }
        }

        /// <summary>
        /// Utility function for Marshaling Unicode on PY3 and AnsiStr on PY2.
        /// Use on functions whose Input signatures changed between PY2/PY3.
        /// <remarks>
        /// You MUST deallocate the IntPtr of the Return when done with it.
        /// </remarks>
        public static IntPtr Py3UnicodePy2StringtoPtr(string s)
        publicunsafestatic IntPtr Py3UnicodePy2StringtoPtr(string s)
        {
            return Runtime.IsPython3
                ? Instance.MarshalManagedToNative(s)
                : Marshal.StringToHGlobalAnsi(s);
            if (Runtime.IsPython3)
            {
                int stringBytesCount = PyEncoding.GetByteCount(s);
                IntPtr mem = Marshal.AllocHGlobal(stringBytesCount + 4);
                fixed (char* str = s)
                {
                    try
                    {
                        PyEncoding.GetBytes(str, s.Length, (byte*)mem, stringBytesCount);
                    }
                    catch
                    {
                        // Do nothing with this. Very strange problem.
                    }

                    *(int*)(mem + stringBytesCount) = 0;
                }
                return mem;
            }

            return Marshal.StringToHGlobalAnsi(s);
        }

        /// <summary>
        private static readonly MarshalerBase Instance = new Utf8Marshaler();
        private static readonly Encoding PyEncoding = Encoding.UTF8;

        public override IntPtr MarshalManagedToNative(object managedObj)
        private const int MaxStringLength = 100;

        private static readonly EncodedStringsFifoDictionary EncodedStringsDictionary =
            new EncodedStringsFifoDictionary(10000, 4 * (MaxStringLength + 1));

        public override unsafe IntPtr MarshalManagedToNative(object managedObj)
        {
            var s = managedObj as string;

                return IntPtr.Zero;
            }

 byte[] bStr = PyEncoding.GetBytes(s + "\0");
 IntPtr mem = Marshal.AllocHGlobal(bStr.Length);
 try
 IntPtr mem;
 int stringBytesCount;
 if (s.Length <= MaxStringLength)
            {
                Marshal.Copy(bStr, 0, mem, bStr.Length);
                if (EncodedStringsDictionary.TryGetValue(s, out mem))
                {
                    return mem;
                }

                stringBytesCount = PyEncoding.GetByteCount(s);
                mem = EncodedStringsDictionary.AddUnsafe(s);
            }
 catch (Exception)
 else
            {
                Marshal.FreeHGlobal(mem);
                throw;
                stringBytesCount = PyEncoding.GetByteCount(s);
                mem = Marshal.AllocHGlobal(stringBytesCount + 1);
            }

            fixed (char* str = s)
            {
                try
                {
                    PyEncoding.GetBytes(str, s.Length, (byte*)mem, stringBytesCount);
                }
                catch
                {
                    // Do nothing with this. Very strange problem.
                }

                ((byte*)mem)[stringBytesCount] = 0;
            }

            return mem;
        }

        public override void CleanUpNativeData(IntPtr pNativeData)
        {
            if (!EncodedStringsDictionary.IsKnownPtr(pNativeData))
            {
                base.CleanUpNativeData(pNativeData);
            }
        }

        public static ICustomMarshaler GetInstance(string cookie)
        {
            return Instance;
diff --git a/src/runtime/Python.Runtime.csproj b/src/runtime/Python.Runtime.csproj
    <Reference Include="System" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="perf_utils\EncodedStringsFifoDictionary.cs" />
    <Compile Include="perf_utils\EncodingGetStringPolyfill.cs" />
    <Compile Include="perf_utils\FifoDictionary.cs" />
    <Compile Include="perf_utils\RawImmutableMemBlock.cs" />
    <Compile Include="perf_utils\RawMemoryFifoDictionary.cs" />
    <Compile Include="perf_utils\RawMemUtils.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="..\SharedAssemblyInfo.cs">
      <Link>Properties\SharedAssemblyInfo.cs</Link>
diff --git a/src/runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs
        //    So for multidomain support it is better to have the dict. recreated for each app-domain initialization
        private static ConcurrentDictionary<string, ConcurrentDictionary<Assembly, string>> namespaces =
            new ConcurrentDictionary<string, ConcurrentDictionary<Assembly, string>>();

        //private static Dictionary<string, Dictionary<string, string>> generics;
        private static AssemblyLoadEventHandler lhandler;
        private static ResolveEventHandler rhandler;
diff --git a/src/runtime/perf_utils/EncodedStringsFifoDictionary.cs b/src/runtime/perf_utils/EncodedStringsFifoDictionary.cs
 using System;

 namespace Python.Runtime
 {
    using System.Runtime.InteropServices;

    public class EncodedStringsFifoDictionary: IDisposable
    {
        private readonly FifoDictionary<string, IntPtr> _innerDictionary;

        private readonly IntPtr _rawMemory;

        private readonly int _allocatedSize;

        public EncodedStringsFifoDictionary(int capacity, int maxItemSize)
        {
            if (maxItemSize < 1)
            {
                throw new ArgumentOutOfRangeException(
                    nameof(maxItemSize),
                    "Maximum item size should be non-zero positive.");
            }

            _innerDictionary = new FifoDictionary<string, IntPtr>(capacity);
            _allocatedSize = maxItemSize * capacity;
            _rawMemory = Marshal.AllocHGlobal(_allocatedSize);

            MaxItemSize = maxItemSize;
        }

        public int MaxItemSize { get; }

        public bool TryGetValue(string key, out IntPtr value)
        {
            return _innerDictionary.TryGetValue(key, out value);
        }

        public IntPtr AddUnsafe(string key)
        {
            int nextSlot = _innerDictionary.NextSlotToAdd;
            IntPtr ptr = _rawMemory + (MaxItemSize * nextSlot);
            _innerDictionary.AddUnsafe(key, ptr);
            return ptr;
        }

        public bool IsKnownPtr(IntPtr ptr)
        {
            var uptr = (ulong)ptr;
            var umem = (ulong)_rawMemory;

            return uptr >= umem && uptr < umem + (ulong)_allocatedSize;
        }

        private void ReleaseUnmanagedResources()
        {
            if (_rawMemory != IntPtr.Zero)
            {
                Marshal.FreeHGlobal(_rawMemory);
            }
        }

        public void Dispose()
        {
            ReleaseUnmanagedResources();
            GC.SuppressFinalize(this);
        }

        ~EncodedStringsFifoDictionary()
        {
            ReleaseUnmanagedResources();
        }
    }
 }
diff --git a/src/runtime/perf_utils/EncodingGetStringPolyfill.cs b/src/runtime/perf_utils/EncodingGetStringPolyfill.cs
 using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Text;

 namespace Python.Runtime
 {
 #if !NETSTANDARD
    /// <summary>
    /// This polyfill is thread unsafe.
    /// </summary>
    [CLSCompliant(false)]
    public static class EncodingGetStringPolyfill
    {
        private static readonly MethodInfo PlatformGetStringMethodInfo =
            typeof(Encoding).GetMethod(
                "GetString",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null,
                new[]
                {
                    typeof(byte*), typeof(int)
                }, null);

        private static readonly byte[] StdDecodeBuffer = PlatformGetStringMethodInfo == null ? new byte[1024 * 1024] : null;

        private static Dictionary<Encoding, EncodingGetStringUnsafeDelegate> PlatformGetStringMethodsDelegatesCache = new Dictionary<Encoding, EncodingGetStringUnsafeDelegate>();

        private unsafe delegate string EncodingGetStringUnsafeDelegate(byte* pstr, int size);

        public unsafe static string GetString(this Encoding encoding, byte* pstr, int size)
        {
            if (PlatformGetStringMethodInfo != null)
            {
                EncodingGetStringUnsafeDelegate getStringDelegate;
                if (!PlatformGetStringMethodsDelegatesCache.TryGetValue(encoding, out getStringDelegate))
                {
                    getStringDelegate =
                        (EncodingGetStringUnsafeDelegate)Delegate.CreateDelegate(
                            typeof(EncodingGetStringUnsafeDelegate), encoding, PlatformGetStringMethodInfo);
                    PlatformGetStringMethodsDelegatesCache.Add(encoding, getStringDelegate);
                }
                return getStringDelegate(pstr, size);
            }

            byte[] buffer = size <= StdDecodeBuffer.Length ? StdDecodeBuffer : new byte[size];
            Marshal.Copy((IntPtr)pstr, buffer, 0, size);
            return encoding.GetString(buffer, 0, size);
        }
    }
 #endif

 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -8,7 +8,8 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
		## [unreleased][]

		### Added

		- Improved performance. String marshaling between python and clr now cached.
		Cache reduces GC pressure and saves from extensive memory copying.
		- Added support for embedding python into dotnet core 2.0 (NetStandard 2.0)
		- Added new build system (pythonnet.15.sln) based on dotnetcore-sdk/xplat(crossplatform msbuild).
		Currently there two side-by-side build systems that produces the same output (net40) from the same sources.
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -104,6 +104,7 @@
		<Compile Include="TestPyWith.cs" />
		<Compile Include="TestRuntime.cs" />
		<Compile Include="TestPyScope.cs" />
		<Compile Include="TestsSuite.cs" />
		<Compile Include="TestTypeManager.cs" />
		<Compile Include="GlobalTestsSetup.cs" />
		</ItemGroup>
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,4 +1,5 @@
		using System;
		using System.Diagnostics;
		using NUnit.Framework;
		using Python.Runtime;

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -34,7 +34,7 @@ public static void PlatformCache()

		// Don't shut down the runtime: if the python engine was initialized
		// but not shut down by another test, we'd end up in a bad state.
		}
		}

		[Test]
		public static void Py_IsInitializedValue()
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,18 @@
		using NUnit.Framework;
		using Python.Runtime;

		namespace Python.EmbeddingTest
		{
		[SetUpFixture]
		public class TestsSuite
		{
		[OneTimeTearDown]
		public void FinalCleanup()
		{
		if (PythonEngine.IsInitialized)
		{
		PythonEngine.Shutdown();
		}
		}
		}
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -18,7 +18,7 @@ public object MarshalNativeToManaged(IntPtr pNativeData)

		public abstract IntPtr MarshalManagedToNative(object managedObj);

		public void CleanUpNativeData(IntPtr pNativeData)
		publicvirtualvoid CleanUpNativeData(IntPtr pNativeData)
		{
		Marshal.FreeHGlobal(pNativeData);
		}
Expand All		@@ -44,7 +44,12 @@ internal class UcsMarshaler : MarshalerBase
		private static readonly MarshalerBase Instance = new UcsMarshaler();
		private static readonly Encoding PyEncoding = Runtime.PyEncoding;

		public override IntPtr MarshalManagedToNative(object managedObj)
		private const int MaxStringLength = 100;
		private const int MaxItemSize = 4 * (MaxStringLength + 1);
		private static readonly EncodedStringsFifoDictionary EncodedStringsDictionary =
		new EncodedStringsFifoDictionary(10000, MaxItemSize);

		public override unsafe IntPtr MarshalManagedToNative(object managedObj)
		{
		var s = managedObj as string;

Expand All		@@ -53,16 +58,36 @@ public override IntPtr MarshalManagedToNative(object managedObj)
		return IntPtr.Zero;
		}

		byte[] bStr = PyEncoding.GetBytes(s + "\0");
		IntPtr mem = Marshal.AllocHGlobal(bStr.Length);
		try
		IntPtr mem;
		int stringBytesCount;
		if (s.Length <= MaxStringLength)
		{
		Marshal.Copy(bStr, 0, mem, bStr.Length);
		if (EncodedStringsDictionary.TryGetValue(s, out mem))
		{
		return mem;
		}

		stringBytesCount = PyEncoding.GetByteCount(s);
		mem = EncodedStringsDictionary.AddUnsafe(s);
		}
		catch (Exception)
		else
		{
		Marshal.FreeHGlobal(mem);
		throw;
		stringBytesCount = PyEncoding.GetByteCount(s);
		mem = Marshal.AllocHGlobal(stringBytesCount + 4);
Copy link Member filmorOct 17, 2018 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Why`+4`, wouldn't one additional byte be enough?
		}

		fixed (char* str = s)
		{
		try
		{
		PyEncoding.GetBytes(str, s.Length, (byte*)mem, stringBytesCount);
		}
		catch
		{
		// Do nothing with this. Very strange problem.
Copy link Member filmorOct 17, 2018 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. When does this happen?
		}

		(int)(mem + stringBytesCount) = 0;
		}

		return mem;
Expand DownExpand Up		@@ -106,6 +131,14 @@ public static int GetUnicodeByteLength(IntPtr p)
		}
		}

		public override void CleanUpNativeData(IntPtr pNativeData)
		{
		if (!EncodedStringsDictionary.IsKnownPtr(pNativeData))
		{
		base.CleanUpNativeData(pNativeData);
		}
		}

		/// <summary>
		/// Utility function for Marshaling Unicode on PY3 and AnsiStr on PY2.
		/// Use on functions whose Input signatures changed between PY2/PY3.
Expand All		@@ -118,11 +151,29 @@ public static int GetUnicodeByteLength(IntPtr p)
		/// <remarks>
		/// You MUST deallocate the IntPtr of the Return when done with it.
		/// </remarks>
		public static IntPtr Py3UnicodePy2StringtoPtr(string s)
		publicunsafestatic IntPtr Py3UnicodePy2StringtoPtr(string s)
		{
		return Runtime.IsPython3
		? Instance.MarshalManagedToNative(s)
		: Marshal.StringToHGlobalAnsi(s);
		if (Runtime.IsPython3)
Copy link Member filmorOct 17, 2018 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. This means that your optimisation will only work at all for Python 3, is that necessary?
		{
		int stringBytesCount = PyEncoding.GetByteCount(s);
		IntPtr mem = Marshal.AllocHGlobal(stringBytesCount + 4);
		fixed (char* str = s)
		{
		try
		{
		PyEncoding.GetBytes(str, s.Length, (byte*)mem, stringBytesCount);
		}
		catch
		{
		// Do nothing with this. Very strange problem.
		}

		(int)(mem + stringBytesCount) = 0;
		}
		return mem;
		}

		return Marshal.StringToHGlobalAnsi(s);
		}

		/// <summary>
Expand DownExpand Up		@@ -208,7 +259,12 @@ internal class Utf8Marshaler : MarshalerBase
		private static readonly MarshalerBase Instance = new Utf8Marshaler();
		private static readonly Encoding PyEncoding = Encoding.UTF8;

		public override IntPtr MarshalManagedToNative(object managedObj)
		private const int MaxStringLength = 100;

		private static readonly EncodedStringsFifoDictionary EncodedStringsDictionary =
		new EncodedStringsFifoDictionary(10000, 4 * (MaxStringLength + 1));

		public override unsafe IntPtr MarshalManagedToNative(object managedObj)
		{
		var s = managedObj as string;

Expand All		@@ -217,21 +273,49 @@ public override IntPtr MarshalManagedToNative(object managedObj)
		return IntPtr.Zero;
		}

		byte[] bStr = PyEncoding.GetBytes(s + "\0");
		IntPtr mem = Marshal.AllocHGlobal(bStr.Length);
		try
		IntPtr mem;
		int stringBytesCount;
		if (s.Length <= MaxStringLength)
		{
		Marshal.Copy(bStr, 0, mem, bStr.Length);
		if (EncodedStringsDictionary.TryGetValue(s, out mem))
		{
		return mem;
		}

		stringBytesCount = PyEncoding.GetByteCount(s);
		mem = EncodedStringsDictionary.AddUnsafe(s);
		}
		catch (Exception)
		else
		{
		Marshal.FreeHGlobal(mem);
		throw;
		stringBytesCount = PyEncoding.GetByteCount(s);
		mem = Marshal.AllocHGlobal(stringBytesCount + 1);
		}

		fixed (char* str = s)
		{
		try
		{
		PyEncoding.GetBytes(str, s.Length, (byte*)mem, stringBytesCount);
		}
		catch
		{
		// Do nothing with this. Very strange problem.
		}

		((byte*)mem)[stringBytesCount] = 0;
		}

		return mem;
		}

		public override void CleanUpNativeData(IntPtr pNativeData)
		{
		if (!EncodedStringsDictionary.IsKnownPtr(pNativeData))
		{
		base.CleanUpNativeData(pNativeData);
		}
		}

		public static ICustomMarshaler GetInstance(string cookie)
		{
		return Instance;
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -76,6 +76,12 @@
		<Reference Include="System" />
		</ItemGroup>
		<ItemGroup>
		<Compile Include="perf_utils\EncodedStringsFifoDictionary.cs" />
		<Compile Include="perf_utils\EncodingGetStringPolyfill.cs" />
		<Compile Include="perf_utils\FifoDictionary.cs" />
		<Compile Include="perf_utils\RawImmutableMemBlock.cs" />
		<Compile Include="perf_utils\RawMemoryFifoDictionary.cs" />
		<Compile Include="perf_utils\RawMemUtils.cs" />
		<Compile Include="Properties\AssemblyInfo.cs" />
		<Compile Include="..\SharedAssemblyInfo.cs">
		<Link>Properties\SharedAssemblyInfo.cs</Link>
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -27,6 +27,7 @@ internal class AssemblyManager
		// So for multidomain support it is better to have the dict. recreated for each app-domain initialization
		private static ConcurrentDictionary<string, ConcurrentDictionary<Assembly, string>> namespaces =
		new ConcurrentDictionary<string, ConcurrentDictionary<Assembly, string>>();

		//private static Dictionary<string, Dictionary<string, string>> generics;
		private static AssemblyLoadEventHandler lhandler;
		private static ResolveEventHandler rhandler;
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,73 @@
		using System;

		namespace Python.Runtime
		{
		using System.Runtime.InteropServices;

		public class EncodedStringsFifoDictionary: IDisposable
		{
		private readonly FifoDictionary<string, IntPtr> _innerDictionary;

		private readonly IntPtr _rawMemory;

		private readonly int _allocatedSize;

		public EncodedStringsFifoDictionary(int capacity, int maxItemSize)
		{
		if (maxItemSize < 1)
		{
		throw new ArgumentOutOfRangeException(
		nameof(maxItemSize),
		"Maximum item size should be non-zero positive.");
		}

		_innerDictionary = new FifoDictionary<string, IntPtr>(capacity);
		_allocatedSize = maxItemSize * capacity;
		_rawMemory = Marshal.AllocHGlobal(_allocatedSize);

		MaxItemSize = maxItemSize;
		}

		public int MaxItemSize { get; }

		public bool TryGetValue(string key, out IntPtr value)
		{
		return _innerDictionary.TryGetValue(key, out value);
		}

		public IntPtr AddUnsafe(string key)
		{
		int nextSlot = _innerDictionary.NextSlotToAdd;
		IntPtr ptr = _rawMemory + (MaxItemSize * nextSlot);
		_innerDictionary.AddUnsafe(key, ptr);
		return ptr;
		}

		public bool IsKnownPtr(IntPtr ptr)
		{
		var uptr = (ulong)ptr;
		var umem = (ulong)_rawMemory;

		return uptr >= umem && uptr < umem + (ulong)_allocatedSize;
		}

		private void ReleaseUnmanagedResources()
		{
		if (_rawMemory != IntPtr.Zero)
		{
		Marshal.FreeHGlobal(_rawMemory);
		}
		}

		public void Dispose()
		{
		ReleaseUnmanagedResources();
		GC.SuppressFinalize(this);
		}

		~EncodedStringsFifoDictionary()
		{
		ReleaseUnmanagedResources();
		}
		}
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,53 @@
		using System;
		using System.Collections.Generic;
		using System.Reflection;
		using System.Runtime.InteropServices;
		using System.Text;

		namespace Python.Runtime
		{
		#if !NETSTANDARD
		/// <summary>
		/// This polyfill is thread unsafe.
		/// </summary>
		[CLSCompliant(false)]
		public static class EncodingGetStringPolyfill
		{
		private static readonly MethodInfo PlatformGetStringMethodInfo =
		typeof(Encoding).GetMethod(
		"GetString",
		BindingFlags.Instance \| BindingFlags.Public \| BindingFlags.NonPublic, null,
		new[]
		{
		typeof(byte*), typeof(int)
		}, null);

		private static readonly byte[] StdDecodeBuffer = PlatformGetStringMethodInfo == null ? new byte[1024 * 1024] : null;

		private static Dictionary<Encoding, EncodingGetStringUnsafeDelegate> PlatformGetStringMethodsDelegatesCache = new Dictionary<Encoding, EncodingGetStringUnsafeDelegate>();

		private unsafe delegate string EncodingGetStringUnsafeDelegate(byte* pstr, int size);

		public unsafe static string GetString(this Encoding encoding, byte* pstr, int size)
		{
		if (PlatformGetStringMethodInfo != null)
		{
		EncodingGetStringUnsafeDelegate getStringDelegate;
		if (!PlatformGetStringMethodsDelegatesCache.TryGetValue(encoding, out getStringDelegate))
		{
		getStringDelegate =
		(EncodingGetStringUnsafeDelegate)Delegate.CreateDelegate(
		typeof(EncodingGetStringUnsafeDelegate), encoding, PlatformGetStringMethodInfo);
		PlatformGetStringMethodsDelegatesCache.Add(encoding, getStringDelegate);
		}
		return getStringDelegate(pstr, size);
		}

		byte[] buffer = size <= StdDecodeBuffer.Length ? StdDecodeBuffer : new byte[size];
		Marshal.Copy((IntPtr)pstr, buffer, 0, size);
		return encoding.GetString(buffer, 0, size);
		}
		}
		#endif

		}