MemoryMappedFile.CreateNew Metoda

Definicja

Przestrzeń nazw:

System.IO.MemoryMappedFiles

Zestaw:

System.IO.MemoryMappedFiles.dll

Tworzy plik zamapowany na pamięć w pamięci systemowej.

Przeciążenia

CreateNew(String, Int64)	Tworzy plik zamapowany na pamięć, który ma określoną pojemność w pamięci systemowej.
CreateNew(String, Int64, MemoryMappedFileAccess)	Tworzy plik zamapowany na pamięć, który ma określoną pojemność i typ dostępu w pamięci systemowej.
CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, HandleInheritability)	Tworzy plik mapowany na pamięć, który ma określoną nazwę, pojemność, typ dostępu, opcje alokacji pamięci i możliwość dziedziczenia.

CreateNew(String, Int64)

Źródło:

MemoryMappedFile.cs

Tworzy plik zamapowany na pamięć, który ma określoną pojemność w pamięci systemowej.

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

Parametry

mapName

String

Nazwa, która ma zostać przypisana do pliku mapowanego w pamięci lub null dla elementu, który MemoryMappedFile nie ma zamiaru udostępniać między procesami.

capacity

Int64

Maksymalny rozmiar w bajtach do przydzielenia do pliku zamapowanego na pamięć.

Zwraca

MemoryMappedFile

Plik mapowany na pamięć, który ma określoną nazwę i pojemność.

Wyjątki

ArgumentException

mapName jest pustym ciągiem.

ArgumentOutOfRangeException

capacity jest mniejsze niż lub równe zero.

PlatformNotSupportedException

Tylko platformy .NET Core i .NET 5+: wywołania CreateNew metody z nazwanym plikiem zamapowanym na pamięć (czyli non-null mapName) są obsługiwane tylko w systemach operacyjnych Windows.

Przykłady

Poniższy przykład składa się z trzech oddzielnych procesów (aplikacji konsolowych), które zapisują Boolean wartości w pliku mapowanym na pamięć. Następuje następująca sekwencja akcji:

1. Proces A tworzy plik zamapowany na pamięć i zapisuje do niego wartość.

2. Proces B otwiera plik zamapowany na pamięć i zapisuje do niego wartość.

3. Proces C otwiera plik zamapowany na pamięć i zapisuje do niego wartość.

4. Proces A odczytuje i wyświetla wartości z pliku zamapowanego na pamięć.

5. Po zakończeniu procesu A z plikiem zamapowanym na pamięć plik jest natychmiast odzyskiwany przez odzyskiwanie pamięci.

Aby uruchomić ten przykład, wykonaj następujące czynności:

1. Skompiluj aplikacje i otwórz trzy okna poleceń.

2. W pierwszym oknie Polecenia uruchom proces A.

3. W drugim oknie Polecenie uruchom proces B.

4. Wróć do procesu A i naciśnij klawisz ENTER.

5. W trzecim oknie Polecenie uruchom proces C.

6. Wróć do procesu A i naciśnij klawisz ENTER.

Dane wyjściowe procesu A są następujące:

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

Proces 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

Proces 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

Proces 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

Uwagi

Użyj tej metody, aby utworzyć plik zamapowany na pamięć, który nie jest utrwalone (tj. niezwiązany z plikiem na dysku), którego można użyć do udostępniania danych między procesami.

Zobacz też

• Pliki mapowane w pamięci

CreateNew(String, Int64, MemoryMappedFileAccess)

Źródło:

MemoryMappedFile.cs

Tworzy plik zamapowany na pamięć, który ma określoną pojemność i typ dostępu w pamięci systemowej.

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

Parametry

mapName

String

Nazwa, która ma zostać przypisana do pliku mapowanego w pamięci lub null dla elementu, który MemoryMappedFile nie ma zamiaru udostępniać między procesami.

capacity

Int64

Maksymalny rozmiar w bajtach do przydzielenia do pliku zamapowanego na pamięć.

access

MemoryMappedFileAccess

Jedna z wartości wyliczenia określająca typ dostępu dozwolonego do pliku mapowanego w pamięci. Wartość domyślna to ReadWrite.

Zwraca

MemoryMappedFile

Plik mapowany na pamięć, który ma określoną charakterystykę.

Wyjątki

ArgumentException

mapName jest pustym ciągiem.

-lub-

access parametr jest ustawiony na wartość tylko do zapisu z wartością Write wyliczenia.

ArgumentOutOfRangeException

capacity jest mniejsze niż lub równe zero.

-lub-

access nie jest prawidłową MemoryMappedFileAccess wartością wyliczenia.

PlatformNotSupportedException

Tylko platformy .NET Core i .NET 5+: wywołania CreateNew metody z nazwanym plikiem zamapowanym na pamięć (czyli non-null mapName) są obsługiwane tylko w systemach operacyjnych Windows.

Uwagi

Użyj tej metody, aby utworzyć plik zamapowany na pamięć, który nie jest utrwalone (tj. niezwiązany z plikiem na dysku), którego można użyć do udostępniania danych między procesami.

Zobacz też

• Pliki mapowane w pamięci

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

Źródło:

MemoryMappedFile.cs

Tworzy plik mapowany na pamięć, który ma określoną nazwę, pojemność, typ dostępu, opcje alokacji pamięci i możliwość dziedziczenia.

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

Parametry

mapName

String

Nazwa, która ma zostać przypisana do pliku mapowanego w pamięci lub null dla elementu, który MemoryMappedFile nie ma zamiaru udostępniać między procesami.

capacity

Int64

Maksymalny rozmiar w bajtach do przydzielenia do pliku zamapowanego na pamięć.

access

MemoryMappedFileAccess

Jedna z wartości wyliczenia określająca typ dostępu dozwolonego do pliku mapowanego w pamięci. Wartość domyślna to ReadWrite.

options

MemoryMappedFileOptions

Bitowa kombinacja wartości wyliczenia, która określa opcje alokacji pamięci dla pliku mapowanego na pamięć.

inheritability

HandleInheritability

Wartość określająca, czy dojście do pliku zamapowanego na pamięć może być dziedziczone przez proces podrzędny. Wartość domyślna to None.

Zwraca

MemoryMappedFile

Plik mapowany na pamięć, który ma określoną charakterystykę.

Wyjątki

ArgumentException

mapName jest pustym ciągiem.

-lub-

access parametr jest ustawiony na wartość tylko do zapisu z wartością Write wyliczenia.

ArgumentOutOfRangeException

capacity jest mniejsze niż lub równe zero.

-lub-

access nie jest prawidłową MemoryMappedFileAccess wartością wyliczenia.

-lub-

inheritability jest nieprawidłową HandleInheritability wartością.

PlatformNotSupportedException

Tylko platformy .NET Core i .NET 5+: wywołania CreateNew metody z nazwanym plikiem zamapowanym na pamięć (czyli non-null mapName) są obsługiwane tylko w systemach operacyjnych Windows.