Dela via

Instruktioner: Konvertera mellan .NET Framework- och Windows Runtime-strömmar (endast Windows)

  • Artikel

.NET Framework för UWP-appar är en delmängd av hela .NET Framework. På grund av säkerhet och andra krav för UWP-appar kan du inte använda den fullständiga uppsättningen .NET Framework-API:er för att öppna och läsa filer. Mer information finns i Översikt över .NET för UWP-appar. Du kanske dock vill använda .NET Framework-API:er för andra strömmanipuleringsåtgärder. Om du vill ändra dessa strömmar kan du konvertera mellan en .NET Framework-strömtyp, till exempel MemoryStream eller FileStream, och en Windows Runtime-ström, till exempel IInputStream, IOutputStreameller IRandomAccessStream.

Klassen System.IO.WindowsRuntimeStreamExtensions innehåller metoder som gör dessa konverteringar enkla. Underliggande skillnader mellan .NET Framework- och Windows Runtime-strömmar påverkar dock resultatet av att använda dessa metoder, enligt beskrivningen i följande avsnitt:

Konvertera från en Windows Runtime till en .NET Framework-ström

Om du vill konvertera från en Windows Runtime-ström till en .NET Framework-ström använder du någon av följande System.IO.WindowsRuntimeStreamExtensions metoder:

Windows Runtime erbjuder strömtyper som endast stöder läsning, endast skrivning eller läsning och skrivning. De här funktionerna bibehålls när du konverterar en Windows Runtime-ström till en .NET Framework-ström. Om du konverterar en Windows Runtime-dataström till en .NET Framework-ström och tillbaka får du tillbaka den ursprungliga Windows Runtime-instansen.

Det är bästa praxis att använda konverteringsmetoden som matchar funktionerna i den Windows Runtime-ström som du vill konvertera. Men eftersom IRandomAccessStream är läsbar och skrivbar (den implementerar både IOutputStream och IInputStream), behåller konverteringsmetoderna funktionerna i den ursprungliga strömmen. Om du till exempel använder WindowsRuntimeStreamExtensions.AsStreamForRead för att konvertera en IRandomAccessStream begränsas inte den konverterade .NET Framework-strömmen till att vara läsbar. Det är också skrivbart.

Exempel: Konvertera slumpmässig åtkomst i Windows Runtime till .NET Framework-dataström

Om du vill konvertera från en slumpmässig Åtkomstström för Windows Runtime till en .NET Framework-ström använder du WindowsRuntimeStreamExtensions.AsStream metoden .

I följande kodexempel uppmanas du att välja en fil, öppnar den med Windows Runtime-API:er och sedan konverterar den till en .NET Framework-ström. Den läser strömmen och matar ut den till ett textblock. Du skulle vanligtvis ändra strömmen med .NET Framework-API:er innan du matar ut resultatet.

// Create a file picker.
FileOpenPicker picker = new FileOpenPicker();
picker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
picker.ViewMode = PickerViewMode.List;
picker.FileTypeFilter.Add(".txt");

// Show picker, enabling user to pick one file.
StorageFile result = await picker.PickSingleFileAsync();
if (result != null)
{
    try
    {
        // Retrieve the stream. This method returns a IRandomAccessStreamWithContentType.
        var stream = await result.OpenReadAsync();

        // Convert the stream to a .NET stream using AsStream, pass to a
        // StreamReader and read the stream.
        using (StreamReader sr = new StreamReader(stream.AsStream()))
        {
            TextBlock1.Text = sr.ReadToEnd();
        }
    }
    catch (Exception ex)
    {
        // ...
    }
}

Konvertera från ett .NET Framework till en Windows Runtime-dataström

Om du vill konvertera från en .NET Framework-ström till en Windows Runtime-ström använder du någon av följande System.IO.WindowsRuntimeStreamExtensions metoder:

När du konverterar en .NET Framework-ström till en Windows Runtime-ström beror funktionerna i den konverterade strömmen på den ursprungliga strömmen. Om den ursprungliga strömmen till exempel stöder både läsning och skrivning, och du anropar WindowsRuntimeStreamExtensions.AsInputStream för att konvertera strömmen, är den returnerade typen en IRandomAccessStream. IRandomAccessStream implementerar IInputStream och IOutputStream, och stöder läsning och skrivning.

.NET Framework-strömmar stöder inte kloning, inte ens efter konverteringen. Om du konverterar en .NET Framework-ström till en Windows Runtime-ström och anropar GetInputStreamAt eller GetOutputStreamAt, som anropar CloneStream, eller om du anropar CloneStream direkt, uppstår ett undantag.

Exempel: Konvertera .NET Framework till slumpmässig åtkomstström i Windows Runtime

Om du vill konvertera från en .NET Framework-ström till en slumpmässig Åtkomstström för Windows Runtime använder du AsRandomAccessStream metoden, som du ser i följande exempel:

Viktigt!

Kontrollera att den .NET Framework-ström som du använder stöder sökning eller kopiera den till en ström som gör det. Du kan använda egenskapen Stream.CanSeek för att fastställa detta.

// Create an HttpClient and access an image as a stream.
var client = new HttpClient();
Stream stream = await client.GetStreamAsync("https://learn.microsoft.com/en-us/dotnet/images/hub/featured-1.png");
// Create a .NET memory stream.
var memStream = new MemoryStream();
// Convert the stream to the memory stream, because a memory stream supports seeking.
await stream.CopyToAsync(memStream);
// Set the start position.
memStream.Position = 0;
// Create a new bitmap image.
var bitmap = new BitmapImage();
// Set the bitmap source to the stream, which is converted to a IRandomAccessStream.
bitmap.SetSource(memStream.AsRandomAccessStream());
// Set the image control source to the bitmap.
Image1.Source = bitmap;

Se även