Binden an einen in eine Cache Management Utility-Klasse geladenen nicht eingebetteten Bericht

Objektmodell

In diesem Berichtbindungsszenario wird ReportDocument verwendet (siehe Berichtbindung mit ReportDocument-Objektmodell).

Ort des Berichts

Berichte befinden sich im Dateiverzeichnis.

Beschreibung

Dieses Berichtbindungsszenario ist mit dem Berichtbindungsszenario Binden an eine Klasse zwischengespeicherter eingebetteter Berichte vergleichbar. Der Unterschied zu diesem Szenario liegt darin, dass die Berichte nicht eingebettet sind. Weitere Informationen über nicht eingebettete Berichte finden Sie unter Sollten eingebettete oder nicht eingebettete Berichte verwendet werden?

Crystal Reports für Visual Studio verfügt über zwei Funktionen, die das Zwischenspeichern von Berichten mit dem ASP.NET Cache-Objekt unterstützen:

Ein integriertes Cache Management Framework für Berichte, das eindeutige Parameter oder Anmeldeinformationen in ansonsten identischen Berichten erkennt und einen eindeutigen Schlüssel für jede zwischengespeicherte Instanz erfordert.
Die Schnittstelle ICachedReport zur Identifikation von Cache Management Utility-Klassen für das Cache Management Framework für Berichte.

Unter Binden an eine Klasse zwischengespeicherter eingebetteter Berichte haben Sie die Cached[Berichtname]-Klasse kennen gelernt, die automatisch erstellt wird, sobald ein Bericht in das Projekt eingebettet wird. Sie können eine Cache Management Utility-Klasse zur Verwaltung nicht eingebetteter Berichte jedoch manuell erstellen. Ein Codebeispiel finden Sie im nachfolgenden Abschnitt 'Implementierung'.

Ausführliche Informationen zum Zwischenspeichern von Berichten und zur Verwendung der Cache Management Utility-Klasse finden Sie unter Sollten normale oder zwischengespeicherte Berichte verwendet werden?

Einsatzmöglichkeiten für das Zwischenspeichern

Das Zwischenspeichern ist bestimmten Zwecken vorbehalten, da es bei unbedachter Anwendung zu einer Überbeanspruchung von Systemressourcen kommen kann. Informationen zu den Einsatzmöglichkeiten für das Zwischenspeichern finden Sie unter Zwischenspeichern von Berichten mit "hoher Mehrbenutzbarkeit".

Pro

Für Mehrbenutzbarkeit ausgelegt: Ideal für das Speichern von Berichten mit hoher Mehrbenutzbarkeit und wenig Permutationen in Parametern oder Anmeldeinformationen.
Optimierter Datenzugriff: Wenn Berichte mit hoher Mehrbenutzbarkeit sehr groß sind oder eine Abfrage enthalten, die so komplex ist, dass das Abrufen der Daten mehrere Minuten dauert, kann der Zugriff über die Cache Management Utility-Klasse beschleunigt w

Contra

Serverauslastung: Im ASP.NET Cache-Objekt verbleibende Berichte können die Arbeitsspeicherressourcen des Servers überbeanspruchen.
Persistenzprobleme: Der Cache verfügt über bestimmte Abhängigkeiten, die es ihm ermöglichen, Änderungen in einer Berichtinstanz zu suchen und die Berichtinstanz erneut zwischenzuspeichern. Bei Änderungen an der Datenbank wird die Berichtinstanz im Cache jedoch nicht mit diesen Änderungen aktualisiert.
Ressourcenintensiv: Wenn ein Bericht über Parameter verfügt, die häufig mit verschiedenen Parameterzeichenfolgen aufgerufen werden (insbesondere, wenn es sich bei einem dieser Parameter um die Anwender-ID handelt), entsteht bei jedem Aufruf ein neuer zwis Dies führt zur Beanspruchung von Systemressourcen. Wenn der Bericht nicht von vielen Anwendern verwendet wird, sollte die Berichtinstanz stattdessen einem Session-Objekt zugewiesen werden. Siehe Session und Persistenz des ReportDocument-Objektmodells.

So binden Sie einen nicht eingebetteten Bericht nach vorherigem Zwischenspeichern an ein CrystalReportViewer-Steuerelement

