Was ist der einfachste Weg zu schreiben, eine zwei-dimensionales array in eine Datei?

Was ist der einfachste Weg zu schreiben, eine zwei-dimensionales array in eine Datei die in C#?

Alle Fragen, die ich bisher gelesen sind für string-arrays, aber ich brauche zum schreiben von Daten.
Ich bin mit der Konvertierung eines alten C-Projekt, und es war einfach in C:

FILE *file;
unsigned char site[32][10];

Initialisieren Sie das array, und öffnen Sie die Datei zum Lesen/schreiben ( die Datei ist immer geöffnet, in das Projekt):

Schreiben der Daten:

if (fseek (file, offset, SEEK_SET))
  return (0);
return (fwrite (&site, sizeof (site), 1, file));

Zum Lesen der Daten:

if (fseek (file, offset, SEEK_SET))
  return (0);
return (fread (&site, sizeof (site), 1, fsite));

Die Datei nicht zu öffnen die ganze Zeit, so habe ich versucht:

byte [,] = new byte[32,10] = { some data here };
File.WriteAllBytes(fileDescr, site);

Aber es funktioniert nicht mit 2-dimensionalen arrays.

Müssen Sie behalten die gleiche Datei-format wie die, die man produziert, indem Sie das C-Programm?
wenn die Antworten hier sind speziell für Binär-und Ihre Frage ist über binäre dann vielleicht sollten Sie in Ihren Titel

InformationsquelleAutor Simon Rees | 2013-03-19

arrays c#file

Referenzen:

using System.Runtime.Serialization.Formatters.Binary;

Methoden:

public static void Serialize(object t, string path)
{
    using(Stream stream = File.Open(path, FileMode.Create))
    {
        BinaryFormatter bformatter = new BinaryFormatter();
        bformatter.Serialize(stream, t);
    }
}
//Could explicitly return 2d array, 
//or be casted from an object to be more dynamic
public static object Deserialize(string path) 
{
    using(Stream stream = File.Open(path, FileMode.Open))
    {
        BinaryFormatter bformatter = new BinaryFormatter();
        return bformatter.Deserialize(stream);
    }
}

Im Einsatz

//Saving
byte[,] TestArray = new int[1000,1000];
//...Fill array
Serialize(TestArray, "Test.osl");

//Loading
byte[,] TestArray = (byte[,])Deserialize("Test.osl");

Leider, ich fand diese Methode sehr langsam für große arrays (z.B. digitale Bilder).
Ja, es scheint, dass die binaryserializer hat performance-Probleme bei großen, mehrdimensionalen arrays, aber das kann currated durch die Umwandlung des Arrays zu einem einzigen Maß-oder jagged-array oder durch die Verwendung einiger unsicherer code wie hier gezeigt: stackoverflow.com/questions/8059813/...
Ja. Es ist möglich, Zeiger auf mehrdimensionale Arrays zu Durchlaufen, ist es in einem-dimensionalen Mode (einfach Inkrementieren der Zeiger) beim kopieren der Daten zu byte [] - Puffer und Spülen Sie es auf der Festplatte. Dies ist wesentlich schneller dann BinaryFormatter. Zeiger erlauben auch einfache casting von primitiven Typen byte (siehe BitConverter Umsetzung).

InformationsquelleAutor corylulu

Wenn bewahren Sie die Abwärtskompatibilität mit der alten 'C' - Programm-Datei-format, ist es vielleicht am einfachsten, wenn Sie die Windows-API verwenden um die Daten zu schreiben. (Wenn nicht, sollten Sie eine BinaryFormatter wie bereits in vorherigen Antworten).

Aber wenn Sie tun wollen, verwenden Sie die Windows-API, hier ein Beispiel:

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;

namespace Demo
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var site = new byte[32,10];

            using (var fs = new FileStream("C:\\TEST\\TEST.BIN", FileMode.Create))
            {
                FastWrite(fs, site, 0, 32*10);
            }
        }

        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]

        private static extern bool WriteFile
        (
            IntPtr hFile,
            IntPtr lpBuffer,
            uint nNumberOfBytesToWrite,
            out uint lpNumberOfBytesWritten,
            IntPtr lpOverlapped
        );

        public static void FastWrite<T>(FileStream fs, T[,] array, int offset, int count) where T : struct
        {
            int sizeOfT = Marshal.SizeOf(typeof (T));
            GCHandle gcHandle = GCHandle.Alloc(array, GCHandleType.Pinned);

            try
            {
                uint bytesWritten;
                uint bytesToWrite = (uint) (count*sizeOfT);

                if (!WriteFile(
                    fs.SafeFileHandle.DangerousGetHandle(),
                    new IntPtr(gcHandle.AddrOfPinnedObject().ToInt64() + (offset*sizeOfT)),
                    bytesToWrite,
                    out bytesWritten,
                    IntPtr.Zero
                )){
                    throw new IOException("Unable to write file.", new Win32Exception(Marshal.GetLastWin32Error()));
                }

                Debug.Assert(bytesWritten == bytesToWrite);
            }

            finally
            {
                gcHandle.Free();
            }
        }
    }
}

Danke für die schnellen replys. Im froh, dass ich hier gefragt wurde ich überschwemmt mit .NET-Lösungen, und keiner von Ihnen waren die Lösungen, die hier vorgeschlagen werden. Ich habe mehr als ein Ort, wo ich zu tun haben und mindestens einer von Ihnen muss rückwärtskompatibel sein, und der rest nicht so ich werde versuchen alle Vorschläge und Bericht zu erstatten.

InformationsquelleAutor Matthew Watson

0

Verwenden System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.
```
public void Serialize(String path, byte[,] myArray)
{
    BinaryFormatter formatter = new BinaryFormatter();
    using (FileStream stream = new FileStream(path, FileMode.Create, FileAccess.Write))
    {
        formatter.Serialize(stream, myArray);
    }
}
```
Die Datei zu Lesen, verwenden Sie die BinaryFormatter-s Deserialize Methode.
```
public byte[,] Deserialize(String path)
{
    BinaryFormatter formatter = new BinaryFormatter();
    using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read))
    {
        byte[,] myArray = (byte[,])formatter.Deserialize(stream);
    }
}
```
- Eine Frage und zwar wenn ich mit der kernel32-option wird es sein, gestützt auf windows8 oder darüber hinaus?
- Windows 8, ja, darüber würde ich davon ausgehen, ja, weil Sie Microsoft nicht mögen, zu brechen der Abwärtskompatibilität. Ich würde ernsthaft in Erwägung ziehen @MatthewWatson version obwohl, wie es ist kompatibel mit allen Dateien, die Sie bereits erstellt haben, in der alten Anwendung-keine Notwendigkeit, Lesen und schreiben Sie.
InformationsquelleAutor Ryan Frame

    //For I/O
    using System.IO;  

    //Output Stream Writer variable
    StreamWriter yourOSW;  

    //Open the file
    yourOSW = new StreamWriter(fileName); 

    //To declare array
    byte[,] yourArray = new byte[numRows, numColumns];  

    //Data value
    byte num = 0;  

    //To fill array (example)
    for(byte i = 0; i < numRows; i++)
    {
        for(byte j = 0; j < numColumns; j++)
        {
            yourArray[i,j] = num;
            num++;
        }
    }

    //To write array to file
    for(byte i = 0; i < numRows; i++)
    {
        for(byte j = 0; j < numColumns; j++)
        {
            yourOSW.WriteLine(yourArray[i,j]);
        }
    }

InformationsquelleAutor cpray89

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.