MemoryMappedFile.CreateNew 方法

定义

命名空间:

System.IO.MemoryMappedFiles

程序集:

System.IO.MemoryMappedFiles.dll

在系统内存中创建一个内存映射文件。

重载

CreateNew(String, Int64)	在系统内存中创建一个具有指定容量的内存映射文件。
CreateNew(String, Int64, MemoryMappedFileAccess)	在系统内存中创建一个具有指定容量和访问类型的内存映射文件。
CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, HandleInheritability)	创建一个具有指定名称、容量、访问类型、内存分配选项和继承性的内存映射文件。

CreateNew(String, Int64)

Source:

MemoryMappedFile.cs

在系统内存中创建一个具有指定容量的内存映射文件。

public:
 static System::IO::MemoryMappedFiles::MemoryMappedFile ^ CreateNew(System::String ^ mapName, long capacity);

public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateNew (string? mapName, long capacity);

static member CreateNew : string * int64 -> System.IO.MemoryMappedFiles.MemoryMappedFile

Public Shared Function CreateNew (mapName As String, capacity As Long) As MemoryMappedFile

参数

mapName

String

要分配给内存映射文件的名称，或用于你不打算在进程中共享的 MemoryMappedFile 的 null。

capacity

Int64

要分配给内存映射文件的最大大小（以字节为单位）。

返回

MemoryMappedFile

具有指定名称和容量的内存映射文件。

例外

ArgumentException

mapName 是一个空字符串。

ArgumentOutOfRangeException

capacity 小于或等于零。

PlatformNotSupportedException

仅限 .NET Core 和 .NET 5+： CreateNew 使用命名内存映射文件 (调用方法，即，仅在 Windows 操作系统上支持非 null mapName) 。

示例

以下示例由三个单独的进程组成， (控制台应用程序) 将值写入 Boolean 内存映射文件。 各操作按下面的顺序发生：

1. 进程 A 创建内存映射文件，并向其写入值。

2. 进程 B 打开内存映射文件，并向其写入值。

3. 进程 C 打开内存映射文件，并向其写入值。

4. 进程 A 读取并显示内存映射文件中的值。

5. 使用内存映射文件完成进程 A 后，垃圾回收会立即回收该文件。

若要运行此示例，请按照以下步骤操作：

1. 编译应用程序并打开三个命令窗口。

2. 在第一个命令窗口中，运行进程 A。

3. 在“第二个命令”窗口中，运行进程 B。

4. 返回到“处理 A”，然后按 Enter。

5. 在第三个命令窗口中，运行进程 C。

6. 返回到“处理 A”，然后按 Enter。

进程 A 的输出如下所示：

Start Process B and press ENTER to continue.
Start Process C and press ENTER to continue.
Process A says: True
Process B says: False
Process C says: True

Process A

using System;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Threading;

class Program
{
    // Process A:
    static void Main(string[] args)
    {
        using (MemoryMappedFile mmf = MemoryMappedFile.CreateNew("testmap", 10000))
        {
            bool mutexCreated;
            Mutex mutex = new Mutex(true, "testmapmutex", out mutexCreated);
            using (MemoryMappedViewStream stream = mmf.CreateViewStream())
            {
                BinaryWriter writer = new BinaryWriter(stream);
                writer.Write(1);
            }
            mutex.ReleaseMutex();

            Console.WriteLine("Start Process B and press ENTER to continue.");
            Console.ReadLine();

            Console.WriteLine("Start Process C and press ENTER to continue.");
            Console.ReadLine();

            mutex.WaitOne();
            using (MemoryMappedViewStream stream = mmf.CreateViewStream())
            {
                BinaryReader reader = new BinaryReader(stream);
                Console.WriteLine("Process A says: {0}", reader.ReadBoolean());
                Console.WriteLine("Process B says: {0}", reader.ReadBoolean());
                Console.WriteLine("Process C says: {0}", reader.ReadBoolean());
            }
            mutex.ReleaseMutex();
        }
    }
}

Imports System.IO
Imports System.IO.MemoryMappedFiles
Imports System.Threading

