问题
I need to open a writable file handle in Python and then hand off the file descriptor to a function in a .NET assembly (accessed via pythonnet's clr module.
Getting from the Python file object to the win32 HANDLE*
is fairly straightforward, as shown in this question:
import clr
from Microsoft.Win32.SafeHandles import SafeFileHandle
from System.IO import FileStream, FileAccess
pyf=open("c:/temp/testing123.txt","w")
fileno=pyf.fileno()
print fileno # 6
handle = msvcrt.get_osfhandle(fileno)
print handle # 1832L
According to MSDN, it should now be possible to construct a standard FileStream
object from either a straight IntPtr
(the handle) or from a SafeFileHandle
wrapper.
FileStream(IntPtr, FileAccess)
FileStream(SafeFileHandle, FileAccess)
The problem is... how can I convince the clr
module to cast handle
as an IntPtr
?
I've tried various versions of the following, but they all give me errors:
FileStream(IntPtr(handle), True)
FileStream(IntPtr(Int64(handle), True)
FileStream(IntPtr(Int32(handle), True)
SafeFileHandle(IntPtr(handle), True)
...
=> TypeError ("value cannot be converted to System.IntPtr")
Any suggestions for how to get this darn file handle into C#?
回答1:
probably a bit too late for this answer, but would something like this have worked?
from contextlib import contextmanager
import ctypes
import io
import os, sys
import tempfile
libc = ctypes.CDLL(None)
c_stdout = ctypes.c_void_p.in_dll(libc, 'stdout')
@contextmanager
def stdout_redirector(stream):
# The original fd stdout points to. Usually 1 on POSIX systems.
original_stdout_fd = sys.stdout.fileno()
def _redirect_stdout(to_fd):
"""Redirect stdout to the given file descriptor."""
# Flush the C-level buffer stdout
libc.fflush(c_stdout)
# Flush and close sys.stdout - also closes the file descriptor (fd)
sys.stdout.close()
# Make original_stdout_fd point to the same file as to_fd
os.dup2(to_fd, original_stdout_fd)
# Create a new sys.stdout that points to the redirected fd
sys.stdout = io.TextIOWrapper(os.fdopen(original_stdout_fd, 'wb'))
# Save a copy of the original stdout fd in saved_stdout_fd
saved_stdout_fd = os.dup(original_stdout_fd)
try:
# Create a temporary file and redirect stdout to it
tfile = tempfile.TemporaryFile(mode='w+b')
_redirect_stdout(tfile.fileno())
# Yield to caller, then redirect stdout back to the saved fd
yield
_redirect_stdout(saved_stdout_fd)
# Copy contents of temporary file to the given stream
tfile.flush()
tfile.seek(0, io.SEEK_SET)
stream.write(tfile.read())
finally:
tfile.close()
os.close(saved_stdout_fd)
回答2:
Got an answer thanks to the good folks on the pythonnet mailing list.
The key is to use the Overloads
constructor to force-cast the win32 HANDLE
to IntPtr
type.
Here's a complete working example:
import tempfile, msvcrt
import clr, msvcrt
from System.IO import FileStream, FileAccess
from System import IntPtr
with tempfile.NamedTemporaryFile(suffix='.txt', delete=False) as pyf:
fileno=pyf.fileno()
print "fileno", fileno
handle = msvcrt.get_osfhandle(fileno)
print "HANDLE", handle
pyf.write("Python\n")
pyf.flush()
cs_handle = IntPtr.Overloads[long](handle)
cs_fs = FileStream(cs_handle, FileAccess.Write)
cs_fs.Write("CLR\n", 0, 4)
cs_fs.Flush()
print "file should contain a line from Python and a line from CLR: ", pyf.name
来源:https://stackoverflow.com/questions/31530059/how-can-i-open-a-net-filestream-object-from-a-python-file-handle