多进程C#优化内存使用技巧

在C#中，优化多进程应用程序的内存使用可以通过以下方法实现：

1. 使用Process类创建子进程：使用System.Diagnostics.Process类创建子进程，而不是直接在主进程中执行任务。这样可以确保每个子进程都有自己的内存空间，从而降低内存使用。

using System.Diagnostics;

ProcessStartInfo startInfo = new ProcessStartInfo("childProcess.exe");
startInfo.CreateNoWindow = true;
startInfo.UseShellExecute = false;

Process childProcess = new Process();
childProcess.StartInfo = startInfo;
childProcess.Start();

2. 限制子进程的内存使用：可以为子进程设置最大内存使用限制。这可以通过ProcessStartInfo类的MaxWorkingSet属性实现。

startInfo.MaxWorkingSet = (IntPtr)(1024 * 1024 * 50); // 限制子进程内存使用为50MB

3. 使用JobObject限制内存使用：JobObject是一种Windows API，可以用来限制一组进程的资源使用（如内存、CPU等）。通过将子进程添加到JobObject中，可以限制它们的内存使用。

using System.Runtime.InteropServices;

[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr CreateJobObject(IntPtr lpJobAttributes, string lpName);

[DllImport("kernel32.dll", SetLastError = true)]
static extern bool AssignProcessToJobObject(IntPtr hJob, IntPtr hProcess);

[DllImport("kernel32.dll", SetLastError = true)]
static extern bool SetInformationJobObject(IntPtr hJob, JobObjectInfoType infoType, IntPtr lpJobObjectInfo, uint cbJobObjectInfoLength);

public enum JobObjectInfoType
{
    AssociateCompletionPortInformation = 7,
    BasicLimitInformation = 2,
    BasicUIRestrictions = 4,
    EndOfJobTimeInformation = 6,
    ExtendedLimitInformation = 9,
    SecurityLimitInformation = 5,
    GroupInformation = 11
}

[StructLayout(LayoutKind.Sequential)]
public struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
{
    public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
    public IO_COUNTERS IoInfo;
    public UIntPtr ProcessMemoryLimit;
    public UIntPtr JobMemoryLimit;
    public UIntPtr PeakProcessMemoryUsed;
    public UIntPtr PeakJobMemoryUsed;
}

[StructLayout(LayoutKind.Sequential)]
public struct JOBOBJECT_BASIC_LIMIT_INFORMATION
{
    public long PerProcessUserTimeLimit;
    public long PerJobUserTimeLimit;
    public uint LimitFlags;
    public UIntPtr MinimumWorkingSetSize;
    public UIntPtr MaximumWorkingSetSize;
    public uint ActiveProcessLimit;
    public UIntPtr Affinity;
    public uint PriorityClass;
    public uint SchedulingClass;
}

// 创建JobObject并限制内存使用
IntPtr jobHandle = CreateJobObject(IntPtr.Zero, null);
JOBOBJECT_EXTENDED_LIMIT_INFORMATION extendedInfo = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
extendedInfo.BasicLimitInformation.LimitFlags = 0x00000100; // JOB_OBJECT_LIMIT_PROCESS_MEMORY
extendedInfo.ProcessMemoryLimit = (UIntPtr)(1024 * 1024 * 50); // 限制子进程内存使用为50MB

IntPtr extendedInfoPtr = Marshal.AllocHGlobal(Marshal.SizeOf(extendedInfo));
Marshal.StructureToPtr(extendedInfo, extendedInfoPtr, false);

SetInformationJobObject(jobHandle, JobObjectInfoType.ExtendedLimitInformation, extendedInfoPtr, (uint)Marshal.SizeOf(extendedInfo));

// 将子进程添加到JobObject
AssignProcessToJobObject(jobHandle, childProcess.Handle);

4. 释放不再使用的资源：在子进程完成任务后，确保释放不再使用的资源，如文件句柄、网络连接等。这可以通过调用Dispose()方法或使用using语句来实现。

5. 使用GC.Collect()和GC.WaitForPendingFinalizers()回收内存：在子进程完成任务后，调用这两个方法来强制执行垃圾回收，从而回收不再使用的内存。

GC.Collect();
GC.WaitForPendingFinalizers();

通过以上方法，可以有效地优化C#多进程应用程序的内存使用。