Anmerkung
Diese Prozedur funktioniert nur bei Projekten, die in Projekt-Setup erstellt wurden. Projekt-Setup enthält spezifische Namespaceverweise und Codekonfigurationen, die für diese Prozedur erforderlich sind. Die Prozedur kann ohne diese Konfiguration nicht ausgeführt werden. Führen Sie deshalb vor Beginn dieser Arbeitsschritte die Schritte unter Projekt-Setup aus.

Suchen Sie die Datei "World Sales Report.rpt" im Unterverzeichnis "General Business". Informationen zu Musterberichten finden Sie unter Verzeichnis "Samples".
Kopieren Sie den vollständigen Verzeichnispfad einschließlich "World Sales Report.rpt" in die Zwischenablage.
Deklarieren Sie innerhalb der (im Projekt-Setup erstellten) ConfigureCrystalReports()-Methode eine reportPath-Zeichenfolgenvariable, und weisen Sie eine Zeichenfolge zu, die den im vorherigen Schritt kopierten Verzeichnispfad der Datei "World Sales Report" enthält.

``` vb
Dim reportPath As String = _
"C:\Program Files\Microsoft Visual Studio 9.0\" _
& "Crystal Reports\Samples\En\Reports\General Business\" _
& "World Sales Report.rpt"
```

``` csharp
string reportPath =
"C:\\Program Files\\Microsoft Visual Studio 9.0\\"
+ "Crystal Reports\\Samples\\En\\Reports\\General Business\\"
+ "World Sales Report.rpt";
```

Deklarieren und instantiieren Sie die NonEmbeddedReportCacher-Klasse, und übergeben Sie sie an die reportFile-Zeichenfolgenvariable.

<table>
<colgroup>
<col style="width: 100%" />
</colgroup>
<thead>
<tr class="header">
<th><img src="images\xkh1wxd8.alert_note(de-de,VS.90).gif" alt="Note" class="note" />Anmerkung</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><p>Hinweise zum Erstellen der NonEmbeddedReportCacher-Klasse finden Sie in der nächsten schrittweisen Anleitung.</p></td>
</tr>
</tbody>
</table>

``` vb
Dim myNonEmbeddedReportCacher As NonEmbeddedReportCacher = _New NonEmbeddedReportCacher(reportFile)
```

``` csharp
NonEmbeddedReportCacher nonEmbeddedReportCacher = new NonEmbeddedReportCacher(reportFile);
```

Weisen Sie die Instanz der Cache Management Utility-Klasse des Berichts der ReportSource-Eigenschaft des CrystalReportViewer-Steuerelements zu.

``` vb
myCrystalReportViewer.ReportSource = myNonEmbeddedReportCacher
```

``` csharp
crystalReportViewer.ReportSource = nonEmbeddedReportCacher;
```

So erstellen Sie die Cache Management Utility-Klasse NonEmbeddedReportCacher

Erstellen Sie eine neue Klasse mit dem Namen NonEmbeddedReportCacher im Projekt.

``` vb
Public Class NonEmbeddedReportCacher

End Class
```

``` csharp
using System;

namespace MyWebApplication
{
public class NonEmbeddedReportCacher
{
public NonEmbeddedReportCacher()
{
}
}
}
```

Fügen Sie die ICachedReport-Schnittstelle an die Klassensignatur an.

``` vb
Public Class NonEmbeddedReportCacher
Implements ICachedReport
```

``` csharp
public class NonEmbeddedReportCacher : ICachedReport
```

