MemoryMappedFile.CreateNew Metod

Definition

Namnområde:: System.IO.MemoryMappedFiles

Sammansättningar:: netstandard.dll, System.IO.MemoryMappedFiles.dll

Sammansättning:: System.IO.MemoryMappedFiles.dll

Sammansättning:: System.Core.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Skapar en minnesmappad fil i systemminnet.

Överlagringar

Name	Description
CreateNew(String, Int64)	Skapar en minnesmappad fil som har den angivna kapaciteten i systemminnet.
CreateNew(String, Int64, MemoryMappedFileAccess)	Skapar en minnesmappad fil som har den angivna kapacitets- och åtkomsttypen i systemminnet.
CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, HandleInheritability)	Skapar en minnesmappad fil med angivet namn, kapacitet, åtkomsttyp, alternativ för minnesallokering och ärvbarhet.
CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, MemoryMappedFileSecurity, HandleInheritability)	Skapar en minnesmappad fil som har angiven kapacitet, åtkomsttyp, minnesallokering, säkerhetsbehörigheter och ärvbarhet i systemminnet.

CreateNew(String, Int64)

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Skapar en minnesmappad fil som har den angivna kapaciteten i systemminnet.

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

Parametrar

mapName: String

Ett namn som ska tilldelas till den minnesmappade filen eller null för ett MemoryMappedFile namn som du inte tänker dela mellan processer.

capacity: Int64

Den maximala storleken i byte som ska allokeras till den minnesmappade filen.

Returer

MemoryMappedFile

En minnesmappad fil som har det angivna namnet och kapaciteten.

Undantag

ArgumentException

mapName är en tom sträng.

ArgumentOutOfRangeException

capacity är mindre än eller lika med noll.

PlatformNotSupportedException

endast .NET Core och .NET 5+ : Anrop till metoden CreateNew med en namngiven minnesmappad fil (dvs. en icke-null-mapName) stöds endast på Windows operativsystem.

Exempel

Följande exempel består av tre separata processer (konsolprogram) som skriver Boolean värden till en minnesmappad fil. Följande sekvens av åtgärder inträffar:

Process A skapar den minnesmappade filen och skriver ett värde till den.
Process B öppnar den minnesmappade filen och skriver ett värde till den.
Process C öppnar den minnesmappade filen och skriver ett värde till den.
Bearbeta A läser och visar värdena från den minnesmappade filen.
När process A har slutförts med den minnesmappade filen återtas filen omedelbart av skräpinsamlingen.

Kör det här exemplet genom att göra följande:

Kompilera programmen och öppna tre kommandofönster.
I det första kommandofönstret kör du Process A.
I det andra kommandofönstret kör du Process B.
Gå tillbaka till Process A och tryck på RETUR.
I det tredje kommandofönstret kör du Process C.
Gå tillbaka till Process A och tryck på RETUR.

Utdata från process A är följande:

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

Bearbeta 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

Kommentarer

Använd den här metoden om du vill skapa en minnesmappad fil som inte är sparad (dvs. inte associerad med en fil på disk), som du kan använda för att dela data mellan processer.

Se även

Memory-Mapped Filer

Gäller för

CreateNew(String, Int64, MemoryMappedFileAccess)

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Skapar en minnesmappad fil som har den angivna kapacitets- och åtkomsttypen i systemminnet.

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

Parametrar

mapName: String

Ett namn som ska tilldelas till den minnesmappade filen eller null för ett MemoryMappedFile namn som du inte tänker dela mellan processer.

capacity: Int64

Den maximala storleken i byte som ska allokeras till den minnesmappade filen.

access: MemoryMappedFileAccess

Ett av uppräkningsvärdena som anger vilken typ av åtkomst som tillåts till den minnesmappade filen. Standardvärdet är ReadWrite.

Returer

MemoryMappedFile

En minnesmappad fil som har de angivna egenskaperna.

Undantag

ArgumentException

mapName är en tom sträng.

-eller-

access är inställt på skrivskyddad med Write uppräkningsvärdet.

ArgumentOutOfRangeException

capacity är mindre än eller lika med noll.

-eller-