Module Module1

    ' Process A:
    Sub Main()
        Using mmf As MemoryMappedFile = MemoryMappedFile.CreateNew("testmap", 10000)
            Dim mutexCreated As Boolean
            Dim mTex As Mutex = New Mutex(True, "testmapmutex", mutexCreated)
            Using Stream As MemoryMappedViewStream = mmf.CreateViewStream()
                Dim writer As BinaryWriter = New BinaryWriter(Stream)
                writer.Write(1)
            End Using
            mTex.ReleaseMutex()
            Console.WriteLine("Start Process B and press ENTER to continue.")
            Console.ReadLine()

            Console.WriteLine("Start Process C and press ENTER to continue.")
            Console.ReadLine()

            mTex.WaitOne()
            Using Stream As MemoryMappedViewStream = mmf.CreateViewStream()
                Dim reader As BinaryReader = New BinaryReader(Stream)
                Console.WriteLine("Process A says: {0}", reader.ReadBoolean())
                Console.WriteLine("Process B says: {0}", reader.ReadBoolean())
                Console.WriteLine("Process C says: {0}", reader.ReadBoolean())
            End Using
            mTex.ReleaseMutex()

        End Using

    End Sub

End Module

Process B

using System;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Threading;

class Program
{
    // Process B:
    static void Main(string[] args)
    {
        try
        {
            using (MemoryMappedFile mmf = MemoryMappedFile.OpenExisting("testmap"))
            {

                Mutex mutex = Mutex.OpenExisting("testmapmutex");
                mutex.WaitOne();

                using (MemoryMappedViewStream stream = mmf.CreateViewStream(1, 0))
                {
                    BinaryWriter writer = new BinaryWriter(stream);
                    writer.Write(0);
                }
                mutex.ReleaseMutex();
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("Memory-mapped file does not exist. Run Process A first.");
        }
    }
}

Imports System.IO
Imports System.IO.MemoryMappedFiles
Imports System.Threading

Module Module1
    ' Process B:
    Sub Main()
        Try
            Using mmf As MemoryMappedFile = MemoryMappedFile.OpenExisting("testmap")
                Dim mTex As Mutex = Mutex.OpenExisting("testmapmutex")
                mTex.WaitOne()
                Using Stream As MemoryMappedViewStream = mmf.CreateViewStream(1, 0)
                    Dim writer As BinaryWriter = New BinaryWriter(Stream)
                    writer.Write(0)
                End Using
                mTex.ReleaseMutex()
            End Using
        Catch noFile As FileNotFoundException
            Console.WriteLine("Memory-mapped file does not exist. Run Process A first." & vbCrLf & noFile.Message)
        End Try

    End Sub

End Module

Process C

using System;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Threading;

class Program
{
    // Process C:
    static void Main(string[] args)
    {
        try
        {
            using (MemoryMappedFile mmf = MemoryMappedFile.OpenExisting("testmap"))
            {

                Mutex mutex = Mutex.OpenExisting("testmapmutex");
                mutex.WaitOne();

                using (MemoryMappedViewStream stream = mmf.CreateViewStream(2, 0))
                {
                    BinaryWriter writer = new BinaryWriter(stream);
                    writer.Write(1);
                }
                mutex.ReleaseMutex();
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("Memory-mapped file does not exist. Run Process A first, then B.");
        }
    }
}

Imports System.IO
Imports System.IO.MemoryMappedFiles
Imports System.Threading

Module Module1
    ' Process C:
    Sub Main()
        Try
            Using mmf As MemoryMappedFile = MemoryMappedFile.OpenExisting("testmap")
                Dim mTex As Mutex = Mutex.OpenExisting("testmapmutex")
                mTex.WaitOne()
                Using Stream As MemoryMappedViewStream = mmf.CreateViewStream(2, 0)
                    Dim writer As BinaryWriter = New BinaryWriter(Stream)
                    writer.Write(1)
                End Using
                mTex.ReleaseMutex()
            End Using
        Catch noFile As FileNotFoundException
            Console.WriteLine("Memory-mapped file does not exist. Run Process A first, then B." & vbCrLf & noFile.Message)
        End Try

