Crear proveedores de datos de filtro para PerformancePoint Services en SharePoint
Aprenda a crear el componente de proveedor de datos en una extensión de filtro personalizada para PerformancePoint Services.
¿Qué es un proveedor de datos personalizado en PerformancePoint Services?
En PerformancePoint Services, los proveedores de datos personalizados recuperan datos del origen de datos subyacente de un filtro y definen cómo usar los datos. Lo más importante es que los proveedores de datos especifican los valores de datos que se van a exponer en el control de filtro y los datos que se pueden usar como punto de partida del filtro. Un proveedor de datos también almacena el valor que un usuario selecciona del control de filtro, que luego se envía a los consumidores de filtro. Los proveedores de datos usan dos objetos DataTable para organizar y almacenar datos. Para obtener más información, vea Información general sobre filtros.
Los siguientes procedimientos y ejemplos, donde se indica cómo crear, configurar y definir un proveedor de datos de filtro, se basan en la clase SampleFilterDataProvider del ejemplo de objetos personalizados. El editor es una aplicación web ligera con la que los usuarios pueden modificar el nombre y la descripción del informe. Para obtener el código completo de la clase, vea Ejemplo de código: Creación de un proveedor de datos para filtros de PerformancePoint Services personalizados en SharePoint.
Se recomienda usar el proveedor de datos de ejemplo como una plantilla. La muestra indica cómo llamar a los objetos de la API de PerformancePoint Services así como los procedimientos recomendados para desarrollar con PerformancePoint Services.
Crear proveedores de datos para filtros de PerformancePoint Services personalizados
Instale PerformancePoint Services o copie los DLL que la extensión usa (enumerados en el paso 3) en el equipo. Para obtener más información, vea ARCHIVOS DLL con bibliotecas de clases.
En Visual Studio, cree una biblioteca de clases de C#. Si ya ha creado una biblioteca de clases para su extensión, agregue una nueva clase de C#.
Debe firmar su DLL con un nombre seguro. Además, asegúrese de que todos los ensamblados a los que su DLL hace referencia tengan nombres seguros. Para obtener información sobre cómo firmar un ensamblado con un nombre seguro y cómo crear un par de claves pública y privada, vea How to: Create a Public/Private Key Pair.
Agregue los siguientes archivos DLL de PerformancePoint Services como referencias de ensamblado al proyecto:
- Microsoft.PerformancePoint.Scorecards.Client.dll
- Microsoft.PerformancePoint.Scorecards.Server.dll
Según cuál sea la funcionalidad de la extensión, es posible que se necesiten más referencias de proyecto.
En su clase de proveedor, agregue directivas using para los siguientes espacios de nombres de PerformancePoint Services:
Según cuál sea la funcionalidad de la extensión, es posible que se necesiten más directivas using.
Hereda de la clase base CustomParameterDataProvider .
Defina el identificador de cadena del nombre del proveedor de datos. Debe coincidir con la clave que se agregue a la sección CustomParameterDataProviders del archivo web.config al registrar la extensión. Para obtener más información, consulte Procedimiento para registrar manualmente las extensiones de PerformancePoint Services.
Invalide el método GetId() para devolver el identificador del proveedor de datos.
Invalide el método GetDisplayDataInternal para definir un objeto DataTable para almacenar los valores de datos del origen de datos subyacente. El filtro usa este método para rellenar el control de selección de filtro. La tabla de datos debe contener los siguientes nombres de columna:
Key Identificador único del registro. Este valor no puede ser NULL. Por motivos de rendimiento y seguridad, los controles emiten únicamente una clave, y no valores para las otras columnas.
Display Valor que aparece en el control del filtro.
ParentKey Este valor sirve para disponer los datos jerárquicos en un control de árbol.
IsDefault Este valor se usa para la persistencia del filtro.
Sugerencia
[!SUGERENCIA] SE pueden agregar más columnas para ampliar la funcionalidad del filtro.
GetDisplayDataInternal llama al método DataSourceRegistry.GetDataSource(DataSource) para comprobar el tipo de origen de datos por nombre, así:
- Hace referencia a un tipo de origen de datos personalizado mediante la propiedad SubTypeId del origen de datos, que es el mismo valor que el atributo subType registrado en el archivo PerformancePoint Services web.config para la extensión del origen de datos.
- Hace referencia a un origen de datos nativo mediante la propiedad SourceName , que devuelve un campo de la clase DataSourceNames .
Invalide el método GetMessageData para almacenar la selección del usuario del control de filtro. El filtro usa este método cuando envía las selecciones del usuario a los consumidores.
Ejemplo de código: Creación de un proveedor de datos para filtros de PerformancePoint Services personalizados en SharePoint
En el ejemplo de código siguiente se muestra cómo un proveedor de datos recupera valores de un servicio web o una hoja de cálculo de Excel y devuelve objetos DataTable para los datos de visualización y los datos de mensaje del filtro.
Para poder compilar este ejemplo de código se debe configurar el entorno de desarrollo del modo descrito en Para crear y configurar la clase del proveedor.
using System.Data;
using Microsoft.PerformancePoint.Scorecards;
using Microsoft.PerformancePoint.Scorecards.Server.Extensions;
namespace Microsoft.PerformancePoint.SDK.Samples.SampleFilter
{
// Represents the sample filter's data provider.
public class SampleFilterDataProvider : CustomParameterDataProvider
{
// This value must match the key that you register for this extension
// in the CustomParameterDataProviders section in the web.config file.
private const string dataProviderName = "SampleFilterDataProvider";
// Returns a table of all possible values (rows) for the
// filter's beginpoints. The filter's BeginPoint property returns
// one ParameterDefinition object.
protected override DataTable GetDisplayDataInternal(ParameterDefinition parameterDefinition, RepositoryLocation parameterSourceLocation, object custom)
{
DataTable retrievedData = null;
// Get the data source.
DataSource parameterDataSource = SafeGetDataSource(parameterSourceLocation);
if (null != parameterDataSource)
{
// Verify that the data source is the sample data source
// or an Excel workbook, which are the types that the
// sample supports.
// If you modify these types of data source, you must make
// the corresponding change in the filter's editor.
if (parameterDataSource.SourceName == "WSTabularDataSource" || parameterDataSource.SourceName == DataSourceNames.ExcelWorkbook)
{
IDataSourceProvider parameterDataSourceProvider =
DataSourceRegistry.GetDataSource(parameterDataSource);
if (null != parameterDataSourceProvider)
{
var dataSourceMetadata = parameterDataSourceProvider as IDataSourceMetadata;
if (null != dataSourceMetadata)
{
// Get the data and store it in the retrievedDataSet
// variable. The -1 parameter returns all records
// from the data source.
DataSet retrievedDataSet = dataSourceMetadata.GetPreviewDataSet(-1);
// Verify that the dataset contains data.
if (retrievedDataSet != null &&
retrievedDataSet.Tables != null &&
retrievedDataSet.Tables.Count > 0 &&
retrievedDataSet.Tables[0] != null &&
retrievedDataSet.Tables[0].Columns != null &&
retrievedDataSet.Tables[0].Columns.Count > 0 &&
retrievedDataSet.Tables[0].Rows != null &&
retrievedDataSet.Tables[0].Rows.Count > 0 &&
retrievedDataSet.Tables[0].Columns.Contains(parameterDefinition.KeyColumn))
{
retrievedData = retrievedDataSet.Tables[0];
}
}
}
}
if (null != retrievedData)
{
// Name the display data table.
retrievedData.TableName = "ParamData";
// Verify that the table has the correct structure.
EnsureDataColumns(retrievedData, parameterDefinition);
bool firstRowSeen = false;
foreach (DataRow row in retrievedData.Rows)
{
// Set the ParentKeyColumn to null because the data
// does not have a hierarchical structure.
row[parameterDefinition.ParentKeyColumn] = null;
// Set the IsDefaultColumn column in the first row to true.
row[parameterDefinition.IsDefaultColumn] = !firstRowSeen;
if (!firstRowSeen)
{
firstRowSeen = true;
}
}
// Set the column visibility.
SetColumnVisibility(retrievedData);
}
}
return retrievedData;
}
// Adds the ShowColumn extended property to a column in the display data table
// and sets it to true. This exposes the column in Dashboard Designer as
// a source value for the beginpoint.
private static void SetColumnVisibility(DataTable displayData)
{
for (int i = 0; i < displayData.Columns.Count; i++)
{
if (!displayData.Columns[i].ExtendedProperties.Contains("ShowColumn"))
{
displayData.Columns[i].ExtendedProperties.Add("ShowColumn", true);
}
}
}
// Verify that all required columns are in the data table.
// The data table returned by this method is expected to contain a
// Key, ParentKey, IsDefault, Display, and an arbitrary number of
// Value columns.
// The specific column names (except for Value columns) are defined
// in the filter's ParameterDefinition object, which is referenced by
// the filter's BeginPoint property.
private static void EnsureDataColumns(DataTable dataTable, ParameterDefinition parameterDefinition)
{
if (!string.IsNullOrEmpty(parameterDefinition.KeyColumn) && !dataTable.Columns.Contains(parameterDefinition.KeyColumn))
{
dataTable.Columns.Add(parameterDefinition.KeyColumn);
}
if (!string.IsNullOrEmpty(parameterDefinition.DisplayColumn) && !dataTable.Columns.Contains(parameterDefinition.DisplayColumn))
{
dataTable.Columns.Add(parameterDefinition.DisplayColumn);
}
if (!string.IsNullOrEmpty(parameterDefinition.ParentKeyColumn) && !dataTable.Columns.Contains(parameterDefinition.ParentKeyColumn))
{
dataTable.Columns.Add(parameterDefinition.ParentKeyColumn);
}
if (!string.IsNullOrEmpty(parameterDefinition.IsDefaultColumn) && !dataTable.Columns.Contains(parameterDefinition.IsDefaultColumn))
{
dataTable.Columns.Add(parameterDefinition.IsDefaultColumn, typeof(bool));
}
}
// Returns the unique string identifier of the data provider.
// This value must match the key that you register for this extension
// in the CustomParameterDataProviders section in the web.config file.
public override string GetId()
{
return dataProviderName;
}
// Returns a table of rows that match the keys in the passed
// ParameterMessage object.
// This method is used by controls that accept parameters, such as
// scorecard and reports. It can also apply a Post Formula.
public override DataTable GetMessageData(RepositoryLocation providerLocation, ParameterMessage parameterMessage, RepositoryLocation parameterSourceLocation, ParameterMapping parameterMapping, object custom)
{
DataTable msgTable = null;
// The ParameterMapping object contains information about
// linked dashboard items.
// The CustomData object is optionally used to store information
// that is not stored in other properties.
DataTable displayTable = GetDisplayDataInternal(parameterMessage, parameterSourceLocation, custom);
if (null != displayTable)
{
msgTable = displayTable.Clone();
for (int i = 0;i < parameterMessage.Values.Rows.Count; i++)
{
for (int j = 0;j < displayTable.Rows.Count; j++)
{
if (!parameterMessage.Values.Rows[i][parameterMessage.KeyColumn].Equals(displayTable.Rows[j][parameterMessage.KeyColumn].ToString()))
continue;
msgTable.ImportRow(displayTable.Rows[j]);
break;
}
}
}
return msgTable;
}
}
}
Pasos siguientes
Después de crear un proveedor de datos y un editor de filtros (incluida su interfaz de usuario, si es necesario), implemente la extensión como se describe en How to: Manually Register PerformancePoint Services Extensions.