Udostępnij za pośrednictwem


MemoryMappedFile.CreateNew Metoda

Definicja

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, MemoryMappedFileAccess, MemoryMappedFileOptions, MemoryMappedFileSecurity, HandleInheritability)

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

CreateNew(String, Int64)

Źródło:
MemoryMappedFile.cs
Źródło:
MemoryMappedFile.cs
Ź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);
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

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

Wyjątki

mapName jest pustym ciągiem.

capacity jest mniejsze niż lub równe zero.

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ż

Dotyczy

CreateNew(String, Int64, MemoryMappedFileAccess)

Źródło:
MemoryMappedFile.cs
Źródło:
MemoryMappedFile.cs
Ź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);
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

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

Wyjątki

mapName jest pustym ciągiem.

-lub-

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

capacity jest mniejsze niż lub równe zero.

-lub-

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

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ż

Dotyczy

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

Źródło:
MemoryMappedFile.cs
Źródło:
MemoryMappedFile.cs
Ź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);
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

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

Wyjątki

mapName jest pustym ciągiem.

-lub-

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

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ą.

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.

Dotyczy

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

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

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

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ęć.

memoryMappedFileSecurity
MemoryMappedFileSecurity

Uprawnienia, które można przyznać na potrzeby dostępu do plików i operacji na plikach mapowanych w pamięci.

Ten parametr może mieć wartość null.

inheritability
HandleInheritability

Jedna z wartości wyliczenia określająca, czy dojście do pliku mapowanego w pamięci może być dziedziczone przez proces podrzędny. Wartość domyślna to None.

Zwraca

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

Atrybuty

Wyjątki

mapName jest pustym ciągiem.

-lub-

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

capacity jest mniejsze niż lub równe zero.

-lub-

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

-lub-

inheritability nie jest prawidłową HandleInheritability wartością wyliczenia.

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ż

Dotyczy