Fügen Sie am Anfang der Klasse drei der Anweisungen "Imports" [Visual Basic] oder "using" [C#] hinzu.

``` vb
Imports CrystalDecisions.Shared
Imports CrystalDecisions.ReportSource
Imports CrystalDecisions.CrystalReports.Engine
```

``` csharp
using CrystalDecisions.Shared;
using CrystalDecisions.ReportSource;
using CrystalDecisions.CrystalReports.Engine;
```

Deklarieren Sie innerhalb der Klasse zwei Instanzen auf Klassenebene: eine Zeichenfolgeninstanz mit dem Namen reportFileName und eine ReportDocument-Instanz mit dem Namen nonEmbeddedReportDocument.

``` vb
Private reportFileName As String
Private nonEmbeddedReportDocument As ReportDocument
```

``` csharp
private string reportFileName;
private ReportDocument nonEmbeddedReportDocument;
```

Legen Sie den Konstruktor so fest, dass er eine reportFileName-Zeichenfolge akzeptiert, und weisen Sie diese Zeichenfolge innerhalb des Konstruktors der reportFileName-Klassenvariablen zu.
```
Public Sub New(ByVal reportFileName As String)
Me.reportFileName = reportFileName
End Sub
```
```
public NonEmbeddedReportCacher(string reportFileName)
{
this.reportFileName = reportFileName;
}
```
In den übrigen Schritten werden die Eigenschaften oder Methoden implementiert, die von der Schnittstelle benötigt werden:
- IsCacheable
- ShareDBLogonInfo
- CacheTimeOut
- CreateReport()
- GetCustomizedCacheKey(RequestContext-Anforderung)
Erstellen Sie die IsCacheable-Eigenschaft, die True zurückgeben sollte.

``` vb
Public Overridable Property IsCacheable() As Boolean Implements ICachedReport.IsCacheable
Get
Return True
End Get
Set(ByVal Value As Boolean)
End Set
End Property
```

``` csharp
public virtual Boolean IsCacheable
{
get
{
return true;
}
set
{
}
}
```

Erstellen Sie die ShareDBLogonInfo-Eigenschaft, die False zurückgeben sollte.

``` vb
Public Overridable Property ShareDBLogonInfo() As Boolean Implements ICachedReport.ShareDBLogonInfo
Get
Return False
End Get
Set(ByVal Value As Boolean)
End Set
End Property
```

``` csharp
public virtual Boolean ShareDBLogonInfo
{
get
{
return false;
}
set
{
}
}
```

Erstellen Sie die CacheTimeOut-Eigenschaft, die eine Konstante aus der CachedReportConstants-Klasse zurückgibt.

``` vb
Public Overridable Property CacheTimeOut() As TimeSpan Implements ICachedReport.CacheTimeOut
Get
Return CachedReportConstants.DEFAULT_TIMEOUT
End Get
Set(ByVal Value As TimeSpan)
End Set
End Property
```

``` csharp
public virtual TimeSpan CacheTimeOut
{
get
{
return CachedReportConstants.DEFAULT_TIMEOUT;
}
set
{
}
}
```

Erstellen Sie die CreateReport()-Methode, die einen nicht eingebetteten Bericht zurückgibt, der in eine ReportDocument-Instanz auf Klassenebene geladen wurde.

``` vb
Public Overridable Function CreateReport() As ReportDocument Implements ICachedReport.CreateReport
If nonEmbeddedReportDocument Is Nothing Then
nonEmbeddedReportDocument = New ReportDocument()
nonEmbeddedReportDocument.Load(reportFileName)
End If
Return nonEmbeddedReportDocument
End Function
```

``` csharp
public virtual ReportDocument CreateReport()
{
if (nonEmbeddedReportDocument == null)
{
nonEmbeddedReportDocument = new ReportDocument();
nonEmbeddedReportDocument.Load(reportFileName);
}
return nonEmbeddedReportDocument;
}
```

Erstellen Sie die GetCustomizedCacheKey()-Methode, und geben Sie Null zurück.

<table>
<colgroup>
<col style="width: 100%" />
</colgroup>
<thead>
<tr class="header">
<th><img src="images\xkh1wxd8.alert_note(de-de,VS.90).gif" alt="Note" class="note" />Anmerkung</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><p>Wenn diese Methode Null zurückgibt, wird das Crystal Reports .NET SDK angewiesen, den Cachesuchschlüssel selbst zu verwalten. Die Alternative besteht darin, an dieser Stelle eine eigene angepasste Cache-Schlüsselmethode zu erstellen und hinzuzufügen.</p></td>
</tr>
</tbody>
</table>

``` vb
Public Overridable Function GetCustomizedCacheKey(ByVal request As RequestContext) As String Implements ICachedReport.GetCustomizedCacheKey
Return Nothing
End Function
```

``` csharp
public virtual String GetCustomizedCacheKey(RequestContext request)
{
return null;
}
```

Um den Bericht anzeigen zu lassen, erstellen Sie Ihr Projekt und führen es aus.

Siehe auch

Last updated on 2008-04-22