Clase MetadataNavigationSettings

Artículo
03/15/2016

Configura los valores de configuración en un objeto MetadataNavigationItem en un control del objeto SPList la visualización de jerarquías de metadatos y filtros en vistas de lista.

Jerarquía de la herencia

System.Object
Microsoft.Office.DocumentManagement.MetadataNavigation.MetadataNavigationSettings

Espacio de nombres: Microsoft.Office.DocumentManagement.MetadataNavigation
Ensamblado: Microsoft.Office.DocumentManagement (en Microsoft.Office.DocumentManagement.dll)

Sintaxis

'Declaración
Public Class MetadataNavigationSettings
'Uso
Dim instance As MetadataNavigationSettings

public class MetadataNavigationSettings

Comentarios

Obtiene la configuración de y conjuntos de configuración a un objeto SPList y persiste ellos tal que la lista, árbol de jerarquía de sitios y los controles de filtro pueden usarlas en la página de vista de lista de la interfaz de usuario. Use siempre el método estático [GetMetadataNavigationSettings] para obtener la configuración de un objeto SPList al inicializar nuevas instancias del objeto MetadataNavigationSettings .

De forma predeterminada, todas las listas tienen donde no hay filtros clave configurados y se configura sólo el tipo de la jerarquía de carpeta especial, que muestra sólo el objeto SPFolder en el árbol de configuración. Utilice estos métodos para modificar la jerarquía de metadatos y datos de filtros clave en el árbol.

Método	Acción
método [AddConfiguredHierarchy] para agregar filtros clave y jerarquías de metadatos adicionales a la configuración.	Agrega las jerarquías de metadatos a la configuración.
[AddConfigureKeyFilter]	Agrega fliters clave a la configuración.
[FindConfiguredHierarchy]	Determina si configurado jerarquías existen en la configuración. Use el resultado en la configuración original en lugar de crear una nueva jerarquía para garantizar que se conserve la configuración de vista interna. Después de ajustar el objeto MetadataNavigationSettings recupera originalmente en la lista, establezca la configuración ajustada de copia en la lista con el objeto SetMetadataNavigationSettings() .
[FindConfiguredKeyFilter]	Determina si configurado existen elementos en la configuración.
[ClearConfiguredHierarchies]	Vacía la configuración y, a continuación, agregan nuevas jerarquías en el orden deseado.
[ClearConfiguredKeyFilters]	Vacía la configuración y, a continuación, agrega filtros clave en el orden deseado.

Ejemplos

using SPWeb = Microsoft.SharePoint.SPWeb;
using SPList = Microsoft.SharePoint.SPList;
using SPField = Microsoft.SharePoint.SPField;

