FilesExpand file tree

 noncopyableanalyzer

/

pythonconsole.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

82 lines (73 loc) · 2.75 KB

 noncopyableanalyzer

/

pythonconsole.cs

Top

File metadata and controls

• Code
• Blame

82 lines (73 loc) · 2.75 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

using System;

using System.Collections.Generic;

using System.IO;

using System.Reflection;

using Python.Runtime;

namespace Python.Runtime

{

/// <summary>

/// Example of Embedding Python inside of a .NET program.

/// </summary>

/// <remarks>

/// It has similar functionality to doing `import clr` from within Python, but this does it

/// the other way around; That is, it loads Python inside of .NET program.

/// See https://github.com/pythonnet/pythonnet/issues/358 for more info.

/// </remarks>

public sealed class PythonConsole

{

#if NET40

private static AssemblyLoader assemblyLoader = new AssemblyLoader();

#endif

private PythonConsole()

{

}

[STAThread]

public static int Main(string[] args)

{

// Only .NET Framework is capable to safely inject python.runtime.dll into resources.

#if NET40

// reference the static assemblyLoader to stop it being optimized away

AssemblyLoader a = assemblyLoader;

#endif

string[] cmd = Environment.GetCommandLineArgs();

PythonEngine.Initialize();

int i = Runtime.Py_Main(cmd.Length, cmd);

PythonEngine.Shutdown();

return i;

}

#if NET40

// Register a callback function to load embedded assemblies.

// (Python.Runtime.dll is included as a resource)

private sealed class AssemblyLoader

{

private Dictionary<string, Assembly> loadedAssemblies;

public AssemblyLoader()

{

loadedAssemblies = new Dictionary<string, Assembly>();

AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>

{

string shortName = args.Name.Split(',')[0];

string resourceName = $"{shortName}.dll";

if (loadedAssemblies.ContainsKey(resourceName))

{

return loadedAssemblies[resourceName];

}

// looks for the assembly from the resources and load it

using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName))

{

if (stream != null)

{

var assemblyData = new byte[stream.Length];

stream.Read(assemblyData, 0, assemblyData.Length);

Assembly assembly = Assembly.Load(assemblyData);

loadedAssemblies[resourceName] = assembly;

return assembly;

}

}

return null;

};

}

}

#endif

}

}