Partager via


MemoryMappedFile.CreateNew Méthode

Définition

Crée un fichier mappé en mémoire dans la mémoire système.

Surcharges

CreateNew(String, Int64)

Crée un fichier mappé en mémoire qui a la capacité spécifiée dans la mémoire système.

CreateNew(String, Int64, MemoryMappedFileAccess)

Crée un fichier mappé en mémoire qui a la capacité et le type d’accès spécifiés dans la mémoire système.

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

Crée un fichier mappé en mémoire qui a le nom, la capacité, le type d’accès, les options d’allocation mémoire et les règles d’héritage spécifiés.

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

Crée un fichier mappé en mémoire qui a la capacité, le type d'accès, l'allocation de mémoire, les autorisations de sécurité et les règles d'héritage spécifiés dans la mémoire système.

CreateNew(String, Int64)

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

Crée un fichier mappé en mémoire qui a la capacité spécifiée dans la mémoire système.

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

Paramètres

mapName
String

Nom à attribuer au fichier mappé en mémoire, ou null pour un MemoryMappedFile que vous ne souhaitez pas partager entre plusieurs processus.

capacity
Int64

Taille maximale (en octets) à allouer au fichier mappé en mémoire.

Retours

Fichier mappé en mémoire qui a le nom et la capacité spécifiés.

Exceptions

mapName est une chaîne vide.

capacity est inférieur ou égal à zéro.

.NET Core et .NET 5+ uniquement : les appels à la CreateNew méthode avec un fichier mappé en mémoire nommé (autrement dit, un fichier non null mapName) sont pris en charge uniquement sur les systèmes d’exploitation Windows.

Exemples

L’exemple suivant est composé de trois processus distincts (applications console) qui écrivent Boolean des valeurs dans un fichier mappé en mémoire. La séquence d’actions suivante se produit :

  1. Le processus A crée le fichier mappé en mémoire et y écrit une valeur.

  2. Le processus B ouvre le fichier mappé en mémoire et y écrit une valeur.

  3. Le processus C ouvre le fichier mappé en mémoire et y écrit une valeur.

  4. Le processus A lit et affiche les valeurs du fichier mappé en mémoire.

  5. Une fois le processus A terminé avec le fichier mappé en mémoire, le fichier est immédiatement récupéré par garbage collection.

Pour exécuter cet exemple, procédez comme suit :

  1. Compilez les applications et ouvrez trois fenêtres De commande.

  2. Dans la première fenêtre Commande, exécutez Le processus A.

  3. Dans la deuxième fenêtre Commande, exécutez le processus B.

  4. Revenez à Traiter A et appuyez sur ENTRÉE.

  5. Dans la troisième fenêtre Commande, exécutez Le processus C.

  6. Revenez à Traiter A et appuyez sur ENTRÉE.

La sortie du processus A est la suivante :

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

Processus 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

Processus 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

Processus 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

Remarques

Utilisez cette méthode pour créer un fichier mappé en mémoire qui n’est pas conservé (c’est-à-dire qui n’est pas associé à un fichier sur le disque), que vous pouvez utiliser pour partager des données entre des processus.

Voir aussi

S’applique à

CreateNew(String, Int64, MemoryMappedFileAccess)

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

Crée un fichier mappé en mémoire qui a la capacité et le type d’accès spécifiés dans la mémoire système.

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

Paramètres

mapName
String

Nom à attribuer au fichier mappé en mémoire, ou null pour un MemoryMappedFile que vous ne souhaitez pas partager entre plusieurs processus.

capacity
Int64

Taille maximale (en octets) à allouer au fichier mappé en mémoire.

access
MemoryMappedFileAccess

L'une des valeurs d'énumération qui spécifie le type d'accès autorisé au fichier mappé en mémoire. La valeur par défaut est ReadWrite.

Retours

Fichier mappé en mémoire qui possède les caractéristiques spécifiées.

Exceptions

mapName est une chaîne vide.

- ou -

access est défini en écriture seule avec la valeur d’énumération Write.

capacity est inférieur ou égal à zéro.

- ou -

access n’est pas une valeur d’énumération MemoryMappedFileAccess valide.