using MetadataNavigationSettings = Microsoft.Office.DocumentManagement.MetadataNavigation.MetadataNavigationSettings;
using MetadataNavigationHierarchy = Microsoft.Office.DocumentManagement.MetadataNavigation.MetadataNavigationHierarchy;
using MetadataNavigationKeyFilter = Microsoft.Office.DocumentManagement.MetadataNavigation.MetadataNavigationKeyFilter;
using MetadataNavigationContext = Microsoft.Office.DocumentManagement.MetadataNavigation.MetadataNavigationContext;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class MetadataNavigationSettingsSamples
    {
        public static void AddFieldsToMDNSettings(SPList list)
        {
            // TODO: Replace these variable values and input parameters with your own values.
            //
            // internal name of the SPField to add into the key filters
            string fieldNameKeyFilterToAdd = "Modified";

            // Validate the input parameters.
            //
            if (null == list)
            {
                throw new System.ArgumentNullException("list");
            }

            // Get the MDN settings object for the SPList that was passed in.
            //
            MetadataNavigationSettings mdnSettings =
                MetadataNavigationSettings.GetMetadataNavigationSettings(list);

            // Add hiearchies into the settings if they are not already there
            //
            MetadataNavigationHierarchy folderHierarchyToAdd =
                MetadataNavigationHierarchy.CreateFolderHierarchy();
            if (null == mdnSettings.FindConfiguredHierarchy(folderHierarchyToAdd.FieldId))
            {
                mdnSettings.AddConfiguredHierarchy(folderHierarchyToAdd);
            }

            MetadataNavigationHierarchy contentTypeHierarchyToAdd =
                MetadataNavigationHierarchy.CreateContentTypeHierarchy();
            if (null == mdnSettings.FindConfiguredHierarchy(contentTypeHierarchyToAdd.FieldId))
            {
                mdnSettings.AddConfiguredHierarchy(contentTypeHierarchyToAdd);
            }

            // Add key filters into the settings if they are not already there
            //
            SPField newKeyFilterField = list.Fields[fieldNameKeyFilterToAdd];
            if (null == mdnSettings.FindConfiguredKeyFilter(newKeyFilterField.Id))
            {
                mdnSettings.AddConfiguredKeyFilter(new MetadataNavigationKeyFilter(newKeyFilterField));
            }

            MetadataNavigationKeyFilter contentTypeKeyFilter =
                MetadataNavigationKeyFilter.CreateContentTypeKeyFilter();
            if (null == mdnSettings.FindConfiguredKeyFilter(contentTypeKeyFilter.FieldId))
            {
                mdnSettings.AddConfiguredKeyFilter(contentTypeKeyFilter);
            }

            // Set the MDN settings back into the list and automatically adjust indexing.
            //
            MetadataNavigationSettings.SetMetadataNavigationSettings(list, mdnSettings, true);
        }
    }
}

namespace Microsoft.SDK.SharePointServer.Samples.WebControls
{

    public static class MetadataNavigationSettingsWebSamples
    {
        public static void ToggleMDNSettingsStateInWebRequest(SPWeb web, System.Guid listId)
        {
            // Validate the input parameters.
            //
            if (null == web)
            {
                throw new System.ArgumentNullException("web");
            }

            // Ensure that there is a current context for these operations
            //
            if (null == MetadataNavigationContext.Current)
            {
                throw new System.InvalidOperationException("No current web context or MetadataNavigationContext");
            }

            // Get the MDN settings for the input web and list id using the cache
            //
            System.Guid listIdToUse = listId;
            MetadataNavigationSettings mdnSettings =
                MetadataNavigationSettings.GetMetadataNavigationSettings(web, listId);

            // If no settings were retrieved then try the current context settings.
            //
            if (null == mdnSettings)
            {
                mdnSettings = MetadataNavigationSettings.Current;
            }

            if (null == mdnSettings)
            {
                throw new System.ArgumentException("Cannot retrieve setting from inputs or from current context");
            }

            if(System.Guid.Empty != MetadataNavigationContext.Current.ListId)
            {
                listIdToUse = MetadataNavigationContext.Current.ListId;
            }

            if (mdnSettings.IsEnabled)
            {
                // If the current settings are enabled then clear them back to default (which is only folder hierarchy)
                mdnSettings.ClearConfiguredHierarchies();
                mdnSettings.ClearConfiguredKeyFilters();
                mdnSettings.AddConfiguredHierarchy(MetadataNavigationHierarchy.CreateFolderHierarchy());
            }
            else
            {
                // If they are not enabled then add a content type key filter and hierachy
                mdnSettings.AddConfiguredHierarchy(MetadataNavigationHierarchy.CreateContentTypeHierarchy());
                mdnSettings.AddConfiguredKeyFilter(MetadataNavigationKeyFilter.CreateContentTypeKeyFilter());
            }

            // Set the MDN settings back into the list.
            //
            SPList list = web.Lists[listIdToUse];
            MetadataNavigationSettings.SetMetadataNavigationSettings(list, mdnSettings);
        }

    }
}

Seguridad para subprocesos

Los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para subprocesos. No se garantiza que los miembros de instancias sean seguros para los subprocesos.