MemoryMappedFile.CreateNew Método

Definição

Cria um arquivo mapeado em memória na memória do sistema.Creates a memory-mapped file in system memory.

Sobrecargas

CreateNew(String, Int64)

Cria um arquivo mapeado em memória que tem a capacidade especificada na memória do sistema.Creates a memory-mapped file that has the specified capacity in system memory.

CreateNew(String, Int64, MemoryMappedFileAccess)

Cria um arquivo mapeado em memória que tem a capacidade e tipo de acesso especificados na memória do sistema.Creates a memory-mapped file that has the specified capacity and access type in system memory.

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

Cria um arquivo mapeado em memória que tem o nome, a capacidade, o tipo de acesso, as opções de alocação de memória e a capacidade de herança especificados.Creates a memory-mapped file that has the specified name, capacity, access type, memory allocation options and inheritability.

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

Cria um arquivo mapeado em memória que tem a capacidade, o tipo de acesso, a alocação de memória, as permissões de segurança e a herdabilidade especificadas na memória do sistema.Creates a memory-mapped file that has the specified capacity, access type, memory allocation, security permissions, and inheritability in system memory.

CreateNew(String, Int64)

Cria um arquivo mapeado em memória que tem a capacidade especificada na memória do sistema.Creates a memory-mapped file that has the specified capacity in system memory.

public:
 static System::IO::MemoryMappedFiles::MemoryMappedFile ^ CreateNew(System::String ^ mapName, long capacity);
public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateNew (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

Parâmetros

mapName
String

Um nome a ser atribuído ao arquivo mapeado em memória, ou null para um MemoryMappedFile que você não pretende compartilhar entre processos.A name to assign to the memory-mapped file, or null for a MemoryMappedFile that you do not intend to share across processes.

capacity
Int64

O tamanho máximo, em bytes, a ser alocado para o arquivo mapeado em memória.The maximum size, in bytes, to allocate to the memory-mapped file.

Retornos

MemoryMappedFile

Um arquivo mapeado em memória que tem o nome e a capacidade especificados.A memory-mapped file that has the specified name and capacity.

Exceções

mapName é uma cadeia de caracteres vazia.mapName is an empty string.

capacity é menor que ou igual a zero.capacity is less than or equal to zero.

Somente .NET 5+ e .NET Core: Há suporte para chamadas ao método CreateNew com um arquivo mapeado na memória nomeado (ou seja, um mapName diferente de nulo) apenas em sistemas operacionais Windows..NET 5+ and .NET Core only: Calls to the CreateNew method with a named memory mapped file (that is, a non-null mapName) are supported on Windows operating systems only.

Exemplos

O exemplo a seguir é composto de três processos separados (aplicativos de console) que gravam Boolean valores em um arquivo mapeado para a memória.The following example is composed of three separate processes (console applications) that write Boolean values to a memory-mapped file. Ocorre a seguinte sequência de ações:The following sequence of actions occur:

  1. O processo A cria o arquivo de memória mapeada e grava um valor nele.Process A creates the memory-mapped file and writes a value to it.

  2. O processo B abre o arquivo mapeado para a memória e grava um valor nele.Process B opens the memory-mapped file and writes a value to it.

  3. O processo C abre o arquivo de memória mapeada e grava um valor nele.Process C opens the memory-mapped file and writes a value to it.

  4. Processar uma leitura e exibir os valores do arquivo mapeado por memória.Process A reads and displays the values from the memory-mapped file.

  5. Depois que o processo A for concluído com o arquivo mapeado para memória, o arquivo será imediatamente recuperado pela coleta de lixo.After Process A is finished with the memory-mapped file, the file is immediately reclaimed by garbage collection.

Para executar este exemplo, faça o seguinte:To run this example, do the following:

  1. Compile os aplicativos e abra três janelas de comando.Compile the applications and open three Command windows.

  2. Na primeira janela Comando, execute o processo A.In the first Command window, run Process A.

  3. Na segunda janela Comando, execute o processo B.In the second Command window, run Process B.

  4. Retorne para processar A e pressione ENTER.Return to Process A and press ENTER.

  5. No terceiro janela Comando, execute o processo C.In the third Command window, run Process C.

  6. Retorne para processar A e pressione ENTER.Return to Process A and press ENTER.

A saída do processo A é a seguinte:The output of Process A is as follows:

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  

Processo AProcess 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

Processo BProcess 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

Processo CProcess 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

Comentários

Use este método para criar um arquivo de memória mapeada que não é persistente (ou seja, não associado a um arquivo no disco), que você pode usar para compartilhar dados entre processos.Use this method to create a memory-mapped file that is not persisted (that is, not associated with a file on disk), which you can use to share data between processes.

Aplica-se a

CreateNew(String, Int64, MemoryMappedFileAccess)

Cria um arquivo mapeado em memória que tem a capacidade e tipo de acesso especificados na memória do sistema.Creates a memory-mapped file that has the specified capacity and access type in system memory.

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);
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

