MemoryMappedFile Klas

Definitie

public ref class MemoryMappedFile : IDisposable

public class MemoryMappedFile : IDisposable

type MemoryMappedFile = class
    interface IDisposable

Public Class MemoryMappedFile
Implements IDisposable

Overname

Object

MemoryMappedFile

Implementeringen

IDisposable

Voorbeelden

In het volgende voorbeeld wordt een geheugenweergave gemaakt van een deel van een zeer groot bestand en wordt een deel ervan bewerkt.

using System;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Runtime.InteropServices;

class Program
{
    static void Main(string[] args)
    {
        long offset = 0x10000000; // 256 megabytes
        long length = 0x20000000; // 512 megabytes

        // Create the memory-mapped file.
        using (var mmf = MemoryMappedFile.CreateFromFile(@"c:\ExtremelyLargeImage.data", FileMode.Open,"ImgA"))
        {
            // Create a random access view, from the 256th megabyte (the offset)
            // to the 768th megabyte (the offset plus length).
            using (var accessor = mmf.CreateViewAccessor(offset, length))
            {
                int colorSize = Marshal.SizeOf(typeof(MyColor));
                MyColor color;

                // Make changes to the view.
                for (long i = 0; i < length; i += colorSize)
                {
                    accessor.Read(i, out color);
                    color.Brighten(10);
                    accessor.Write(i, ref color);
                }
            }
        }
    }
}

public struct MyColor
{
    public short Red;
    public short Green;
    public short Blue;
    public short Alpha;

    // Make the view brighter.
    public void Brighten(short value)
    {
        Red = (short)Math.Min(short.MaxValue, (int)Red + value);
        Green = (short)Math.Min(short.MaxValue, (int)Green + value);
        Blue = (short)Math.Min(short.MaxValue, (int)Blue + value);
        Alpha = (short)Math.Min(short.MaxValue, (int)Alpha + value);
    }
}

Imports System.IO
Imports System.IO.MemoryMappedFiles
Imports System.Runtime.InteropServices

Class Program

    Sub Main()
        Dim offset As Long = &H10000000 ' 256 megabytes
        Dim length As Long = &H20000000 ' 512 megabytes

        ' Create the memory-mapped file.
        Using mmf = MemoryMappedFile.CreateFromFile("c:\ExtremelyLargeImage.data", FileMode.Open, "ImgA")
            ' Create a random access view, from the 256th megabyte (the offset)
            ' to the 768th megabyte (the offset plus length).
            Using accessor = mmf.CreateViewAccessor(offset, length)
                Dim colorSize As Integer = Marshal.SizeOf(GetType(MyColor))
                Dim color As MyColor
                Dim i As Long = 0

                ' Make changes to the view.
                Do While (i < length)
                    accessor.Read(i, color)
                    color.Brighten(10)
                    accessor.Write(i, color)
                    i += colorSize
                Loop
            End Using
        End Using
    End Sub
End Class

Public Structure MyColor
    Public Red As Short
    Public Green As Short
    Public Blue As Short
    Public Alpha As Short

    ' Make the view brighter.
    Public Sub Brighten(ByVal value As Short)
        Red = CType(Math.Min(Short.MaxValue, (CType(Red, Integer) + value)), Short)
        Green = CType(Math.Min(Short.MaxValue, (CType(Green, Integer) + value)), Short)
        Blue = CType(Math.Min(Short.MaxValue, (CType(Blue, Integer) + value)), Short)
        Alpha = CType(Math.Min(Short.MaxValue, (CType(Alpha, Integer) + value)), Short)
    End Sub
End Structure

Opmerkingen

Een geheugentoewijzingsbestand wijst de inhoud van een bestand toe aan de logische adresruimte van een toepassing. Met geheugen toegewezen bestanden kunnen programmeurs met extreem grote bestanden werken, omdat het geheugen gelijktijdig kan worden beheerd en ze volledige, willekeurige toegang tot een bestand toestaan zonder dat ze op zoek hoeven te zijn. Geheugen toegewezen bestanden kunnen ook worden gedeeld over meerdere processen.

De CreateFromFile methoden maken een geheugentoewijzingsbestand op basis van een opgegeven pad of een FileStream bestaand bestand op schijf. Wijzigingen worden automatisch doorgegeven aan de schijf wanneer het bestand niet is toegewezen.

De CreateNew methoden maken een geheugentoewijzingsbestand dat niet is toegewezen aan een bestaand bestand op schijf en zijn geschikt voor het maken van gedeeld geheugen voor IPC (Interprocess Communication).

Een geheugentoewijzingsbestand kan worden gekoppeld aan een optionele naam waarmee het geheugentoewijzingsbestand kan worden gedeeld met andere processen.

U kunt meerdere weergaven van het geheugentoewijzingsbestand maken, inclusief weergaven van delen van het bestand. U kunt hetzelfde deel van een bestand toewijzen aan meer dan één adres om gelijktijdig geheugen te maken. Om twee weergaven gelijktijdig te houden, moeten ze gebaseerd zijn op hetzelfde geheugen-gehecht bestand. Het maken van twee bestandstoewijzingen van hetzelfde bestand met twee weergaven biedt geen gelijktijdigheid.

Zie ook

• Memory-Mapped-bestanden