Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase DesignerTransaction

 

Permite agrupar una serie de acciones en tiempo de diseño para mejorar el rendimiento y habilitar la posibilidad de deshacer la mayoría de los tipos de cambio.

Espacio de nombres:   System.ComponentModel.Design
Ensamblado:  System (en System.dll)

System.Object
  System.ComponentModel.Design.DesignerTransaction

[HostProtectionAttribute(SecurityAction.LinkDemand, SharedState = true)]
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
public abstract class DesignerTransaction : IDisposable

NombreDescripción
System_CAPS_protmethodDesignerTransaction()

Inicializa una nueva instancia de la clase DesignerTransaction sin ninguna descripción.

System_CAPS_protmethodDesignerTransaction(String)

Inicializa una nueva instancia de la clase DesignerTransaction utilizando la descripción de transacción especificada.

NombreDescripción
System_CAPS_pubpropertyCanceled

Obtiene un valor que indica si se canceló la transacción.

System_CAPS_pubpropertyCommitted

Obtiene un valor que indica si se confirmó la transacción.

System_CAPS_pubpropertyDescription

Obtiene una descripción para la transacción.

NombreDescripción
System_CAPS_pubmethodCancel()

Cancela la transacción e intenta deshacer los cambios realizados por los eventos de la transacción.

System_CAPS_pubmethodCommit()

Confirma la transacción.

System_CAPS_protmethodDispose(Boolean)

Libera los recursos no administrados que usa DesignerTransaction y libera los recursos administrados de forma opcional.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Libera los recursos asociados a este objeto. Este reemplazo confirma esta transacción si aún no se había confirmado.(Invalida Object.Finalize()).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_protmethodOnCancel()

Genera el evento Cancel.

System_CAPS_protmethodOnCommit()

Realiza el trabajo real de confirmación de una transacción.

System_CAPS_pubmethodToString()

Retorna una cadena que representa al objeto actual. (Heredado de Object).

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethodIDisposable.Dispose()

Libera todos los recursos usados por DesignerTransaction.

Las transacciones pueden realizar un seguimiento de las acciones que se pueden deshacer posteriormente. Los cambios realizados durante una transacción se pueden deshacer cancelar una transacción, que intenta automáticamente deshacer cada cambio estableciendo cada propiedad que ha cambiado a su valor anterior al cambio. Las transacciones también pueden mejorar el rendimiento durante una serie de operaciones aplazando las actualizaciones de la pantalla hasta la finalización de la transacción.

Cuando una transacción está en curso, algunos componentes aplazan su procesamiento hasta que finalice la transacción escuchando el TransactionOpening y TransactionClosed eventos. La ventana Propiedades, por ejemplo, no actualice su presentación después de abrirse una transacción hasta que la transacción se ha cerrado.

Para usar transacciones reversibles o en varias operaciones, haga que el diseñador crea un DesignerTransaction para cada operación o serie de operaciones que deben ser reversibles. Tenga cuidado de no realizar acciones fuera de las transacciones que podrían impedir que se complete correctamente una secuencia de eventos de deshacer.

Puede obtener un nuevo DesignerTransaction llamando el CreateTransaction método de una IDesignerHost. Asegúrese de obtener cada DesignerTransaction de activos IDesignerHost para integrarse correctamente en la transacción del diseñador mecanismo de procesamiento, en lugar de crear un nuevo DesignerTransaction directamente.

Para realizar una acción en una transacción, primero debe crear una transacción. Se debe llamar el OnComponentChanging método antes de que se produce cada cambio o un conjunto de cambios y el OnComponentChanged método después de cada cambio o un conjunto de cambios se producen. Por último, complete y cierre la transacción llamando a la Commit (método).

System_CAPS_noteNota

Al realizar cambios en los valores de propiedad, utilice la SetValue método de un PropertyDescriptor, que llama a los métodos de cambio de componente de la IComponentChangeService y crea un DesignerTransaction que representa el cambio automáticamente.