Parâmetros

mapName
String

Um nome a ser atribuído ao arquivo mapeado em memória, ou null para um MemoryMappedFile que você não pretende compartilhar entre processos.A name to assign to the memory-mapped file, or null for a MemoryMappedFile that you do not intend to share across processes.

capacity
Int64

O tamanho máximo, em bytes, a ser alocado para o arquivo mapeado em memória.The maximum size, in bytes, to allocate to the memory-mapped file.

access
MemoryMappedFileAccess

Um dos valores de enumeração que especifica o tipo de acesso permitido para o arquivo mapeado na memória.One of the enumeration values that specifies the type of access allowed to the memory-mapped file. O padrão é ReadWrite.The default is ReadWrite.

Retornos

MemoryMappedFile

Um arquivo mapeado na memória que tem as características especificadas.A memory-mapped file that has the specified characteristics.

Exceções

mapName é uma cadeia de caracteres vazia.mapName is an empty string.

- ou --or- access é definido como somente gravação com o valor de enumeração Write.access is set to write-only with the Write enumeration value.

capacity é menor que ou igual a zero.capacity is less than or equal to zero.

- ou --or- access não é um valor de enumeração MemoryMappedFileAccess válido.access is not a valid MemoryMappedFileAccess enumeration value.

Somente .NET 5+ e .NET Core: Há suporte para chamadas ao método CreateNew com um arquivo mapeado na memória nomeado (ou seja, um mapName diferente de nulo) apenas em sistemas operacionais Windows..NET 5+ and .NET Core only: Calls to the CreateNew method with a named memory mapped file (that is, a non-null mapName) are supported on Windows operating systems only.

Comentários

Use este método para criar um arquivo de memória mapeada que não é persistente (ou seja, não associado a um arquivo no disco), que você pode usar para compartilhar dados entre processos.Use this method to create a memory-mapped file that is not persisted (that is, not associated with a file on disk), which you can use to share data between processes.

Aplica-se a

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

Cria um arquivo mapeado em memória que tem o nome, a capacidade, o tipo de acesso, as opções de alocação de memória e a capacidade de herança especificados.Creates a memory-mapped file that has the specified name, capacity, access type, memory allocation options and inheritability.

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);
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

Parâmetros

mapName
String

Um nome a ser atribuído ao arquivo mapeado em memória, ou null para um MemoryMappedFile que você não pretende compartilhar entre processos.A name to assign to the memory-mapped file, or null for a MemoryMappedFile that you do not intend to share across processes.

capacity
Int64

O tamanho máximo, em bytes, a ser alocado para o arquivo mapeado em memória.The maximum size, in bytes, to allocate to the memory-mapped file.

access
MemoryMappedFileAccess

Um dos valores de enumeração que especifica o tipo de acesso permitido para o arquivo mapeado na memória.One of the enumeration values that specifies the type of access allowed to the memory-mapped file. O padrão é ReadWrite.The default is ReadWrite.

options
MemoryMappedFileOptions

Uma combinação bit a bit dos valores de enumeração que especifica opções de alocação de memória para o arquivo mapeado na memória.A bitwise combination of enumeration values that specifies memory allocation options for the memory-mapped file.

inheritability
HandleInheritability

Um valor que especifica se um identificador para o arquivo de mapeamento de memória pode ser herdado por um processo filho.A value that specifies whether a handle to the memory-mapped file can be inherited by a child process. O padrão é None.The default is None.

Retornos

MemoryMappedFile

Um arquivo mapeado na memória que tem as características especificadas.A memory-mapped file that has the specified characteristics.

Exceções

mapName é uma cadeia de caracteres vazia.mapName is an empty string.

- ou --or- access é definido como somente gravação com o valor de enumeração Write.access is set to write-only with the Write enumeration value.

capacity é menor que ou igual a zero.capacity is less than or equal to zero.

- ou --or- access não é um valor de enumeração MemoryMappedFileAccess válido.access is not a valid MemoryMappedFileAccess enumeration value.

- ou --or- inheritability não é um valor HandleInheritability válido.inheritability is not a valid HandleInheritability value.

Somente .NET 5+ e .NET Core: Há suporte para chamadas ao método CreateNew com um arquivo mapeado na memória nomeado (ou seja, um mapName diferente de nulo) apenas em sistemas operacionais Windows..NET 5+ and .NET Core only: Calls to the CreateNew method with a named memory mapped file (that is, a non-null mapName) are supported on Windows operating systems only.

