MemoryMappedFile.CreateNew Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System.IO.MemoryMappedFiles
Assembly:
System.IO.MemoryMappedFiles.dll
Assembly:
System.Core.dll
Assembly:
netstandard.dll

Crea un file mappato alla memoria nella memoria di sistema.

Overload

CreateNew(String, Int64)

Crea un file mappato alla memoria con la capacità specificata nella memoria di sistema.
CreateNew(String, Int64, MemoryMappedFileAccess)

Crea un file mappato alla memoria con la capacità e il tipo di accesso specificati nella memoria di sistema.
CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, HandleInheritability)

Crea un file mappato alla memoria con il nome, la capacità, il tipo di accesso, le opzioni di allocazione di memoria e l'ereditabilità specificati.
CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, MemoryMappedFileSecurity, HandleInheritability)

Crea un file mappato alla memoria con la capacità, il tipo di accesso, l'allocazione di memoria, le autorizzazioni di sicurezza e l'ereditabilità specificati nella memoria di sistema.

CreateNew(String, Int64)

Source:
MemoryMappedFile.cs
Source:
MemoryMappedFile.cs
Source:
MemoryMappedFile.cs

Crea un file mappato alla memoria con la capacità specificata nella memoria di 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

Parametri

mapName
String

Nome da assegnare al file di cui è stato eseguito il mapping alla memoria, oppure null per un elemento MemoryMappedFile che non si vuole condividere tra processi.

capacity
Int64

Dimensioni massime, in byte, da allocare per il file mappato alla memoria.

Restituisce

MemoryMappedFile

File mappato alla memoria con il nome e la capacità specificati.

Eccezioni

ArgumentException

Il parametro mapName è una stringa vuota.

ArgumentOutOfRangeException

capacity è minore o uguale a zero.

PlatformNotSupportedException

Solo .NET Core e .NET 5+ : le chiamate al CreateNew metodo con un file mappato a memoria denominata ( ovvero un non null mapName) sono supportate solo nei sistemi operativi Windows.

Esempio

L'esempio seguente è costituito da tre processi separati (applicazioni console) che scrivono Boolean valori in un file mappato alla memoria. Si verifica la sequenza di azioni seguente:

  1. Process A crea il file mappato alla memoria e scrive un valore in esso.

  2. Il processo B apre il file mappato alla memoria e scrive un valore.

  3. Il processo C apre il file mappato alla memoria e scrive un valore.

  4. Elaborare A legge e visualizza i valori del file mappato alla memoria.

  5. Al termine del processo A con il file mappato alla memoria, il file viene immediatamente recuperato da Garbage Collection.

Per eseguire questo esempio, seguire questa procedura:

  1. Compilare le applicazioni e aprire tre finestre comando.

  2. Nella prima finestra comando eseguire Process A.

  3. Nella seconda finestra comando eseguire Process B.

  4. Tornare a Elaborare A e premere INVIO.

  5. Nella terza finestra Comando eseguire Process C.

  6. Tornare a Elaborare A e premere INVIO.

L'output di Process A è il seguente:

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

Commenti

Usare questo metodo per creare un file mappato alla memoria che non è persistente, ovvero non associato a un file su disco, che è possibile usare per condividere i dati tra processi.

Vedi anche

Si applica a

CreateNew(String, Int64, MemoryMappedFileAccess)

Source:
MemoryMappedFile.cs
Source:
MemoryMappedFile.cs
Source:
MemoryMappedFile.cs

Crea un file mappato alla memoria con la capacità e il tipo di accesso specificati nella memoria di 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

Parametri

mapName
String

Nome da assegnare al file di cui è stato eseguito il mapping alla memoria, oppure null per un elemento MemoryMappedFile che non si vuole condividere tra processi.

capacity
Int64

Dimensioni massime, in byte, da allocare per il file mappato alla memoria.

access
MemoryMappedFileAccess

Uno dei valori di enumerazione che specifica il tipo di accesso consentito al file mappato alla memoria. Il valore predefinito è ReadWrite.

Restituisce

MemoryMappedFile

File mappato alla memoria con le caratteristiche specificate.

Eccezioni

ArgumentException

Il parametro mapName è una stringa vuota.

-oppure-

access viene impostato su sola scrittura con il valore di enumerazione Write.

ArgumentOutOfRangeException