.NET Core et .NET 5+ uniquement : les appels à la CreateNew méthode avec un fichier mappé en mémoire nommé (autrement dit, un fichier non null mapName) sont pris en charge uniquement sur les systèmes d’exploitation Windows.

Remarques

Utilisez cette méthode pour créer un fichier mappé en mémoire qui n’est pas conservé (c’est-à-dire qui n’est pas associé à un fichier sur le disque), que vous pouvez utiliser pour partager des données entre des processus.

Voir aussi

S’applique à

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

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

Crée un fichier mappé en mémoire qui a le nom, la capacité, le type d’accès, les options d’allocation mémoire et les règles d’héritage spécifiés.

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

Paramètres

mapName
String

Nom à attribuer au fichier mappé en mémoire, ou null pour un MemoryMappedFile que vous ne souhaitez pas partager entre plusieurs processus.

capacity
Int64

Taille maximale (en octets) à allouer au fichier mappé en mémoire.

access
MemoryMappedFileAccess

L'une des valeurs d'énumération qui spécifie le type d'accès autorisé au fichier mappé en mémoire. La valeur par défaut est ReadWrite.

options
MemoryMappedFileOptions

Combinaison d'opérations de bits de valeurs d'énumération qui spécifie des options d'allocation de mémoire pour le fichier mappé en mémoire.

inheritability
HandleInheritability

Valeur qui spécifie si un processus enfant peut hériter d’un handle au fichier mappé en mémoire. La valeur par défaut est None.

Retours

Fichier mappé en mémoire qui possède les caractéristiques spécifiées.

Exceptions

mapName est une chaîne vide.

- ou -

access est défini en écriture seule avec la valeur d’énumération Write.

capacity est inférieur ou égal à zéro.

- ou -

access n’est pas une valeur d’énumération MemoryMappedFileAccess valide.

- ou -

inheritability n’est pas une valeur de HandleInheritability valide.

.NET Core et .NET 5+ uniquement : les appels à la CreateNew méthode avec un fichier mappé en mémoire nommé (autrement dit, un fichier non null mapName) sont pris en charge uniquement sur les systèmes d’exploitation Windows.

S’applique à

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

Crée un fichier mappé en mémoire qui a la capacité, le type d'accès, l'allocation de mémoire, les autorisations de sécurité et les règles d'héritage spécifiés dans la mémoire système.

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

Paramètres

mapName
String

Nom à attribuer au fichier mappé en mémoire, ou null pour un MemoryMappedFile que vous ne souhaitez pas partager entre plusieurs processus.

capacity
Int64

Taille maximale (en octets) à allouer au fichier mappé en mémoire.

access
MemoryMappedFileAccess

L'une des valeurs d'énumération qui spécifie le type d'accès autorisé au fichier mappé en mémoire. La valeur par défaut est ReadWrite.

options
MemoryMappedFileOptions

Combinaison d'opérations de bits de valeurs d'énumération qui spécifie des options d'allocation de mémoire pour le fichier mappé en mémoire.

memoryMappedFileSecurity
MemoryMappedFileSecurity

Autorisations qui peuvent être accordées pour l'accès aux fichiers et aux opérations sur les fichiers mappés en mémoire.

Ce paramètre peut être null.

inheritability
HandleInheritability

L'une des valeurs d'énumération qui spécifie si un processus enfant peut hériter d'un handle au fichier mappé en mémoire. La valeur par défaut est None.

Retours

Fichier mappé en mémoire qui possède les caractéristiques spécifiées.

Attributs

Exceptions

mapName est une chaîne vide.

- ou -

access est défini en écriture seule avec la valeur d’énumération Write.

capacity est inférieur ou égal à zéro.

- ou -

access n’est pas une valeur d’énumération MemoryMappedFileAccess valide.

- ou -

inheritability n’est pas une valeur d’énumération HandleInheritability valide.

Remarques

Utilisez cette méthode pour créer un fichier mappé en mémoire qui n’est pas conservé (c’est-à-dire qui n’est pas associé à un fichier sur le disque), que vous pouvez utiliser pour partager des données entre des processus.

Voir aussi

S’applique à