Aplica-se a

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

Cria um arquivo mapeado em memória que tem a capacidade, o tipo de acesso, a alocação de memória, as permissões de segurança e a herdabilidade especificadas na memória do sistema.Creates a memory-mapped file that has the specified capacity, access type, memory allocation, security permissions, and inheritability in system memory.

public:
 static System::IO::MemoryMappedFiles::MemoryMappedFile ^ CreateNew(System::String ^ mapName, long capacity, System::IO::MemoryMappedFiles::MemoryMappedFileAccess access, System::IO::MemoryMappedFiles::MemoryMappedFileOptions options, System::IO::MemoryMappedFiles::MemoryMappedFileSecurity ^ memoryMappedFileSecurity, System::IO::HandleInheritability inheritability);
[System.Security.SecurityCritical]
public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateNew (string mapName, long capacity, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access, System.IO.MemoryMappedFiles.MemoryMappedFileOptions options, System.IO.MemoryMappedFiles.MemoryMappedFileSecurity memoryMappedFileSecurity, 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.MemoryMappedFiles.MemoryMappedFileSecurity memoryMappedFileSecurity, System.IO.HandleInheritability inheritability);
[<System.Security.SecurityCritical>]
static member CreateNew : string * int64 * System.IO.MemoryMappedFiles.MemoryMappedFileAccess * System.IO.MemoryMappedFiles.MemoryMappedFileOptions * System.IO.MemoryMappedFiles.MemoryMappedFileSecurity * System.IO.HandleInheritability -> System.IO.MemoryMappedFiles.MemoryMappedFile
static member CreateNew : string * int64 * System.IO.MemoryMappedFiles.MemoryMappedFileAccess * System.IO.MemoryMappedFiles.MemoryMappedFileOptions * System.IO.MemoryMappedFiles.MemoryMappedFileSecurity * System.IO.HandleInheritability -> System.IO.MemoryMappedFiles.MemoryMappedFile
Public Shared Function CreateNew (mapName As String, capacity As Long, access As MemoryMappedFileAccess, options As MemoryMappedFileOptions, memoryMappedFileSecurity As MemoryMappedFileSecurity, inheritability As HandleInheritability) As MemoryMappedFile

Parâmetros

mapName
String

Um nome a ser atribuído ao arquivo mapeado em memória, ou null para um MemoryMappedFile que você não pretende compartilhar entre processos.A name to assign to the memory-mapped file, or null for a MemoryMappedFile that you do not intend to share across processes.

capacity
Int64

O tamanho máximo, em bytes, a ser alocado para o arquivo mapeado em memória.The maximum size, in bytes, to allocate to the memory-mapped file.

access
MemoryMappedFileAccess

Um dos valores de enumeração que especifica o tipo de acesso permitido para o arquivo mapeado na memória.One of the enumeration values that specifies the type of access allowed to the memory-mapped file. O padrão é ReadWrite.The default is ReadWrite.

options
MemoryMappedFileOptions

Uma combinação bit a bit dos valores de enumeração que especifica opções de alocação de memória para o arquivo mapeado na memória.A bitwise combination of enumeration values that specifies memory allocation options for the memory-mapped file.

memoryMappedFileSecurity
MemoryMappedFileSecurity

As permissões que podem ser concedidas para acesso a arquivos e operações em arquivos mapeados em memória.The permissions that can be granted for file access and operations on memory-mapped files.

Esse parâmetro pode ser null.This parameter can be null.

inheritability
HandleInheritability

Um dos valores de enumeração que especifica se um identificador para o arquivo mapeado em memória pode ser herdado por um processo filho.One of the enumeration values that specifies whether a handle to the memory-mapped file can be inherited by a child process. O padrão é None.The default is None.

Retornos

MemoryMappedFile

Um arquivo mapeado na memória que tem as características especificadas.A memory-mapped file that has the specified characteristics.

Atributos

Exceções

mapName é uma cadeia de caracteres vazia.mapName is an empty string.

- ou --or- access é definido como somente gravação com o valor de enumeração Write.access is set to write-only with the Write enumeration value.

capacity é menor que ou igual a zero.capacity is less than or equal to zero.

- ou --or- access não é um valor de enumeração MemoryMappedFileAccess válido.access is not a valid MemoryMappedFileAccess enumeration value.

- ou --or- inheritability não é um valor de enumeração HandleInheritability válido.inheritability is not a valid HandleInheritability enumeration value.

Comentários

Use este método para criar um arquivo de memória mapeada que não é persistente (ou seja, não associado a um arquivo no disco), que você pode usar para compartilhar dados entre processos.Use this method to create a memory-mapped file that is not persisted (that is, not associated with a file on disk), which you can use to share data between processes.

Aplica-se a