Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original
Este tema aún no ha recibido ninguna valoración - Valorar este tema

DesignerTransaction (Clase)

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.

System.Object
  System.ComponentModel.Design.DesignerTransaction

Espacio de nombres:  System.ComponentModel.Design
Ensamblado:  System (en System.dll)
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
[HostProtectionAttribute(SecurityAction.LinkDemand, SharedState = true)]
public abstract class DesignerTransaction : IDisposable

El tipo DesignerTransaction expone los siguientes miembros.

  NombreDescripción
Método protegidoDesignerTransaction()Inicializa una nueva instancia de la clase DesignerTransaction sin ninguna descripción.
Método protegidoDesignerTransaction(String)Inicializa una nueva instancia de la clase DesignerTransaction utilizando la descripción de transacción especificada.
Arriba
  NombreDescripción
Propiedad públicaCanceledObtiene un valor que indica si se canceló la transacción.
Propiedad públicaCommittedObtiene un valor que indica si se confirmó la transacción.
Propiedad públicaDescriptionObtiene una descripción para la transacción.
Arriba
  NombreDescripción
Método públicoCancelCancela la transacción e intenta deshacer los cambios realizados por los eventos de la transacción.
Método públicoCommitConfirma la transacción.
Método protegidoDisposeLibera los recursos no administrados que utiliza DesignerTransaction y libera los recursos administrados de forma opcional.
Método públicoEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método protegidoFinalizeLibera los recursos asociados a este objeto. Este reemplazo confirma esta transacción si aún no se había confirmado. (Invalida a Object.Finalize()).
Método públicoGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoGetType Obtiene el Typede la instancia actual. (Se hereda de Object).
Método protegidoMemberwiseClone Crea una copia superficial del Object actual. (Se hereda de Object).
Método protegidoOnCancelGenera el evento Cancel.
Método protegidoOnCommitRealiza el trabajo real de confirmación de una transacción.
Método públicoToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Arriba
  NombreDescripción
Implementación explícita de interfacesMétodo privadoIDisposable.DisposeLibera todos los recursos utilizados por DesignerTransaction.
Arriba

Las transacciones pueden realizar el seguimiento de las acciones que más tarde se pueden deshacer. Los cambios realizados durante una transacción se pueden deshacer cancelándola, con lo que se intenta deshacer automáticamente cada cambio estableciendo cada una de las propiedades modificadas en su valor anterior al cambio. Asimismo, para mejorar el rendimiento durante determinadas operaciones, las transacciones demoran las actualizaciones de la pantalla hasta que termina la transacción.

Mientras está teniendo lugar una transacción, algunos componentes aplazan su procesamiento hasta que finalice la transacción escuchando los eventos TransactionOpening y TransactionClosed. La ventana Propiedades, por ejemplo, no se actualiza después de abrirse una transacción hasta que se cierra dicha transacción.

Para usar transacciones en operaciones reversibles o en varias operaciones, haga que el diseñador cree una clase DesignerTransaction para cada operación o serie de operaciones que desee que sean reversibles. Procure no realizar acciones fuera de las transacciones que puedan impedir que se complete correctamente una secuencia de eventos de deshacer.

Para obtener una DesignerTransaction nueva, llame al método CreateTransaction de IDesignerHost. Asegúrese de obtener cada DesignerTransaction de la IDesignerHost activa para integrarse correctamente en el mecanismo de proceso de transacciones del diseñador, en lugar de crear una DesignerTransaction nueva directamente.

Para realizar una acción en una transacción, primero se debe crear la transacción. Después, llame al método OnComponentChanging antes de que se produzcan los cambios, y al método OnComponentChanged después de que se produzcan los cambios. Finalmente, complete y cierre la transacción llamando al método Commit.

NotaNota

Cuando haga cambios en los valores de propiedades, use el método SetValue de PropertyDescriptor, que llama a los métodos de cambios de componentes de IComponentChangeService y crea una DesignerTransaction que representa el cambio automáticamente.

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

  1. Llame a CreateTransaction para obtener un DesignerTransaction que pueda utilizarse para controlar la transacción.

  2. En un bloque try, para cada acción de la que desee hacer un seguimiento con una clase DesignerTransaction, llame al método OnComponentChanging, realice los cambios y, a continuación, llame al método OnComponentChanged para indicar que estos se han realizado los cambios.

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

En C#, puede utilizarse la instrucción using en lugar de un bloque try/finally, tal y como se muestra en el siguiente ejemplo.

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

Para cancelar y deshacer una transacción antes de confirmarla, llame al método Cancel. Cuando se llama al método Cancel, las acciones de las que hace un seguimiento DesignerTransaction se deshacen para intentar deshacer los cambios. Para deshacer las acciones realizadas en transacciones anteriores, se debe utilizar el comando para deshacer incluido en el entorno de desarrollo.

NotaNota

El atributo HostProtectionAttribute aplicado a este tipo o miembro tiene el valor de propiedad Resources siguiente: SharedState. El atributo HostProtectionAttribute no afecta a las aplicaciones de escritorio (que normalmente se inician haciendo doble clic en un icono, escribiendo un comando o introduciendo una dirección URL en el explorador). Para obtener más información, vea la clase HostProtectionAttribute o Programación en SQL Server y atributos de protección de host.

En el ejemplo de código siguiente se muestra cómo se crea una clase 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 proyecto nuevo, agregue una referencia al archivo DLL compilado y agregue el componente en la biblioteca al Cuadro de herramientas.

En Visual Studio, hay una amplia compatibilidad para esta característica.

Para obtener más información, vea Tutorial: Rellenar automáticamente el cuadro de herramientas con componentes personalizados y Tutorial: Rellenar automáticamente el cuadro de herramientas con componentes personalizados y Tutorial: Rellenar automáticamente el cuadro de herramientas con componentes personalizados y Tutorial: Rellenar automáticamente el cuadro de herramientas con componentes personalizados y Tutorial: Rellenar automáticamente el cuadro de herramientas con componentes personalizados.

Opcionalmente, el diseñador puede mostrar notificaciones acerca de los eventos de transacciones del diseñador. Si agrega una instancia de DTComponent a un formulario en tiempo de diseño, se mostrará un cuadro de mensaje preguntando si desea recibir notificaciones de los eventos de transacciones del diseñador. Para activar o desactivar las notificaciones, se utiliza el menú contextual que aparece al hacer clic con el botón secundario en una instancia de DTComponent. Las transacciones se crean al cambiar los valores mediante la ventana Propiedades. Asimismo, para que el diseñador realice una transacción, se puede hacer clic en Realizar transacción de ejemplo en el menú contextual correspondiente al 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);
	}
    }
}


.NET Framework

Compatible con: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.
Todos los miembros públicos static (Shared en Visual Basic) de este tipo son seguros para subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.
¿Te ha resultado útil?
(Caracteres restantes: 1500)
Gracias por sus comentarios

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft. Reservados todos los derechos.