capacity è minore o uguale a zero.

-oppure-

access non è un valore di enumerazione MemoryMappedFileAccess valido.

PlatformNotSupportedException

Solo .NET Core e .NET 5+ : le chiamate al CreateNew metodo con un file mappato a memoria denominata ( ovvero un non null mapName) sono supportate solo nei sistemi operativi Windows.

Commenti

Usare questo metodo per creare un file mappato alla memoria che non è persistente, ovvero non associato a un file su disco, che è possibile usare per condividere i dati tra processi.

Vedi anche

Si applica a

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

Source:
MemoryMappedFile.cs
Source:
MemoryMappedFile.cs
Source:
MemoryMappedFile.cs

Crea un file mappato alla memoria con il nome, la capacità, il tipo di accesso, le opzioni di allocazione di memoria e l'ereditabilità specificati.

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

Parametri

mapName
String

Nome da assegnare al file di cui è stato eseguito il mapping alla memoria, oppure null per un elemento MemoryMappedFile che non si vuole condividere tra processi.

capacity
Int64

Dimensioni massime, in byte, da allocare per il file mappato alla memoria.

access
MemoryMappedFileAccess

Uno dei valori di enumerazione che specifica il tipo di accesso consentito al file mappato alla memoria. Il valore predefinito è ReadWrite.

options
MemoryMappedFileOptions

Combinazione bit per bit di valori di enumerazione che specifica opzioni di allocazione della memoria per il file mappato alla memoria.

inheritability
HandleInheritability

Valore che specifica se un handle al file mappato alla memoria può essere ereditato da un processo figlio. Il valore predefinito è None.

Restituisce

MemoryMappedFile

File mappato alla memoria con le caratteristiche specificate.

Eccezioni

ArgumentException

Il parametro mapName è una stringa vuota.

-oppure-

access viene impostato su sola scrittura con il valore di enumerazione Write.

ArgumentOutOfRangeException

capacity è minore o uguale a zero.

-oppure-

access non è un valore di enumerazione MemoryMappedFileAccess valido.

-oppure-

inheritability non è un valore valido di HandleInheritability.

PlatformNotSupportedException

Solo .NET Core e .NET 5+ : le chiamate al CreateNew metodo con un file mappato a memoria denominata ( ovvero un non null mapName) sono supportate solo nei sistemi operativi Windows.

Si applica a

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

Crea un file mappato alla memoria con la capacità, il tipo di accesso, l'allocazione di memoria, le autorizzazioni di sicurezza e l'ereditabilità specificati nella memoria di 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

Parametri

mapName
String

Nome da assegnare al file di cui è stato eseguito il mapping alla memoria, oppure null per un elemento MemoryMappedFile che non si vuole condividere tra processi.

capacity
Int64

Dimensioni massime, in byte, da allocare per il file mappato alla memoria.

access
MemoryMappedFileAccess

Uno dei valori di enumerazione che specifica il tipo di accesso consentito al file mappato alla memoria. Il valore predefinito è ReadWrite.

options
MemoryMappedFileOptions

Combinazione bit per bit di valori di enumerazione che specifica opzioni di allocazione della memoria per il file mappato alla memoria.

memoryMappedFileSecurity
MemoryMappedFileSecurity

Autorizzazioni che è possibile concedere per l'accesso ai file e le operazioni sui file mappati alla memoria.

Questo parametro può essere null.

inheritability
HandleInheritability

Uno dei valori di enumerazione che specifica se un handle al file mappato alla memoria può essere ereditato da un processo figlio. Il valore predefinito è None.

Restituisce

MemoryMappedFile

File mappato alla memoria con le caratteristiche specificate.

Attributi
SecurityCriticalAttribute

Eccezioni

ArgumentException

Il parametro mapName è una stringa vuota.

-oppure-

access viene impostato su sola scrittura con il valore di enumerazione Write.

ArgumentOutOfRangeException

capacity è minore o uguale a zero.

-oppure-

access non è un valore di enumerazione MemoryMappedFileAccess valido.

-oppure-

inheritability non è un valore di enumerazione HandleInheritability valido.

Commenti

Usare questo metodo per creare un file mappato alla memoria che non è persistente, ovvero non associato a un file su disco, che è possibile usare per condividere i dati tra processi.

Vedi anche

Si applica a