MemoryMappedFile.CreateNew Metodo

Definizione

Spazio dei nomi:

System.IO.MemoryMappedFiles

Assembly:

System.IO.MemoryMappedFiles.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)

Origine:

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

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 alla 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. Il processo A crea il file mappato alla memoria e vi scrive un valore.

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

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

4. Process 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 di comando.

2. Nella prima finestra di comando eseguire Process A.

3. Nella seconda finestra di comando eseguire Process B.

4. Tornare a Elabora A e premere INVIO.

5. Nella terza finestra di comando eseguire Process C.

6. Tornare a Elabora A e premere INVIO.

L'output del processo 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

Utilizzare 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

• File mappati alla memoria

CreateNew(String, Int64, MemoryMappedFileAccess)

Origine:

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

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 alla memoria denominata (ovvero un non Null mapName) sono supportate solo nei sistemi operativi Windows.

Commenti

Utilizzare 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

• File mappati alla memoria

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

Origine:

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

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 alla memoria denominata (ovvero un non Null mapName) sono supportate solo nei sistemi operativi Windows.