access är inte ett giltigt MemoryMappedFileAccess uppräkningsvärde.

PlatformNotSupportedException

endast .NET Core och .NET 5+ : Anrop till metoden CreateNew med en namngiven minnesmappad fil (dvs. en icke-null-mapName) stöds endast på Windows operativsystem.

Kommentarer

Använd den här metoden om du vill skapa en minnesmappad fil som inte är sparad (dvs. inte associerad med en fil på disk), som du kan använda för att dela data mellan processer.

Se även

Memory-Mapped Filer

Gäller för

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

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Källa:: MemoryMappedFile.cs

Skapar en minnesmappad fil med angivet namn, kapacitet, åtkomsttyp, alternativ för minnesallokering och ärvbarhet.

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

Parametrar

mapName: String

Ett namn som ska tilldelas till den minnesmappade filen eller null för ett MemoryMappedFile namn som du inte tänker dela mellan processer.

capacity: Int64

Den maximala storleken i byte som ska allokeras till den minnesmappade filen.

access: MemoryMappedFileAccess

Ett av uppräkningsvärdena som anger vilken typ av åtkomst som tillåts till den minnesmappade filen. Standardvärdet är ReadWrite.

options: MemoryMappedFileOptions

En bitvis kombination av uppräkningsvärden som anger alternativ för minnesallokering för den minnesmappade filen.

inheritability: HandleInheritability

Ett värde som anger om en referens till den minnesmappade filen kan ärvas av en underordnad process. Standardvärdet är None.

Returer

MemoryMappedFile

En minnesmappad fil som har de angivna egenskaperna.

Undantag

ArgumentException

mapName är en tom sträng.

-eller-

access är inställt på skrivskyddad med Write uppräkningsvärdet.

ArgumentOutOfRangeException

capacity är mindre än eller lika med noll.

-eller-

access är inte ett giltigt MemoryMappedFileAccess uppräkningsvärde.

-eller-

inheritability är inte ett giltigt HandleInheritability värde.

PlatformNotSupportedException

endast .NET Core och .NET 5+ : Anrop till metoden CreateNew med en namngiven minnesmappad fil (dvs. en icke-null-mapName) stöds endast på Windows operativsystem.

Gäller för

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

Skapar en minnesmappad fil som har angiven kapacitet, åtkomsttyp, minnesallokering, säkerhetsbehörigheter och ärvbarhet i systemminnet.

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

Parametrar

mapName: String

Ett namn som ska tilldelas till den minnesmappade filen eller null för ett MemoryMappedFile namn som du inte tänker dela mellan processer.

capacity: Int64

Den maximala storleken i byte som ska allokeras till den minnesmappade filen.

access: MemoryMappedFileAccess

Ett av uppräkningsvärdena som anger vilken typ av åtkomst som tillåts till den minnesmappade filen. Standardvärdet är ReadWrite.

options: MemoryMappedFileOptions

En bitvis kombination av uppräkningsvärden som anger alternativ för minnesallokering för den minnesmappade filen.

memoryMappedFileSecurity: MemoryMappedFileSecurity

Behörigheter som kan beviljas för filåtkomst och åtgärder på minnesmappade filer.

Den här parametern kan vara null.

inheritability: HandleInheritability

Ett av uppräkningsvärdena som anger om en referens till den minnesmappade filen kan ärvas av en underordnad process. Standardvärdet är None.

Returer

MemoryMappedFile

En minnesmappad fil som har de angivna egenskaperna.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentException

mapName är en tom sträng.

-eller-

access är inställt på skrivskyddad med Write uppräkningsvärdet.

ArgumentOutOfRangeException

capacity är mindre än eller lika med noll.

-eller-

access är inte ett giltigt MemoryMappedFileAccess uppräkningsvärde.

-eller-

inheritability är inte ett giltigt HandleInheritability uppräkningsvärde.

Kommentarer

Använd den här metoden om du vill skapa en minnesmappad fil som inte är sparad (dvs. inte associerad med en fil på disk), som du kan använda för att dela data mellan processer.

Se även

Memory-Mapped Filer

Gäller för

Feedback

Var den här sidan till hjälp?