Para realizar una transacción, complete los pasos siguientes:

  1. Llame a CreateTransaction para obtener un DesignerTransaction que se puede utilizar para controlar la transacción.

  2. Dentro de un try bloque para cada acción que desee realizar un seguimiento con un DesignerTransaction, llame a la OnComponentChanging método, haga los cambios, a continuación, llame el OnComponentChanged método para indicar que ha realizado el cambio o cambios.

  3. Para completar la transacción, llame a Commit desde un finally bloque.

En C#, puede utilizar el using instrucción en lugar de un try/finally Bloquear, como se muestra en el ejemplo siguiente.

using (host.CreateTransaction() {
// Insert your code here.
}

Para cancelar e intenta deshacer una transacción antes de que se ha confirmado, llame a la Cancel (método). Cuando el Cancel se invoca el método, hace un seguimiento de las acciones mediante el DesignerTransaction se deshacen para intentar deshacer los cambios. Para deshacer las acciones que se ha producido como parte de transacciones anteriores, debe utilizar el comando Deshacer proporcionado por el entorno de desarrollo.

El siguiente código de ejemplo de programa muestra cómo crear un DesignerTransaction desde un diseñador. Para ejecutar este ejemplo, compile el código fuente en una biblioteca de clases. Debe agregar una referencia al ensamblado System.Design. En un nuevo proyecto, agregue una referencia a la DLL compilada y agregue el componente de la biblioteca a la herramientas.

Hay una amplia compatibilidad para esta característica en Visual Studio.

Also see Walkthrough: Automatically Populating the Toolbox with Custom Components.

El diseñador opcionalmente puede mostrar notificaciones sobre eventos de transacción del diseñador. Si agrega una instancia de la DTComponent a un formulario en modo de diseño, aparecerá un mensaje preguntándole si desea recibir notificaciones de eventos de transacción del diseñador. Activar o desactivar estas notificaciones mediante el menú contextual que aparece cuando hace clic en una instancia de la DTComponent. Las transacciones se crean cuando se cambian los valores mediante la ventana Propiedades. También puede hacer que el diseñador realice una transacción haciendo clic en realizar transacciones de ejemplo en el menú contextual para el componente.

using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;

/*
    This sample demonstrates how to perform a series of actions in a designer 
    transaction, how to change values of properties of a component from a 
    designer, and how to complete transactions without being interrupted 
    by other activities.

    To run this sample, add this code to a class library project and compile. 
    Create a new Windows Forms project or load a form in the designer. Add a 
    reference to the class library that was compiled in the first step.
    Right-click the Toolbox in design mode and click Customize Toolbox.  
    Browse to the class library that was compiled in the first step and 
    select OK until the DTComponent item appears in the Toolbox.  Add an 
    instance of this component to the form.  

    When the component is created and added to the component tray for your
    design project, the Initialize method of the designer is called. 
    This method displays a message box informing you that designer transaction
    event handlers will be registered unless you click Cancel. When you set 
    properties in the properties window, each change will be encapsulated in 
    a designer transaction, allowing the change to be undone later.  

    When you right-click the component,	the shortcut menu for the component 
    is displayed. The designer constructs this menu according to whether 
    designer transaction notifications are enabled, and offers the option
    of enabling or disabling the notifications, depending on the current 
    mode. The shortcut menu also presents a Perform Example Transaction 
    item, which will set the values of the component's StringProperty and 
    CountProperty properties. You can undo the last designer transaction using 
    the Undo command provided by the Visual Studio development environment.
*/

namespace DesignerTransactionSample
{
    // Associate the DTDesigner with this component
    [DesignerAttribute(typeof(DTDesigner))]
    public class DTComponent : System.ComponentModel.Component
    {
    	private string m_String;
	private int m_Count;

	public string StringProperty
	{
	    get
            { return m_String; }
	    set
	    { m_String = value; }
	}

	public int CountProperty
	{
	    get
	    { return m_Count; }
	    set
	    { m_Count = value; }
	}

	private void InitializeComponent()
	{
	    m_String = "Initial Value";
	    m_Count = 0;
	}
    }

    internal class DTDesigner : ComponentDesigner
    {
	private bool notification_mode = false;
	private int count = 10;

	// The Verbs property is overridden from ComponentDesigner
	public override DesignerVerbCollection Verbs
	{
	    get
	    {				
	        DesignerVerbCollection dvc = new DesignerVerbCollection();				
		dvc.Add( new DesignerVerb("Perform Example Transaction", new EventHandler(this.DoTransaction)) );
		if(notification_mode)
		    dvc.Add(new DesignerVerb("End Designer Transaction Notifications", new EventHandler(this.UnlinkDTNotifications)));
		else
		    dvc.Add(new DesignerVerb("Show Designer Transaction Notifications", new EventHandler(this.LinkDTNotifications)));				return dvc;
	    }
	}

        public override void Initialize(System.ComponentModel.IComponent component)
        {
            base.Initialize(component);

            IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));			
            if(host == null)
            {
                MessageBox.Show("The IDesignerHost service interface could not be obtained.");
                return;
            }

            if( MessageBox.Show("Press the Yes button to display notification message boxes for the designer transaction opened and closed notifications.","Link DesignerTransaction Notifications?", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1, MessageBoxOptions.RightAlign) == DialogResult.Yes )
            {							
	        host.TransactionOpened += new EventHandler(OnDesignerTransactionOpened);
    	        host.TransactionClosed += new DesignerTransactionCloseEventHandler(OnDesignerTransactionClosed);
                notification_mode = true;
            }
        }

        private void LinkDTNotifications(object sender, EventArgs e)
        {
            if(notification_mode == false)
            {
	        IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));							
                if(host != null)
	        {
		    notification_mode = true;
                   host.TransactionOpened += new EventHandler(OnDesignerTransactionOpened);
                   host.TransactionClosed += new DesignerTransactionCloseEventHandler(OnDesignerTransactionClosed);
	        }
	    }
        }

        private void UnlinkDTNotifications(object sender, EventArgs e)
        {
	    if(notification_mode)
    	    {
    	        IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));							
	        if(host != null)
                {				
		    notification_mode = false;
                    host.TransactionOpened -= new EventHandler(OnDesignerTransactionOpened);
                    host.TransactionClosed -= new DesignerTransactionCloseEventHandler(OnDesignerTransactionClosed);
                }
            }
        }

        private void OnDesignerTransactionOpened(object sender, EventArgs e)
        {			
	    System.Windows.Forms.MessageBox.Show("A Designer Transaction was started. (TransactionOpened)");
        }

        private void OnDesignerTransactionClosed(object sender, DesignerTransactionCloseEventArgs e)
        {			
	    System.Windows.Forms.MessageBox.Show("A Designer Transaction was completed. (TransactionClosed)");
        }   

        private void DoTransaction(object sender, EventArgs e) 
        {			
    	    IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));			
            DesignerTransaction t = host.CreateTransaction("Change Text and Size");

            /* The code within the using statement is considered to be a single transaction.
	       When the user selects Undo, the system will undo everything executed in this code block. */
            using (t)
            {
	        if(notification_mode)
	            System.Windows.Forms.MessageBox.Show("Entering a Designer-Initiated Designer Transaction");

                // The .NET Framework automatically associates the TypeDescriptor with the correct component
	        PropertyDescriptor someText = TypeDescriptor.GetProperties(Component)["StringProperty"];
                someText.SetValue(Component, "This text was set by the designer for this component.");

                PropertyDescriptor anInteger = TypeDescriptor.GetProperties(Component)["CountProperty"];
	        anInteger.SetValue(Component, count);
	        count++;

                // Complete the designer transaction.
	        t.Commit();

	        if(notification_mode)
	            System.Windows.Forms.MessageBox.Show("Designer-Initiated Designer Transaction Completed");
            }
        }

	protected override void Dispose(bool disposing)
	{
	    UnlinkDTNotifications(this, new EventArgs());
	    base.Dispose(disposing);
	}
    }
}

NamedPermissionSet

for full access to system resources. Demand value: F:System.Security.Permissions.SecurityAction.InheritanceDemand. Associated state:

.NET Framework
Disponible desde 1.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: