Serialisieren Sie ein Dokument in einer Datenbank und arbeiten Sie damit

Eine der Aufgaben, die Sie bei der Arbeit mit Dokumenten möglicherweise erledigen müssen, ist das Speichern und Abrufen von Document-Objekten in und aus einer Datenbank. Dies wäre beispielsweise erforderlich, wenn Sie ein Content-Management-System jeglicher Art implementieren würden. Alle früheren Versionen von Dokumenten müssen im Datenbanksystem gespeichert sein. Die Möglichkeit, Dokumente in der Datenbank zu speichern, ist auch äußerst nützlich, wenn Ihre Anwendung einen webbasierten Dienst bereitstellt.

Aspose.Words bietet die Möglichkeit, ein Dokument in ein Byte-Array umzuwandeln, um es anschließend in einer Datenbank zu bearbeiten.

Konvertieren Sie ein Dokument in ein Byte-Array

Um ein Dokument in einer Datenbank zu speichern oder für die Übertragung im Internet vorzubereiten, ist es häufig erforderlich, das Dokument zu serialisieren, um ein Byte-Array zu erhalten.

So serialisieren Sie ein Document-Objekt in Aspose.Words:

1. Speichern Sie es mithilfe der Save-Methodenüberladung der Document-Klasse in einem MemoryStream.
2. Rufen Sie die ToArray-Methode auf, die ein Array von Bytes zurückgibt, die das Dokument in Byteform darstellen.

Die obigen Schritte können dann umgekehrt werden, um die Bytes wieder in ein Document-Objekt zu laden.

Das ausgewählte Speicherformat ist wichtig, um sicherzustellen, dass beim Speichern und erneuten Laden in das Document-Objekt die höchste Wiedergabetreue erhalten bleibt. Aus diesem Grund wird empfohlen, eine Reihe von OOXML-Dateiformaten zu verwenden.

Das folgende Beispiel zeigt, wie man ein Document-Objekt serialisiert, um ein Byte-Array zu erhalten, und wie man dann das Byte-Array deserialisiert, um wieder ein Document-Objekt zu erhalten:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_LoadingAndSaving();

// Load the document from disk.
Document doc = new Document(dataDir + "Test File (doc).doc");

// Create a new memory stream.
MemoryStream outStream = new MemoryStream();
// Save the document to stream.
doc.Save(outStream, SaveFormat.Docx);

// Convert the document to byte form.
byte[] docBytes = outStream.ToArray();

// The bytes are now ready to be stored/transmitted.

// Now reverse the steps to load the bytes back into a document object.
MemoryStream inStream = new MemoryStream(docBytes);

// Load the stream into a new document object.
Document loadDoc = new Document(inStream);

Sie können die Vorlagendatei dieses Beispiels von Aspose.Words GitHub herunterladen.

Speichern, lesen und löschen Sie ein Dokument in einer Datenbank

In diesem Abschnitt wird gezeigt, wie Sie ein Dokument in einer Datenbank speichern und es dann wieder in ein Document-Objekt laden, um damit zu arbeiten. Der Einfachheit halber ist der Dateiname der Schlüssel zum Speichern und Abrufen von Dokumenten aus der Datenbank. Die Datenbank enthält zwei Spalten. Die erste Spalte “FileName” wird als String gespeichert und dient zur Identifizierung von Dokumenten. Die zweite Spalte “FileContent” wird als BLOB-Objekt gespeichert, das das Dokumentobjekt in Byteform speichert.

Das folgende Codebeispiel zeigt, wie Sie eine Verbindung zu einer Datenbank einrichten und Befehle ausführen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
string dbName = "";
// Open a database connection.
string connString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + RunExamples.GetDataDir_Database() + dbName;
OleDbConnection mConnection = new OleDbConnection(connString);
mConnection.Open();

In diesem Beispiel verwenden wir die Microsoft Access .mdb-Datenbank zum Speichern eines Aspose.Words-Dokuments.

Das folgende Codebeispiel zeigt, wie man ein Dokument in der Datenbank speichert, dann dasselbe Dokument erneut liest und schließlich den Datensatz, der das Dokument enthält, aus der Datenbank löscht:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
// Store the document to the database.
StoreToDatabase(doc, mConnection);
// Read the document from the database and store the file to disk.
Document dbDoc = ReadFromDatabase(fileName, mConnection);

// Save the retrieved document to disk.
string newFileName = Path.GetFileNameWithoutExtension(fileName) + " from DB" + Path.GetExtension(fileName);
dbDoc.Save(dataDir + newFileName);

// Delete the document from the database.
DeleteFromDatabase(fileName, mConnection);

// Close the connection to the database.
mConnection.Close();

Speichern Sie ein Dokument in einer Datenbank

Um ein Dokument in einer Datenbank zu speichern, konvertieren Sie dieses Dokument in ein Byte-Array, wie am Anfang dieses Artikels beschrieben. Speichern Sie dann dieses Byte-Array in einem Datenbankfeld.

Das folgende Codebeispiel zeigt, wie ein Dokument in der angegebenen Datenbank gespeichert wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
public static void StoreToDatabase(Document doc, OleDbConnection mConnection)
{
    // Save the document to a MemoryStream object.
    MemoryStream stream = new MemoryStream();
    doc.Save(stream, SaveFormat.Docx);

    // Get the filename from the document.
    string fileName = Path.GetFileName(doc.OriginalFileName);

    // Create the SQL command.
    string commandString = "INSERT INTO Documents (FileName, FileContent) VALUES('" + fileName + "', @Docx)";
    OleDbCommand command = new OleDbCommand(commandString, mConnection);

    // Add the @Docx parameter.
    command.Parameters.AddWithValue("Docx", stream.ToArray());

    // Write the document to the database.
    command.ExecuteNonQuery(); 
}

Geben Sie commandString an, einen SQL-Ausdruck, der die ganze Arbeit erledigt:

• Um ein Dokument in der Datenbank zu speichern, wird der Befehl “INSERT INTO” verwendet und eine Tabelle zusammen mit den Werten von zwei Datensatzfeldern – FileName und FileContent – angegeben. Um zusätzliche Parameter zu vermeiden, wird der Dateiname vom Document-Objekt selbst übernommen. Dem FileContent-Feldwert werden Bytes aus dem Speicherstrom zugewiesen, der eine binäre Darstellung des gespeicherten Dokuments enthält. – Die verbleibende Codezeile führt den Befehl aus, der das Aspose.Words-Dokument in der Datenbank speichert.

Rufen Sie ein Dokument aus einer Datenbank ab

Um ein Dokument aus der Datenbank abzurufen, wählen Sie den Datensatz aus, der die Dokumentdaten als Byte-Array enthält. Laden Sie dann das Byte-Array aus dem Datensatz in MemoryStream und erstellen Sie ein Document-Objekt, das das Dokument aus MemoryStream lädt.

Das folgende Codebeispiel zeigt, wie ein Dokument aus der angegebenen Datenbank abgerufen und zurückgegeben wird, wobei der Dateiname als Schlüssel zum Abrufen dieses Dokuments verwendet wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
public static Document ReadFromDatabase(string fileName, OleDbConnection mConnection)
{
    // Create the SQL command.
    string commandString = "SELECT * FROM Documents WHERE FileName='" + fileName + "'";
    OleDbCommand command = new OleDbCommand(commandString, mConnection);

    // Create the data adapter.
    OleDbDataAdapter adapter = new OleDbDataAdapter(command);

    // Fill the results from the database into a DataTable.
    DataTable dataTable = new DataTable();
    adapter.Fill(dataTable);

    // Check there was a matching record found from the database and throw an exception if no record was found.
    if (dataTable.Rows.Count == 0)
        throw new ArgumentException(string.Format("Could not find any record matching the document \"{0}\" in the database.", fileName));

    // The document is stored in byte form in the FileContent column.
    // Retrieve these bytes of the first matching record to a new buffer.
    byte[] buffer = (byte[])dataTable.Rows[0]["FileContent"];

    // Wrap the bytes from the buffer into a new MemoryStream object.
    MemoryStream newStream = new MemoryStream(buffer);

    // Read the document from the stream.
    Document doc = new Document(newStream);

    // Return the retrieved document.
    return doc;
}

Mit dem SQL-Befehl “SELECT * FROM” wird der entsprechende Datensatz anhand des Dateinamens abgerufen.

Löschen Sie ein Dokument aus einer Datenbank

Um ein Dokument aus der Datenbank zu löschen, verwenden Sie den entsprechenden SQL-Befehl ohne Manipulationen am Document-Objekt.

Das folgende Codebeispiel zeigt, wie Sie ein Dokument aus der Datenbank löschen und den Dateinamen zum Abrufen des Datensatzes verwenden:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
public static void DeleteFromDatabase(string fileName, OleDbConnection mConnection)
{
    // Create the SQL command.
    string commandString = "DELETE * FROM Documents WHERE FileName='" + fileName + "'";
    OleDbCommand command = new OleDbCommand(commandString, mConnection);

    // Delete the record.
    command.ExecuteNonQuery();

}