    End Sub

End Module

注解

使用此方法创建一个内存映射文件，该文件不是持久化 (，即不与磁盘) 上的文件关联，可用于在进程之间共享数据。

另请参阅

• 内存映射文件

CreateNew(String, Int64, MemoryMappedFileAccess)

Source:

MemoryMappedFile.cs

在系统内存中创建一个具有指定容量和访问类型的内存映射文件。

public:
 static System::IO::MemoryMappedFiles::MemoryMappedFile ^ CreateNew(System::String ^ mapName, long capacity, System::IO::MemoryMappedFiles::MemoryMappedFileAccess access);

public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateNew (string? mapName, long capacity, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access);

static member CreateNew : string * int64 * System.IO.MemoryMappedFiles.MemoryMappedFileAccess -> System.IO.MemoryMappedFiles.MemoryMappedFile

Public Shared Function CreateNew (mapName As String, capacity As Long, access As MemoryMappedFileAccess) As MemoryMappedFile

参数

mapName

String

要分配给内存映射文件的名称，或用于你不打算在进程中共享的 MemoryMappedFile 的 null。

capacity

Int64

要分配给内存映射文件的最大大小（以字节为单位）。

access

MemoryMappedFileAccess

指定内存映射文件允许的访问类型的枚举值之一。 默认值为 ReadWrite。

返回

MemoryMappedFile

具有指定特征的内存映射文件。

例外

ArgumentException

mapName 是一个空字符串。

- 或 -

通过 Write 枚举值将 access 设置为只写。

ArgumentOutOfRangeException

capacity 小于或等于零。

- 或 -

access 不是有效的 MemoryMappedFileAccess 枚举值。

PlatformNotSupportedException

仅限 .NET Core 和 .NET 5+： CreateNew 使用命名内存映射文件 (调用方法，即，仅在 Windows 操作系统上支持非 null mapName) 。

注解

使用此方法创建一个内存映射文件，该文件不是持久化 (，即不与磁盘) 上的文件关联，可用于在进程之间共享数据。

另请参阅

• 内存映射文件

CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, HandleInheritability)

Source:

MemoryMappedFile.cs

创建一个具有指定名称、容量、访问类型、内存分配选项和继承性的内存映射文件。

public:
 static System::IO::MemoryMappedFiles::MemoryMappedFile ^ CreateNew(System::String ^ mapName, long capacity, System::IO::MemoryMappedFiles::MemoryMappedFileAccess access, System::IO::MemoryMappedFiles::MemoryMappedFileOptions options, System::IO::HandleInheritability inheritability);

public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateNew (string? mapName, long capacity, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access, System.IO.MemoryMappedFiles.MemoryMappedFileOptions options, System.IO.HandleInheritability inheritability);

static member CreateNew : string * int64 * System.IO.MemoryMappedFiles.MemoryMappedFileAccess * System.IO.MemoryMappedFiles.MemoryMappedFileOptions * System.IO.HandleInheritability -> System.IO.MemoryMappedFiles.MemoryMappedFile

Public Shared Function CreateNew (mapName As String, capacity As Long, access As MemoryMappedFileAccess, options As MemoryMappedFileOptions, inheritability As HandleInheritability) As MemoryMappedFile

参数

mapName

String

要分配给内存映射文件的名称，或用于你不打算在进程中共享的 MemoryMappedFile 的 null。

capacity

Int64

要分配给内存映射文件的最大大小（以字节为单位）。

access

MemoryMappedFileAccess

指定内存映射文件允许的访问类型的枚举值之一。 默认值为 ReadWrite。

options

MemoryMappedFileOptions

枚举值的按位组合，用于为内存映射文件指定内存分配选项。

inheritability

HandleInheritability

一个值，该值指定内存映射文件的句柄能否由子进程继承。 默认值为 None。

返回

MemoryMappedFile

具有指定特征的内存映射文件。

例外

ArgumentException

mapName 是一个空字符串。

- 或 -

通过 Write 枚举值将 access 设置为只写。

ArgumentOutOfRangeException

capacity 小于或等于零。

- 或 -

access 不是有效的 MemoryMappedFileAccess 枚举值。

- 或 -

inheritability 不是有效的 HandleInheritability 值。

PlatformNotSupportedException

仅限 .NET Core 和 .NET 5+： CreateNew 使用命名内存映射文件 (调用方法，即，仅在 Windows 操作系统上支持非 null mapName) 。