IPersonalizable.Save(PersonalizationDictionary) Método

Definición

Espacio de nombres:

System.Web.UI.WebControls.WebParts

Ensamblado:

System.Web.dll

Guarda propiedades personalizadas e información del estado interno en el objeto PersonalizationDictionary del control.

C#

public void Save (System.Web.UI.WebControls.WebParts.PersonalizationDictionary state);

Parámetros

state

PersonalizationDictionary

PersonalizationDictionary que contiene datos con ámbito personalizados cargados desde el almacén de datos subyacente.

Ejemplos

En el ejemplo de código siguiente se muestra cómo implementar el Save método en un control personalizado WebPart . Para obtener el código completo necesario para ejecutar este ejemplo, consulte la sección Ejemplo de la información general de la IPersonalizable clase.

C#

namespace Samples.AspNet.CS.Controls
{

    using System;
    using System.Collections;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Drawing;
    using System.Web;
    using System.Web.UI;
    using System.Security.Permissions;
    using System.Web.UI.WebControls;
    using System.Web.UI.WebControls.WebParts;

    [AspNetHostingPermission(SecurityAction.Demand,
      Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand,
      Level = AspNetHostingPermissionLevel.Minimal)]
    public class UrlListWebPart : WebPart, IPersonalizable
    {
        private ArrayList _sharedUrls;
        private ArrayList _userUrls;
        private bool _listDirty;

        private TextBox _nameTextBox;
        private TextBox _urlTextBox;
        private Button _addButton;
        private BulletedList _list;

        protected override void CreateChildControls()
        {
            Label nameLabel = new Label();
            Label urlLabel = new Label();
            LiteralControl breakLiteral1 = new LiteralControl("<br />");
            LiteralControl breakLiteral2 = new LiteralControl("<br />");
            LiteralControl breakLiteral3 = new LiteralControl("<br />");

            _nameTextBox = new TextBox();
            _urlTextBox = new TextBox();
            _addButton = new Button();
            _list = new BulletedList();

            nameLabel.Text = "Name: ";
            urlLabel.Text = "URL: ";
            _nameTextBox.ID = "nameTextBox";
            _urlTextBox.ID = "urlTextBox";
            _addButton.Text = "Add";
            _addButton.ID = "addButton";
            _addButton.Click += new EventHandler(this.OnClickAddButton);
            _list.DisplayMode = BulletedListDisplayMode.HyperLink;
            _list.ID = "list";

            Controls.Add(nameLabel);
            Controls.Add(_nameTextBox);
            Controls.Add(breakLiteral1);

            Controls.Add(urlLabel);
            Controls.Add(_urlTextBox);
            Controls.Add(breakLiteral2);

            Controls.Add(_addButton);
            Controls.Add(breakLiteral3);

            Controls.Add(_list);
        }

        private void OnClickAddButton(object sender, EventArgs e)
        {
            string name = _nameTextBox.Text.Trim();
            string url = _urlTextBox.Text.Trim();

            Pair p = new Pair(name, url);
            if (WebPartManager.Personalization.Scope == PersonalizationScope.Shared)
            {
                _sharedUrls ??= new ArrayList();
                _sharedUrls.Add(p);
            }
            else
            {
                _userUrls ??= new ArrayList();
                _userUrls.Add(p);
            }

            OnUrlAdded();
        }

        protected virtual void OnUrlAdded()
        {
            _listDirty = true;
            ChildControlsCreated = false;
        }

        protected override void RenderContents(HtmlTextWriter writer)
        {
            if (_sharedUrls != null)
            {
                foreach (Pair p in _sharedUrls)
                {
                    _list.Items.Add(new ListItem((string)p.First, (string)p.Second));
                }
            }
            if (_userUrls != null)
            {
                foreach (Pair p in _userUrls)
                {
                    _list.Items.Add(new ListItem((string)p.First, (string)p.Second));
                }
            }

            base.RenderContents(writer);
        }

        public virtual bool IsDirty
        {
            get
            {
                return _listDirty;
            }
        }
        public new virtual void Load(PersonalizationDictionary state)
        {
            if (state != null)
            {
                PersonalizationEntry sharedUrlsEntry = state["sharedUrls"];
                if (sharedUrlsEntry != null)
                {
                    _sharedUrls = (ArrayList)sharedUrlsEntry.Value;
                }

                PersonalizationEntry userUrlsEntry = state["userUrls"];
                if (userUrlsEntry != null)
                {
                    _userUrls = (ArrayList)userUrlsEntry.Value;
                }
            }
        }

        public virtual void Save(PersonalizationDictionary state)
        {
            if ((_sharedUrls != null) && (_sharedUrls.Count != 0))
            {
                state["sharedUrls"] = new PersonalizationEntry(_sharedUrls, PersonalizationScope.Shared);
            }
            if ((_userUrls != null) && (_userUrls.Count != 0))
            {
                state["userUrls"] = new PersonalizationEntry(_userUrls, PersonalizationScope.User);
            }
        }
    }
}

Comentarios

Un control de servidor puede almacenar sus propias propiedades personalizadas e información de estado interna especificada PersonalizationDictionary en el state parámetro . La información se almacena como una serie de pares nombre-valor. Es responsabilidad del control usar pares nombre-valor que puede reconocer durante las llamadas posteriores realizadas al control a través del Load método .

Un control puede hacer referencia a su control asociado WebPartManager y comprobar el PersonalizationScope objeto para determinar el ámbito actual. La información de estado personalizada debe ser adecuada para el ámbito actual. Tenga en cuenta que cada PersonalizationEntry valor que se agrega al PersonalizationDictionary objeto debe asociarse con el valor de ámbito adecuado, ya que la infraestructura de personalización depende de esto al combinar Shared y User-scoped datos personalizados antes de pasarlos al Load método .

Al usar la implementación estándar de ASP.NET de elementos web, los controles deben asegurarse de que los objetos colocados en el diccionario de estados se puedan serializar mediante la clase ASP.NETObjectStateFormatter. En la práctica, esto significa lo siguiente:

• Los tipos de .NET Framework primitivos, las cadenas y los tipos de .NET Framework orientados a colecciones, como matrices, listas de matrices, tablas hash y diccionarios híbridos, se serializable automáticamente.

• Los tipos personalizados que proporcionan sus propias TypeConverter clases capaces de serializar y deserializar a partir de cadenas se consideran serializables.

• Los tipos personalizados que la clase puede serializar BinaryFormatter se consideran serializables.

Importante

No debe agregar tipos basados en las clases definidas en el directorio App_Code y, a continuación, depender del mecanismo de serialización binaria predeterminado. los artefactos basados en App_Code no son serializables de forma binaria de forma coherente debido al hecho de que pueden cambiar sus nombres de ensamblado en momentos aleatorios.

Se aplica a