Xamarin iOS DocumentPicker：如何导入大文件？

这个问题我之前也踩过坑！核心原因就是你把整个大文件直接加载到内存里了——iOS对内存管控非常严格，几十上百MB的文件转成byte数组还能撑住，但更大的文件会瞬间占满内存，要么导致应用卡顿，直接被系统后台杀掉。下面给你几个针对性的解决方案：

方案一：直接复制文件URL到Documents目录（推荐） #

既然我们只是要把选中的文件导入到本地，完全没必要用UIDocument加载整个内容。直接利用系统的文件复制API，全程不把文件读进内存，效率最高。

代码示例（在DidPickDocumentsAtUrls中实现） #

public override void DidPickDocumentsAtUrls(NSUrl[] urls)
{
    base.DidPickDocumentsAtUrls(urls);
    
    foreach (var sourceUrl in urls)
    {
        // 必须先获取安全范围文件的访问权限
        if (!sourceUrl.StartAccessingSecurityScopedResource())
        {
            Console.WriteLine("无法获取文件访问权限");
            continue;
        }

        try
        {
            // 获取应用Documents目录的目标URL
            var documentsDir = NSFileManager.DefaultManager.GetUrls(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomain.User)[0];
            var targetUrl = documentsDir.Append(sourceUrl.LastPathComponent, false);

            // 使用NSFileCoordinator处理文件操作，避免跨应用访问冲突
            var fileCoordinator = new NSFileCoordinator();
            NSError coordError = null;
            
            fileCoordinator.CoordinateReading(sourceUrl, NSFileCoordinatorReadingOptions.ForUploading, out coordError, (safeReadUrl) =>
            {
                NSError copyError = null;
                if (NSFileManager.DefaultManager.Copy(safeReadUrl, targetUrl, out copyError))
                {
                    Console.WriteLine($"文件已成功导入到Documents: {targetUrl.Path}");
                }
                else
                {
                    Console.WriteLine($"复制失败: {copyError.LocalizedDescription}");
                }
            });

            if (coordError != null && coordError.Code != 0)
            {
                Console.WriteLine($"文件访问协调失败: {coordError.LocalizedDescription}");
            }
        }
        finally
        {
            // 一定要释放安全访问权限，否则会泄漏资源
            sourceUrl.StopAccessingSecurityScopedResource();
        }
    }
}

方案二：改进UIDocument子类，避免加载全量内容 #

如果你必须用UIDocument的流程（比如需要处理文件版本、权限等），那就要修改子类的实现，不要把整个文件内容存到内存里，而是直接写入本地文件。

改进后的MySubclassedDoc代码 #

public class MySubclassedDoc : UIDocument
{
    private readonly string _targetFilePath;

    // 初始化时传入目标文件路径
    public MySubclassedDoc(NSUrl fileUrl, string targetFilePath) : base(fileUrl)
    {
        _targetFilePath = targetFilePath;
    }

    public override bool LoadFromContents(NSObject contents, string typeName, out NSError outError)
    {
        outError = null;

        if (contents is NSData fileData)
        {
            try
            {
                // 直接将NSData写入目标文件，不转成byte数组驻留内存
                fileData.Save(_targetFilePath, true);
                return true;
            }
            catch (Exception ex)
            {
                outError = new NSError(
                    new NSString("FileWriteError"), 
                    1, 
                    new NSDictionary(NSLocalizedDescriptionKey, ex.Message)
                );
                return false;
            }
        }

        outError = new NSError(
            new NSString("InvalidContent"), 
            2, 
            new NSDictionary(NSLocalizedDescriptionKey, "文件内容无效")
        );
        return false;
    }

    // 如果不需要读取文件内容，这个方法可以返回null（根据你的业务需求调整）
    public override NSObject ContentsForType(string typeName, out NSError outError)
    {
        outError = null;
        return null;
    }
}

调用改进后的UIDocument #

public override void DidPickDocumentsAtUrls(NSUrl[] urls)
{
    base.DidPickDocumentsAtUrls(urls);
    
    foreach (var sourceUrl in urls)
    {
        if (!sourceUrl.StartAccessingSecurityScopedResource())
        {
            Console.WriteLine("无法获取文件访问权限");
            continue;
        }

        try
        {
            var documentsDir = NSFileManager.DefaultManager.GetUrls(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomain.User)[0].Path;
            var targetFilePath = Path.Combine(documentsDir, sourceUrl.LastPathComponent);

            var doc = new MySubclassedDoc(sourceUrl, targetFilePath);
            doc.Open((success) =>
            {
                if (success)
                {
                    Console.WriteLine("文件导入成功");
                    doc.Close((closeSuccess) => {});
                }
                else
                {
                    Console.WriteLine("文件导入失败");
                }
            });
        }
        finally
        {
            sourceUrl.StopAccessingSecurityScopedResource();
        }
    }
}

方案三：超大型文件分块处理（几个GB级别的文件） #

如果要处理的是几个GB的超大型文件，可以用分块读写的方式，每次只加载一小部分内容到内存，进一步降低内存占用。

分块复制代码示例 #

private void CopyLargeFile(NSUrl sourceUrl, string targetFilePath)
{
    NSError openError = null;
    using (var sourceHandle = NSFileHandle.FromUrl(sourceUrl, NSFileHandleReadPermission, out openError))
    {
        if (openError != null)
        {
            Console.WriteLine($"打开源文件失败: {openError.LocalizedDescription}");
            return;
        }

        // 创建目标文件
        if (!NSFileManager.DefaultManager.CreateFile(targetFilePath, null, null))
        {
            Console.WriteLine("创建目标文件失败");
            return;
        }

        using (var targetHandle = NSFileHandle.ForWritingAtPath(targetFilePath))
        {
            if (targetHandle == null)
            {
                Console.WriteLine("打开目标文件失败");
                return;
            }

            const long chunkSize = 1024 * 1024; // 每次读取1MB内容
            NSData chunkData;

            do
            {
                chunkData = sourceHandle.ReadDataOfLength(chunkSize);
                if (chunkData.Length > 0)
                {
                    targetHandle.WriteData(chunkData);
                }
            } while (chunkData.Length == chunkSize);

            // 确保内容写入磁盘
            targetHandle.Synchronize();
        }
    }
}

调用分块复制 #

在DidPickDocumentsAtUrls的安全权限块里直接调用这个方法即可：

CopyLargeFile(sourceUrl, targetFilePath);

关键注意事项 #

1. 安全范围文件权限：从iOS 11开始，通过UIDocumentPicker获取的文件URL必须调用StartAccessingSecurityScopedResource获取权限，操作完成后一定要调用StopAccessingSecurityScopedResource释放，否则会导致资源泄漏。
2. 避免内存加载：所有大文件处理的核心都是不要把整个文件加载到内存，尽量直接操作文件系统或者分块处理。
3. 文件访问协调：使用NSFileCoordinator可以避免文件被其他应用占用时的访问冲突，让操作更稳定。

内容的提问来源于stack exchange，提问作者fritz