MemoryMappedFile.CreateNew Método

Referência

Definição

Namespace:: System.IO.MemoryMappedFiles

Assembly:: System.IO.MemoryMappedFiles.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Cria um arquivo mapeado em memória na memória do sistema.

Sobrecargas

CreateNew(String, Int64)	Cria um arquivo mapeado em memória que tem a capacidade especificada na memória do sistema.
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.
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.
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.

CreateNew(String, Int64)

Origem:: MemoryMappedFile.cs

Origem:: MemoryMappedFile.cs

Origem:: MemoryMappedFile.cs

Cria um arquivo mapeado em memória que tem a capacidade especificada na memória do sistema.

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.

capacity: Int64

O tamanho máximo, em bytes, a ser alocado para o arquivo mapeado em memória.

Retornos

MemoryMappedFile

Um arquivo mapeado em memória que tem o nome e a capacidade especificados.

Exceções

ArgumentException

mapName é uma cadeia de caracteres vazia.

ArgumentOutOfRangeException

capacity é menor que ou igual a zero.

PlatformNotSupportedException

Somente .NET Core e .NET 5+: as chamadas para o CreateNew método com um arquivo mapeado de memória nomeada (ou seja, um não nulo mapName) têm suporte apenas em sistemas operacionais Windows.

Exemplos

O exemplo a seguir é composto por três processos separados (aplicativos de console) que gravam Boolean valores em um arquivo mapeado em memória. Ocorre a seguinte sequência de ações:

O processo A cria o arquivo mapeado na memória e grava um valor nele.
O processo B abre o arquivo mapeado na memória e grava um valor nele.
O processo C abre o arquivo mapeado na memória e grava um valor nele.
O Processo A lê e exibe os valores do arquivo mapeado na memória.
Depois que o Processo A for concluído com o arquivo mapeado na memória, o arquivo será recuperado imediatamente pela coleta de lixo.

Para executar este exemplo, faça o seguinte:

Compile os aplicativos e abra três janelas de comando.
Na primeira janela Comando, execute o Processo A.
Na segunda janela Comando, execute o Processo B.
Retorne ao Processo A e pressione ENTER.
Na terceira janela Comando, execute o Processo C.
Retorne ao Processo A e pressione ENTER.

A saída do Processo A é a seguinte:

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 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 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 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 esse método para criar um arquivo mapeado na memória que não é persistente (ou seja, não associado a um arquivo em disco), que pode ser usado para compartilhar dados entre processos.

Confira também

Arquivos mapeados em memória

Aplica-se a

CreateNew(String, Int64, MemoryMappedFileAccess)

Origem:: MemoryMappedFile.cs

Origem:: MemoryMappedFile.cs

Origem:: MemoryMappedFile.cs

Cria um arquivo mapeado em memória que tem a capacidade e tipo de acesso especificados na memória do sistema.

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.

capacity: Int64

O tamanho máximo, em bytes, a ser alocado para o arquivo mapeado em memória.

access: MemoryMappedFileAccess

Um dos valores de enumeração que especifica o tipo de acesso permitido para o arquivo mapeado na memória. O padrão é ReadWrite.

Retornos

MemoryMappedFile

Um arquivo mapeado na memória que tem as características especificadas.

Exceções

ArgumentException

mapName é uma cadeia de caracteres vazia.

- ou -

access é definido como somente gravação com o valor de enumeração Write.

ArgumentOutOfRangeException

capacity é menor que ou igual a zero.

- ou -

access não é um valor de enumeração MemoryMappedFileAccess válido.

PlatformNotSupportedException

Somente .NET Core e .NET 5+: as chamadas para o CreateNew método com um arquivo mapeado de memória nomeada (ou seja, um não nulo mapName) têm suporte apenas em sistemas operacionais Windows.

Comentários

Use esse método para criar um arquivo mapeado na memória que não é persistente (ou seja, não associado a um arquivo em disco), que pode ser usado para compartilhar dados entre processos.

Confira também

Arquivos mapeados em memória

Aplica-se a

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

Origem:: MemoryMappedFile.cs

Origem:: MemoryMappedFile.cs

Origem:: MemoryMappedFile.cs

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.

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.

capacity: Int64

O tamanho máximo, em bytes, a ser alocado para o arquivo mapeado em memória.

access: MemoryMappedFileAccess

Um dos valores de enumeração que especifica o tipo de acesso permitido para o arquivo mapeado na memória. O padrão é 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.

inheritability: HandleInheritability

Um valor que especifica se um identificador para o arquivo de mapeamento de memória pode ser herdado por um processo filho. O padrão é None.

Retornos

MemoryMappedFile

Um arquivo mapeado na memória que tem as características especificadas.

Exceções

ArgumentException

mapName é uma cadeia de caracteres vazia.

- ou -

access é definido como somente gravação com o valor de enumeração Write.

ArgumentOutOfRangeException

capacity é menor que ou igual a zero.

- ou -

access não é um valor de enumeração MemoryMappedFileAccess válido.

- ou -

inheritability não é um valor HandleInheritability válido.

PlatformNotSupportedException

Somente .NET Core e .NET 5+: as chamadas para o CreateNew método com um arquivo mapeado de memória nomeada (ou seja, um não nulo mapName) têm suporte apenas em sistemas operacionais Windows.

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.

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

[<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

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.

capacity: Int64

O tamanho máximo, em bytes, a ser alocado para o arquivo mapeado em memória.

access: MemoryMappedFileAccess

Um dos valores de enumeração que especifica o tipo de acesso permitido para o arquivo mapeado na memória. O padrão é 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.

memoryMappedFileSecurity: MemoryMappedFileSecurity

As permissões que podem ser concedidas para acesso a arquivos e operações em arquivos mapeados em memória.

Esse parâmetro pode ser 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. O padrão é None.

Retornos

MemoryMappedFile

Um arquivo mapeado na memória que tem as características especificadas.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentException

mapName é uma cadeia de caracteres vazia.

- ou -

access é definido como somente gravação com o valor de enumeração Write.

ArgumentOutOfRangeException

capacity é menor que ou igual a zero.

- ou -

access não é um valor de enumeração MemoryMappedFileAccess válido.

- ou -

inheritability não é um valor de enumeração HandleInheritability válido.

Comentários

Use esse método para criar um arquivo mapeado na memória que não é persistente (ou seja, não associado a um arquivo em disco), que pode ser usado para compartilhar dados entre processos.

Confira também

Arquivos mapeados em memória

Aplica-se a

Feedback

Esta página foi útil?

Partilhar via

MemoryMappedFile.CreateNew Método

Definição

Sobrecargas

CreateNew(String, Int64)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

CreateNew(String, Int64, MemoryMappedFileAccess)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

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

Parâmetros

Retornos

Exceções

Aplica-se a

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

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Feedback