Erstellen von Filter-Editoren für PerformancePoint-Dienste in SharePoint
In diesem Artikel erfahren Sie, wie die Editor-Komponente einer benutzerdefinierten Filtererweiterung für PerformancePoint-Dienste erstellt wird.
Was sind benutzerdefinierte Filter-Editoren für PerformancePoint-Dienste ?
In PerformancePoint-Dienste aktivieren Sie benutzerdefinierte Filter-Editoren Benutzer Eigenschaften für benutzerdefinierte Filter fest. Filter-Editoren müssen auch die BeginPoints-Eigenschaft eines Filters initialisieren, die den Filteranfangspunkt definiert, der Parameterwerte für Scorecard- und Berichtsconsumer enthält. Weitere Informationen zu Editor Anforderungen und Funktionen finden Sie unter Editoren für benutzerdefinierte PerformancePoint Services-Objekte.
Die folgenden Prozeduren und Beispielen basieren auf der SampleFilterEditor -Klasse aus der benutzerdefinierten Objekte (Beispiel). Der Editor ist eine dünne Anwendung, die Benutzern ermöglicht, ändern Name und Beschreibung des Filters und die zugrunde liegenden Datenquelle auswählen. Den vollständigen Code für die -Klasse finden Sie unter Codebeispiel: Erstellen, Abrufen und Aktualisieren von benutzerdefinierten PerformancePoint-Dienste Filtern in SharePoint.
Es wird empfohlen, dass Sie den Beispiel-Editor als Vorlage verwenden. Das Beispiel zeigt wie Objekte aufrufen PerformancePoint-Dienste-API bietet Hilfsobjekte, die vereinfachen von Anrufen für Repository-Vorgänge (wie erstellen und Aktualisieren der Objekte), und bewährte Methoden für die Entwicklung von PerformancePoint-Dienste veranschaulicht.
Erstellen Sie und konfigurieren Sie die Editorklasse für benutzerdefinierte PerformancePoint-Dienste Filter
Installieren Sie PerformancePoint-Dienste, oder kopieren Sie die DLLs, die die Erweiterung verwendet (siehe Schritt 3) auf Ihrem Computer. Weitere Informationen finden Sie unter DLLs mit Klassenbibliotheken.
Erstellen Sie in Visual Studio eine C#-Klassenbibliothek. Wenn Sie eine Klassenbibliothek für die Erweiterung erstellt haben, fügen Sie eine neue C#-Klasse.
Sie müssen die DLL mit einem starken Namen signieren. Stellen Sie außerdem sicher, dass alle Assemblys, auf die von der DLL verwiesen wird, ebenfalls starke Namen haben. Informationen zum Signieren einer Assembly mit einem starken Namen und zum Erstellen eines öffentlichen/privaten Schlüsselpaars finden Sie unter Vorgehensweise: Erstellen eines öffentlichen/privaten Schlüsselpaars.
Fügen Sie dem Projekt die folgenden DLLs als Assemblyverweise hinzu:
- Microsoft.PerformancePoint.Scorecards.Client.dll
- Microsoft.PerformancePoint.Scorecards.ServerCommon.dll
- Microsoft.PerformancePoint.Scorecards.ServerRendering.dll
- Microsoft.PerformancePoint.Scorecards.Store.dll (von Hilfsklassen verwendet)
- Microsoft.SharePoint.dll (used by helper classes)
The sample editor also contains assembly references to System.Web.dll and System.Web.Services.dll. Depending on your extension's functionality, other project references may be required.
Fügen Sie dem Projekt die folgenden Klassen aus dem Beispiel. Im Editor wird für die Interaktion mit dem Repository PerformancePoint-Dienste Hilfsklassen verwendet:
- DataSourceConsumerHelper.cs
- ExtensionRepositoryHelper.cs
- FilterRepositoryHelper.cs
- IDataSourceConsumer.cs
Fügen Sie in Ihrer Editor-Klasse Direktiven für die folgenden PerformancePoint-Dienste Namespaces hinzu
using:- Microsoft.PerformancePoint.Scorecards
- Microsoft.PerformancePoint.Scorecards.ServerCommon
- Microsoft.PerformancePoint.Scorecards.ServerRendering
Je nach Funktionalität der Erweiterung sind u. U. andere using-Direktiven erforderlich.
Übernehmen Sie von der Basisklasse, die die Implementierung Ihres Editors unterstützt. Da der Beispielfilter-Editor eine Webanwendung ist, erbt er von der Page-Klasse . Andere Implementierungen können von Basisklassen wie der UserControl-Klasse oder der WebPart-Klasse abgeleitet werden.
Definieren Sie Steuerelemente, mit denen die Eigenschaften verfügbar gemacht werden, die die Benutzer anzeigen oder ändern sollen. Mit dem Beispiel-Filter-Editor werden zunächst Variablen für die Webserversteuerelemente deklariert, die in der Benutzeroberflächenkomponente definiert sind, wobei es sich um eine ASPX-Seite handelt. Außerdem wird mit dem Beispieleditor ein Schaltflächensteuerelement definiert, mit dem Benutzer Änderungen senden können. Anschließend ruft der Editor die CreateChildControls() -Methode auf, um die Steuerelemente auf der Seite verfügbar zu machen.
Hinweis
Im Editor wird die Programmierlogik separat von der Benutzeroberfläche definiert. Anweisungen zum Erstellen der Benutzeroberflächenkomponenten würden den Rahmen dieser Dokumentation sprengen.
Im Beispiel Filter-Editor führt die Schritte 8 bis 12 in der Page_Load -Methode. Page_Load wird auch initialisieren und Überprüfen von Variablen und Steuerelemente, füllen Sie Steuerelemente und Statusinformationen für die benutzerdefinierte Filter und Hilfsprogramm-Objekte zu speichern.
Legen Sie die AllowUnsafeUpdates-Eigenschaft auf true fest. Dadurch können mit dem Filter-Editor Daten in das Repository geschrieben werden, ohne POST-Vorgänge des Formulars zu verwenden.
Rufen Sie die Parameter aus der Abfragezeichenfolge ab, und legen Sie sie als Werte für lokale Variablen fest, wie im folgenden Codebeispiel dargestellt.
// The URL of the site collection that contains the PerformancePoint Services repository. string server = Request.QueryString[ClickOnceLaunchKeys.SiteCollectionUrl]; // The location of the filter in the repository. string itemLocation = Request.QueryString[ClickOnceLaunchKeys.ItemLocation]; // The operation to perform: OpenItem or CreateItem. string action = Request.QueryString[ClickOnceLaunchKeys.LaunchOperation];Hinweis
Informationen zu Abfragezeichenfolgenparametern finden Sie unter Editoren für benutzerdefinierte PerformancePoint-Dienste Objects.
Rufen Sie das FilterRepositoryHelper-Objekt ab, das für Aufrufe an das Repository verwendet wird, wie im folgenden Codebeispiel illustriert.
filterRepositoryHelper = new FilterRepositoryHelper();Legen Sie wie im folgenden Codebeispiel dargestellt den Filter für die Datenquelle basierend auf dem Abfragezeichenfolgen-Parameter fest.
RepositoryLocation repositoryFilterLocation = RepositoryLocation.CreateFromUriString(itemLocation);Vorgang ( OpenItem oder CreateItem) aus der Abfragezeichenfolge abzurufen und abzurufen oder den benutzerdefinierten Filter zu erstellen.
- Verwenden Sie die FilterRepositoryHelper.Get-Methode zum Abrufen des benutzerdefinierten Filters.
- Um den benutzerdefinierten Filter zu erstellen, verwenden Sie den Konstruktor Filter(), und definieren Sie Eigenschaften für den Filter Name , RendererClassName und SubTypeId . SubTypeId ist der eindeutige Bezeichner für den Filter, und es muss übereinstimmen, das subType -Attribut, das Sie für den benutzerdefinierten Filter in der PerformancePoint-Dienste web.config-Datei angeben. RendererClassName ist den vollqualifizierten Namen der Klasse, die das Webserversteuerelement Renderer definiert. Wenn es nicht im Editor definiert ist, ist die Standardeinstellung der Rendererklasse, die in der Datei web.config angegeben ist.
if (ClickOnceLaunchValues.OpenItem.Equals(action, StringComparison.OrdinalIgnoreCase)) { // Use the repository-helper object to retrieve the filter. filter = filterRepositoryHelper.Get(repositoryFilterLocation); if (filter == null) { displayError("Could not retrieve the filter for editing."); return; } } else if (ClickOnceLaunchValues.CreateItem.Equals(action, StringComparison.OrdinalIgnoreCase)) { filter = new Filter { RendererClassName = typeof(MultiSelectTreeViewControl).AssemblyQualifiedName, SubTypeId = "SampleFilter" }; }Hinweis
Standardmäßig können Benutzer benutzerdefinierte Objekte nur über PerformancePoint Dashboard Designer erstellen. Damit Benutzer ein benutzerdefiniertes Objekt außerhalb des Dashboard-Designers erstellen können, müssen Sie ein Menüelement hinzufügen, das eine CreateItem-Anforderung aus dem Inhaltstyp im Repository an Ihren Editor sendet. Weitere Informationen finden Sie unter Editoren für benutzerdefinierte PerformancePoint Services-Objekte.
Rufen Sie die zugrunde liegende Datenquelle des Filters aus dem Repository ab. Der Beispiel-Filter-Editor verwendet die FilterRepositoryHelper.DataSourceHelper-Eigenschaft zum Abrufen der DataSourceConsumerHelper.GetDataSource-Methode, mit der die Datenquelle anhand ihres Speicherorts im Repository abgerufen wird. Dies wird im folgenden Codebeispiel demonstriert.
if (!string.IsNullOrEmpty(filter.DataSourceLocation.ItemUrl)) { RepositoryLocation repositoryDatasourceLocation = RepositoryLocation.CreateFromUriString(filter.DataSourceLocation.ItemUrl); datasource = filterRepositoryHelper.DataSourceHelper.GetDataSource(repositoryDatasourceLocation); }Damit Benutzer auf eine Datenquelle für den Filter auswählen können, füllen Sie das Steuerelement zur Auswahl mit PerformancePoint-Dienste-Datenquellen. Die PopulateDataSourceDropDown -Methode im Filter-Editor Beispiel ruft die DataSourceConsumerHelper.GetDataSourcesBySourceNames -Methode zum Abrufen der Datenquellen. Dies ist im folgenden Codebeispiel dargestellt.
// The parameter contains the default server-relative URL to the PerformancePoint Data Connections Library. // Edit this value if you are not using the default path. A leading forward slash may not be needed. ICollection dataSourceCollection = filterRepositoryHelper.DataSourceHelper.GetDataSourcesBySourceNames ("/BICenter/Data%20Connections%20for%20PerformancePoint/", new[] { "WSTabularDataSource", DataSourceNames.ExcelWorkbook });Im Beispiel Filter-Editor werden nur zwei Arten von Datenquelle abgerufen, aber Sie können diese Methode zur Unterstützung von anderen Arten von Datenquellen oder den Benutzer für den Typ der Datenquelle abrufen abgefragt ändern. Um auf eine native Datenquelle eines bestimmten Typs zu verweisen, verwenden Sie die SourceName-Eigenschaft , die ein Feld aus der DataSourceNames-Klasse zurückgibt. Um eine benutzerdefinierte Datenquelle verweisen möchten, verwenden Sie die SubTypeId -Eigenschaft der Datenquelle, die den gleichen Wert wie das Attribut subType ist, die in der PerformancePoint-Dienste web.config-Datei für die datenquellenerweiterung registriert ist.
Wenn Sie diese Methode ändern, müssen Sie die entsprechende Änderung in der GetDisplayDataInternal-Methode im Datenanbieter des Beispielfilters vornehmen.
Definieren Sie den Filteranfangspunkt, der durch die BeginPoints-Eigenschaft dargestellt wird. Dies definiert die Quelle der Filterwerte und ist erforderlich, damit der Filter Daten an Scorecards und Berichte senden kann.
Erstellen Sie ein ParameterDefinition-Objekt . BeginPoints gibt ein ParameterDefinitionCollection -Objekt zurück, das nur ein ParameterDefinition -Objekt enthält.
Um den Datenanbieter des Filters anzugeben, legen Sie die ParameterProviderId-Eigenschaft auf den eindeutigen Bezeichner des Datenanbieters fest. Dieser Wert muss mit dem Wert übereinstimmen, der von der GetId() -Methode des Datenanbieters zurückgegeben wird.
Um die Quelle der Schlüsselbezeichner für die Filterwerte anzugeben, legen Sie die KeyColumn-Eigenschaft auf die Spalte in der Anzeigedatentabelle fest, die die Schlüsselbezeichner enthält. The sample filter editor defines this property as the "Symbol" column.
Um die Quelle der Anzeigewerte für das Filtersteuerelement anzugeben, legen Sie die DisplayColumn-Eigenschaft auf die Spalte in der Anzeigedatentabelle fest, die die Anzeigewerte enthält. The sample filter editor defines this property as the "Symbol" column.
Hinweis
Die Anzeigedatentabelle wird von der DisplayValues-Eigenschaft zurückgegeben und initialisiert, wenn der Filterdatenanbieter die GetDisplayDataInternal-Methode aufruft. Falls die Datentabelle andere Spalten enthält, können Sie andere Spaltenzuordnungen definieren, um zusätzliche Funktionalität anzubieten.
if (0 == filter.BeginPoints.Count) { ParameterDefinition paramDef = new ParameterDefinition(); // Reference the data provider. paramDef.ParameterProviderId = "SampleFilterDataProvider"; paramDef.DefaultPostFormula = string.Empty; // Specify the column that contains the key identifiers and the column // that contains the display values. The sample uses the same column // for both purposes. // These values must match the structure of the data table that is // returned by the ParameterDefinition.DisplayValues property. paramDef.KeyColumn = "Symbol"; paramDef.DisplayColumn = "Symbol"; // You can use this property to store custom information for this filter. paramDef.CustomDefinition = string.Empty; filter.BeginPoints.Add(paramDef); }Der Anfangspunkt für den Beispieleditor wird in der VerifyFilter-Methode definiert. Mithilfe von VerifyFilter wird außerdem überprüft, ob erforderliche Eigenschaften festgelegt sind, und der Auswahlmodus wird definiert, bei dem es sich um eine optionale Eigenschaft handelt.
Initialisieren Sie den Filter, indem Sie die Abfrage des Filters ausführen und Daten aus der Datenquelle abrufen. Mit der buttonOK_Click-Methode im Beispiel-Filter-Editor wird die FilterRepositoryHelper.GetParameterDisplayData-Methode zum Initialisieren des Filters aufgerufen.
Hinweis
Der Editor muss FilterRepositoryHelper.GetParameterDisplayData mindestens einmal aufrufen, bevor das Filterobjekt aktualisiert wird.
Aktualisieren Sie den Filter mit benutzerdefinierten Änderungen. Mit der buttonOK_Click-Methode im Beispiel-Filter-Editor wird die FilterRepositoryHelper.Update-Methode zum Aktualisieren der Eigenschaften Name , Description und DataSourceLocation des Filters im Repository aufgerufen. Darüber hinaus werden mit buttonOK_Click die Inhalte der Steuerelemente überprüft und Statusinformationen für den benutzerdefinierten Filter und das Hilfsobjekt abgerufen.
Hinweis
Benutzer können die Eigenschaften Name, Beschreibung und Besitzer (Verantwortliche Person) eines benutzerdefinierten Objekts festlegen und benutzerdefinierte Objekte direkt im Dashboard-Designer und im PerformancePoint-Dienste-Repository löschen.
Codebeispiel: Erstellen, Abrufen und Aktualisieren von benutzerdefinierten PerformancePoint-Dienste-Filtern in SharePoint
Im folgenden Codebeispiel wird erstellt, abgerufen und benutzerdefinierte Filter aktualisiert. Dieser Code hat ihren Ursprung im Editor CodeBehind-Klasse, die die Programmierlogik für Steuerelemente bereitstellt, die in einer ASPX-Seite definiert sind.
Bevor Sie dieses Codebeispiel kompilieren können, müssen Sie Ihre Entwicklungsumgebung wie unter Erstellen und Konfigurieren der Editorklasse für einen Filter-Editor in PerformancePoint-Dienste beschrieben konfigurieren.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Web.UI;
using System.Web.UI.WebControls;
using Microsoft.PerformancePoint.Scorecards;
using Microsoft.PerformancePoint.Scorecards.ServerCommon;
using Microsoft.PerformancePoint.Scorecards.ServerRendering;
namespace Microsoft.PerformancePoint.SDK.Samples.SampleFilter
{
// Represents the class that defines the sample filter editor.
public class SampleFilterEditor : Page
{
// Declare private variables for the ASP.NET controls defined in the user interface.
// The sample's user interface is an ASPX page that defines the controls in HTML.
private TextBox textboxName;
private TextBox textboxDescription;
private Label labelErrorMessage;
private DropDownList dropdownlistDataSource;
private Button buttonOK;
private ListBox listboxStocks;
// Make the controls available to this class.
protected override void CreateChildControls()
{
base.CreateChildControls();
if (null == textboxName)
textboxName = FindControl("textboxName") as TextBox;
if (null == textboxDescription)
textboxDescription = FindControl("textboxDescription") as TextBox;
if (null == dropdownlistDataSource)
dropdownlistDataSource = FindControl("dropdownlistDataSource") as DropDownList;
if (null == labelErrorMessage)
labelErrorMessage = FindControl("labelErrorMessage") as Label;
if (null==buttonOK)
buttonOK = FindControl("buttonOK") as Button;
if (null==listboxStocks)
listboxStocks = FindControl("listboxStocks") as ListBox;
}
// Handles the Load event of the Page control.
// Methods that use a control variable should call the Control.EnsureChildControls
// method before accessing the variable for the first time.
protected void Page_Load(object sender, EventArgs e)
{
// Required to enable custom report and filter editors to
// write data to the repository.
ServerUtils.AllowUnsafeUpdates = true;
// Initialize controls the first time the page loads only.
if (!IsPostBack)
{
EnsureChildControls();
FilterRepositoryHelper filterRepositoryHelper = null;
try
{
// Get information from the query string parameters.
string server = Request.QueryString[ClickOnceLaunchKeys.SiteCollectionUrl];
string itemLocation = Request.QueryString[ClickOnceLaunchKeys.ItemLocation];
string action = Request.QueryString[ClickOnceLaunchKeys.LaunchOperation];
// Validate the query string parameters.
if (string.IsNullOrEmpty(server) ||
string.IsNullOrEmpty(itemLocation) ||
string.IsNullOrEmpty(action))
{
displayError("Invalid URL.");
return;
}
// Retrieve the repository-helper object.
filterRepositoryHelper =
new FilterRepositoryHelper();
// Set the filter location.
RepositoryLocation repositoryFilterLocation = RepositoryLocation.CreateFromUriString(itemLocation);
Filter filter;
DataSource datasource = null;
// Retrieve or create the filter object, depending on the operation
// passed in the query string (OpenItem or CreateItem).
if (ClickOnceLaunchValues.OpenItem.Equals(action, StringComparison.OrdinalIgnoreCase))
{
// Retrieve the filter object by using the repository-helper object.
filter = filterRepositoryHelper.Get(repositoryFilterLocation);
if (filter == null)
{
displayError("Could not retrieve the filter for editing.");
return;
}
}
else if (ClickOnceLaunchValues.CreateItem.Equals(action, StringComparison.OrdinalIgnoreCase))
{
// Create a filter.
// CreateItem requests can be sent from a SharePoint list, but
// you must create a custom menu item to send the request.
// Dashboard Designer can send edit requests only.
filter = new Filter
{
// Specify the class that defines the renderer
// web server control. The sample filter uses a native
// PerformancePoint Services renderer.
// Defaults to the value specified in the web.config file
RendererClassName = typeof(MultiSelectTreeViewControl).AssemblyQualifiedName,
// Specify the unique identifier for the filter.
// The SubTypeId property must match the
// subType attribute in the web.config file.
SubTypeId = "SampleFilter"
};
}
else
{
displayError("Invalid Action.");
return;
}
VerifyFilter(filter);
// Retrieve filter's underlying data source.
if (!string.IsNullOrEmpty(filter.DataSourceLocation.ItemUrl))
{
RepositoryLocation repositoryDatasourceLocation =
RepositoryLocation.CreateFromUriString(filter.DataSourceLocation.ItemUrl);
datasource =
// Gets a PerformancePoint Services data source by using the
// DataSourceHelper property to call the
// DataSourceConsumerHelper.GetDataSource method.
filterRepositoryHelper.DataSourceHelper.GetDataSource(repositoryDatasourceLocation);
}
// Save the original filter and helper objects across page postbacks.
ViewState["action"] = action;
ViewState["filter"] = filter;
ViewState["filterrepositoryhelper"] = filterRepositoryHelper;
ViewState["itemlocation"] = itemLocation;
// Populate the child controls.
textboxName.Text = filter.Name.ToString();
textboxDescription.Text = filter.Description.ToString();
// Populate the dropdownlistDataSource control with data sources of specific
// types from the PerformancePoint Services repository.
// This method looks up the passed data source in the data sources
// that are registered in the web.config file.
// Although the sample retrieves data sources of two specific types,
// you can modify it to prompt the user for a data source type.
PopulateDataSourceDropDown(datasource);
// Call the SelectedIndexChanged event directly to populate the
// listbox control with preview data.
dropdownlistDataSource_SelectedIndexChanged(null, null);
}
catch (Exception ex)
{
displayError("An error has occurred. Please contact your administrator for more information.");
if (filterRepositoryHelper != null)
{
// Add the exception detail to the server event log.
filterRepositoryHelper.HandleException(ex);
}
}
}
}
// Handles the SelectedIndexChanged event of the dropdownlistDataSource control.
protected void dropdownlistDataSource_SelectedIndexChanged(object sender, EventArgs e)
{
EnsureChildControls();
// Check if a valid data source is selected.
if (null != dropdownlistDataSource.SelectedItem &&
!string.IsNullOrEmpty(dropdownlistDataSource.SelectedItem.Text))
{
// Retrieve the data source object.
FilterRepositoryHelper filterRepositoryHelper =
(FilterRepositoryHelper)ViewState["filterrepositoryhelper"];
string selectedDataSourceItemUrl = dropdownlistDataSource.SelectedItem.Value;
RepositoryLocation repositoryDatasourceLocation =
RepositoryLocation.CreateFromUriString(selectedDataSourceItemUrl);
DataSource datasource = filterRepositoryHelper.DataSourceHelper.GetDataSource(repositoryDatasourceLocation);
ViewState["datasource"] = datasource;
// Populate the listboxStocks control with the preview data for the selected
// data source.
PopulateListBoxData(datasource);
}
else
{
ClearStocksListBox();
}
}
// Clears the listboxStocks control.
// The sample filter works with a web service that provides stock information.
private void ClearStocksListBox()
{
listboxStocks.DataSource = null;
listboxStocks.DataBind();
listboxStocks.Items.Clear();
}
// Handles the Click event of the buttonOK control.
protected void buttonOK_Click(object sender, EventArgs e)
{
EnsureChildControls();
// Verify that the controls contain values.
if (string.IsNullOrEmpty(textboxName.Text))
{
labelErrorMessage.Text = "A filter name is required.";
return;
}
if (dropdownlistDataSource.SelectedIndex == 0)
{
labelErrorMessage.Text = "A data source is required.";
return;
}
// Clear any pre-existing error message.
labelErrorMessage.Text = string.Empty;
// Retrieve the filter, data source, and helper objects from view state.
string action = (string)ViewState["action"];
string itemLocation = (string) ViewState["itemlocation"];
Filter filter = (Filter)ViewState["filter"];
DataSource datasource = (DataSource)ViewState["datasource"];
FilterRepositoryHelper filterRepositoryHelper = (FilterRepositoryHelper)ViewState["filterrepositoryhelper"];
// Update the filter object with form changes.
filter.Name.Text = textboxName.Text;
filter.Description.Text = textboxDescription.Text;
filter.DataSourceLocation = datasource.Location;
foreach (ParameterDefinition parameterDefinition in filter.BeginPoints)
{
parameterDefinition.DisplayName = filter.Name.Text;
}
// Initialize the filter. This method runs the filter's query and retrieves preview data.
filterRepositoryHelper.GetParameterDisplayData(ref filter);
// Save the filter object to the PerformancePoint Services repository.
try
{
filter.Validate();
if (ClickOnceLaunchValues.CreateItem.Equals(action,StringComparison.OrdinalIgnoreCase))
{
Filter newFilter = filterRepositoryHelper.Create(
string.IsNullOrEmpty(filter.Location.ItemUrl) ? itemLocation : filter.Location.ItemUrl, filter);
ViewState["filter"] = newFilter;
ViewState["action"] = ClickOnceLaunchValues.OpenItem;
}
else
{
filterRepositoryHelper.Update(filter);
}
}
catch (Exception ex)
{
displayError("An error has occurred. Please contact your administrator for more information.");
if (filterRepositoryHelper != null)
{
// Add the exception detail to the server event log.
filterRepositoryHelper.HandleException(ex);
}
}
}
// Displays the error string in the labelErrorMessage label.
void displayError(string msg)
{
EnsureChildControls();
labelErrorMessage.Text = msg;
// Disable the OK button because the page is in an error state.
buttonOK.Enabled = false;
return;
}
// Verifies that the properties for the filter object are set.
static void VerifyFilter(Filter filter)
{
if (null != filter)
{
// Verify that all required properties are set.
if (string.IsNullOrEmpty(filter.SubTypeId))
{
// This value must match the subType attribute specified
// in the web.config file.
filter.SubTypeId = "SampleFilter";
}
if (string.IsNullOrEmpty(filter.RendererClassName))
{
filter.RendererClassName = typeof (MultiSelectTreeViewControl).AssemblyQualifiedName;
}
// Define the BeginPoints property so the filter can send a parameter value to
// scorecards and reports.
// The value must be from the KeyColumn of the display
// DataTable object, which is defined in the data provider. The data table is
// returned by the FilterRepositoryHelper.GetParameterDisplayData method.
// A filter has one beginpoint only, and it is represented by a
// ParameterDefinition object. The ParameterDefinition object defines how
// the filter accesses the data.
if (0 == filter.BeginPoints.Count)
{
ParameterDefinition paramDef = new ParameterDefinition
{
// This value must match the value returned
// by the data provider's GetId method.
ParameterProviderId = "SampleFilterDataProvider",
// Reference the data provider.
DefaultPostFormula = string.Empty,
// Specify the column that contains
// the key identifiers and the column
// that contains the display values.
// The sample uses the same column
// for both purposes.
// These values must match the structure
// of the data table that is returned
// by the ParameterDefinition.DisplayValues property.
KeyColumn = "Symbol",
DisplayColumn = "Symbol",
// You can use this property to store
// extra information for this filter.
CustomDefinition = string.Empty
};
filter.BeginPoints.Add(paramDef);
}
// Set optional properties. The renderer can return multiple values.
filter.SelectionMode = FilterSelectionMode.MultiSelect;
}
}
// Populates the dropdownlistDataSource control.
void PopulateDataSourceDropDown(DataSource filterDataSource)
{
EnsureChildControls();
FilterRepositoryHelper filterRepositoryHelper =
(FilterRepositoryHelper)ViewState["filterrepositoryhelper"];
// Retrieve data sources from the repository by using the DataSourceHelper
// property to call the DataSourceConsumerHelper object.
// If you modify the types of data source to retrieve, you must make the corresponding
// change in the filter's data provider.
// The parameter contains the default server-relative URL to the PerformancePoint Data Connections Library.
// Edit this value if you are not using the default path. A leading forward slash may not be needed.
ICollection dataSourceCollection = filterRepositoryHelper.DataSourceHelper.GetDataSourcesBySourceNames("/BICenter/Data%20Connections%20for%20PerformancePoint/",
new[] { "WSTabularDataSource", DataSourceNames.ExcelWorkbook });
if (null == dataSourceCollection)
{
displayError("No available data sources were found.");
return;
}
// Create a list of name/value pairs for the dropdownlistDataSource control.
var dataSources = new List<KeyValuePair<string, string>>();
int selectedIndex = 0;
int i = 1;
dataSources.Add(new KeyValuePair<string, string>(string.Empty, string.Empty));
foreach (DataSource ds in dataSourceCollection)
{
dataSources.Add(new KeyValuePair<string, string>(ds.Name.Text, ds.Location.ItemUrl));
// Check if the entry is the originally selected data source.
if ((filterDataSource != null) &&
(string.Compare(ds.Name.Text, filterDataSource.Name.Text) == 0))
{
selectedIndex = i;
}
++i;
}
dropdownlistDataSource.DataSource = dataSources;
dropdownlistDataSource.DataTextField = "Key";
dropdownlistDataSource.DataValueField = "Value";
dropdownlistDataSource.DataBind();
dropdownlistDataSource.SelectedIndex = selectedIndex;
}
// Populate the list box data.
void PopulateListBoxData(DataSource datasource)
{
EnsureChildControls();
ClearStocksListBox();
FilterRepositoryHelper filterRepositoryHelper =
(FilterRepositoryHelper)ViewState["filterrepositoryhelper"];
// Retrieve the first 100 rows of the preview data from the data source
DataSet dataSet = filterRepositoryHelper.DataSourceHelper.GetDataSet(100, datasource);
if (null != dataSet && null != dataSet.Tables[0])
{
listboxStocks.DataTextField = "Symbol";
listboxStocks.DataValueField = "Value";
listboxStocks.DataSource = dataSet.Tables[0];
listboxStocks.DataBind();
}
}
}
}
Nächste Schritte
Nachdem Sie einen Filter-Editor (einschließlich seiner Benutzeroberfläche, falls erforderlich) und einen Datenanbieter erstellt haben, stellen Sie die Erweiterung wie unter Vorgehensweise: Manuelles Registrieren von PerformancePoint-Dienste-Erweiterungen beschrieben bereit.