MemoryMappedFile.CreateNew Método

Definición

Espacio de nombres:

System.IO.MemoryMappedFiles

Ensamblado:

System.IO.MemoryMappedFiles.dll

Crea un archivo asignado a la memoria en la memoria del sistema.

Sobrecargas

CreateNew(String, Int64)	Crea un archivo asignado a la memoria con la capacidad especificada en la memoria del sistema.
CreateNew(String, Int64, MemoryMappedFileAccess)	Crea un archivo asignado a la memoria con la capacidad y el tipo de acceso especificados en la memoria del sistema.
CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, HandleInheritability)	Crea un archivo asignado a la memoria que tiene el nombre, la capacidad, el tipo de acceso, las opciones de asignación de memoria y la cualidad de heredable que se especifiquen.

CreateNew(String, Int64)

Source:

MemoryMappedFile.cs

Crea un archivo asignado a la memoria con la capacidad especificada en la memoria del sistema.

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

Parámetros

mapName

String

Nombre para asignar al archivo asignado a la memoria o null para un MemoryMappedFile que no tiene intención de compartir entre procesos.

capacity

Int64

Tamaño máximo, en bytes, que se va a asignar al archivo asignado a la memoria.

Devoluciones

MemoryMappedFile

Archivo asignado a la memoria con el nombre y la capacidad especificados.

Excepciones

ArgumentException

mapName es una cadena vacía.

ArgumentOutOfRangeException

capacity es menor o igual que cero.

PlatformNotSupportedException

Solo .NET Core y .NET 5+: las llamadas al CreateNew método con un archivo asignado a memoria con nombre (es decir, un valor distinto de NULL mapName) solo se admiten en sistemas operativos Windows.

Ejemplos

El ejemplo siguiente se compone de tres procesos independientes (aplicaciones de consola) que escriben Boolean valores en un archivo asignado a memoria. Se produce la siguiente secuencia de acciones:

1. El proceso A crea el archivo asignado a memoria y escribe un valor en él.

2. El proceso B abre el archivo asignado a memoria y escribe un valor en él.

3. El proceso C abre el archivo asignado a memoria y escribe un valor en él.

4. Procesar lecturas y muestra los valores del archivo asignado a memoria.

5. Una vez finalizado el proceso A con el archivo asignado a memoria, la recolección de elementos no utilizados recupera inmediatamente el archivo.

Para ejecutar este ejemplo, haga lo siguiente:

1. Compile las aplicaciones y abra tres ventanas de comandos.

2. En la primera ventana Comando, ejecute Process A.

3. En la segunda ventana Comando, ejecute Proceso B.

4. Vuelva al proceso A y presione ENTRAR.

5. En la tercera ventana Comando, ejecute Proceso C.

6. Vuelva al proceso A y presione ENTRAR.

La salida del proceso A es la siguiente:

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

Comentarios

Use este método para crear un archivo asignado a memoria que no se conserve (es decir, no asociado a un archivo en el disco), que puede usar para compartir datos entre procesos.

Consulte también

• Archivos asignados a memoria

CreateNew(String, Int64, MemoryMappedFileAccess)

Source:

MemoryMappedFile.cs

Crea un archivo asignado a la memoria con la capacidad y el tipo de acceso especificados en la memoria del 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);

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

Nombre para asignar al archivo asignado a la memoria o null para un MemoryMappedFile que no tiene intención de compartir entre procesos.

capacity

Int64

Tamaño máximo, en bytes, que se va a asignar al archivo asignado a la memoria.

access

MemoryMappedFileAccess

Uno de los valores de enumeración que especifica el tipo de acceso permitido para el archivo asignado a la memoria. De manera predeterminada, es ReadWrite.

Devoluciones

MemoryMappedFile

Archivo asignado a la memoria que tiene las características especificadas.

Excepciones

ArgumentException

mapName es una cadena vacía.

o bien

access se establece como de solo escritura con el valor de enumeración Write.

ArgumentOutOfRangeException

capacity es menor o igual que cero.

o bien

access no es un valor de enumeración MemoryMappedFileAccess válido.

PlatformNotSupportedException

Solo .NET Core y .NET 5+: las llamadas al CreateNew método con un archivo asignado a memoria con nombre (es decir, un valor distinto de NULL mapName) solo se admiten en sistemas operativos Windows.

Comentarios

Use este método para crear un archivo asignado a memoria que no se conserve (es decir, no asociado a un archivo en el disco), que puede usar para compartir datos entre procesos.

Consulte también

• Archivos asignados a memoria

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

Source:

MemoryMappedFile.cs

Crea un archivo asignado a la memoria que tiene el nombre, la capacidad, el tipo de acceso, las opciones de asignación de memoria y la cualidad de heredable que se especifiquen.

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

Parámetros

mapName

String

Nombre para asignar al archivo asignado a la memoria o null para un MemoryMappedFile que no tiene intención de compartir entre procesos.

capacity

Int64

Tamaño máximo, en bytes, que se va a asignar al archivo asignado a la memoria.

access

MemoryMappedFileAccess

Uno de los valores de enumeración que especifica el tipo de acceso permitido para el archivo asignado a la memoria. De manera predeterminada, es ReadWrite.

options

MemoryMappedFileOptions

Combinación bit a bit de valores de enumeración que especifica las opciones de asignación de memoria para el archivo asignado a la memoria.

inheritability

HandleInheritability

Valor que especifica si un proceso secundario puede heredar un identificador para el archivo asignado a la memoria. De manera predeterminada, es None.

Devoluciones

MemoryMappedFile

Archivo asignado a la memoria que tiene las características especificadas.

Excepciones

ArgumentException

mapName es una cadena vacía.

o bien

access se establece como de solo escritura con el valor de enumeración Write.

ArgumentOutOfRangeException

capacity es menor o igual que cero.

o bien

access no es un valor de enumeración MemoryMappedFileAccess válido.

o bien

inheritability no es un valor HandleInheritability válido.

PlatformNotSupportedException

Solo .NET Core y .NET 5+: las llamadas al CreateNew método con un archivo asignado a memoria con nombre (es decir, un valor distinto de NULL mapName) solo se admiten en sistemas operativos Windows.