DesignerTransaction Sınıf

Tanım

Ad Alanı:

System.ComponentModel.Design

Bütünleştirilmiş Kod:

System.ComponentModel.TypeConverter.dll

Kaynak:

DesignerTransaction.cs

Performansı geliştirmek ve çoğu değişiklik türünün geri alınmasına olanak tanımak için bir dizi tasarım zamanı eylemini gruplandırmak için bir yol sağlar.

C#

public abstract class DesignerTransaction : IDisposable

Devralma

Object

DesignerTransaction

Uygulamalar

IDisposable

Örnekler

Aşağıdaki kod örneği programı bir tasarımcıdan nasıl oluşturulacağını DesignerTransaction gösterir. Bu örneği çalıştırmak için kaynak kodu bir sınıf kitaplığında derleyin. System.Design derlemesine bir başvuru eklemeniz gerekir. Yeni bir projede derlenmiş DLL'ye bir başvuru ekleyin ve kitaplıktaki bileşeni Araç Kutusu'na ekleyin.

Visual Studio'da bu özellik için kapsamlı destek sağlanır.

Ayrıca bkz . İzlenecek Yol: Araç Kutusunu Özel Bileşenlerle Otomatik Olarak Doldurma.

Tasarımcı isteğe bağlı olarak tasarımcı işlem olaylarıyla ilgili bildirimleri görüntüleyebilir. Tasarım modundayken forma örneğini DTComponent eklerseniz, tasarımcı işlemi olay bildirimlerini almak isteyip istemediğinizi soran bir ileti kutusu görüntülenir. Öğesinin bir örneğine DTComponentsağ tıkladığınızda görüntülenen kısayol menüsünü kullanarak bu bildirimleri aç/kapatabilirsiniz. İşlemler, Özellikler penceresi kullanarak değerleri değiştirdiğinizde oluşturulur. Tasarımcının, bileşenin kısayol menüsünde Örnek İşlem Gerçekleştir'e tıklayarak bir işlem gerçekleştirmesini de sağlayabilirsiniz.

C#

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);
    }
    }
}

Açıklamalar

İşlemler daha sonra geri alınabilecek eylemleri izleyebilir. İşlem sırasında yapılan değişiklikler, bir işlem iptal edilerek tersine çevrilebilir. Bu işlem, değiştirilen her özelliği değişiklik öncesi değerine ayarlayarak her değişikliği otomatik olarak tersine çevirmeye çalışır. İşlemler, işlemin tamamlanmasına kadar güncelleştirmeleri görüntüye erteleyerek bir dizi işlem sırasında performansı da artırabilir.

Bir işlem devam ederken, bazı bileşenler ve TransactionClosed olaylarını dinleyerek işlem tamamlanana kadar işlemlerini ertelerTransactionOpening. Örneğin Özellikler penceresi, işlem kapatılana kadar bir işlem açıldıktan sonra görünümünü güncelleştirmez.

Geri alınabilen veya birden çok işlem için işlemleri kullanmak için tasarımcınızın her işlem veya işlem serisi için geri alınabilen bir DesignerTransaction oluşturmasını sağlayın. İşlemlerin dışında bir dizi geri alma olayının başarıyla tamamlanmasını engelleyebilecek eylemler gerçekleştirmemeye dikkat edin.

yöntemini çağırarak CreateTransaction yeni DesignerTransaction bir IDesignerHostelde edebilirsiniz. Doğrudan yeni DesignerTransaction bir işlem oluşturmak yerine tasarımcı işlem mekanizmasıyla doğru şekilde tümleştirmek için her DesignerTransaction birinin etkinden IDesignerHost alındığından emin olun.

Bir işlem içinde eylem gerçekleştirmek için önce bir işlem oluşturmanız gerekir. Ardından, her değişiklik veya değişiklik kümesi gerçekleşmeden önce yöntemini ve OnComponentChanged her değişiklik veya değişiklik kümesi gerçekleştikten sonra yöntemini çağırmanız OnComponentChanging gerekir. Son olarak yöntemini çağırarak Commit işlemi tamamlayın ve kapatın.

Not

Özellik değerlerinde değişiklik yaparken, öğesinin SetValuePropertyDescriptorbileşen değişiklik yöntemlerini IComponentChangeService çağıran ve değişikliği otomatik olarak temsil eden bir DesignerTransaction oluşturan yöntemini kullanın.

İşlem gerçekleştirmek için aşağıdaki adımları tamamlayın:

1. İşlemi denetlemek için kullanılabilecek bir DesignerTransaction almak için çağrısıCreateTransaction.

2. Bir try blok içinde, ile DesignerTransactionizlemek istediğiniz her eylem için yöntemini çağırın OnComponentChanging , değişikliği veya değişiklikleri yapın, ardından değişikliğin veya değişikliklerin yapıldığının sinyalini vermek için yöntemini çağırın OnComponentChanged .

3. İşlemi tamamlamak için bir finally bloğun içinden çağrısı Commit gerçekleştirin.

C# dilinde, aşağıdaki örnekte olduğu gibi bir try/finally blok yerine deyimini kullanabilirsinizusing.

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

İptal etmek ve bir işlemi işlenmeden önce geri almak için yöntemini çağırın Cancel . Cancel yöntemi çağrıldığında, tarafından DesignerTransaction izlenen eylemler değişiklikleri geri almayı deneyecek şekilde tersine çevrilir. Önceki işlemlerin bir parçası olarak gerçekleşen eylemleri geri almak için geliştirme ortamı tarafından sağlanan geri alma komutunu kullanmanız gerekir.

Oluşturucular

DesignerTransaction()	Açıklama olmadan sınıfının yeni bir örneğini DesignerTransaction başlatır.
DesignerTransaction(String)	Belirtilen işlem açıklamasını kullanarak sınıfın DesignerTransaction yeni bir örneğini başlatır.

Özellikler

Canceled	İşlemin iptal edilip edilmediğini belirten bir değer alır.
Committed	İşlemin işlenip işlenmediğini belirten bir değer alır.
Description	İşlem için bir açıklama alır.

Yöntemler

Cancel()	İşlemi iptal eder ve işlemin olayları tarafından yapılan değişiklikleri geri almayı dener.
Commit()	Bu işlemi işler.
Dispose(Boolean)	DesignerTransaction tarafından kullanılan yönetilmeyen kaynakları serbest bırakır ve yönetilen kaynakları isteğe bağlı olarak serbest bırakır.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
Finalize()	Bu nesneyle ilişkili kaynakları serbest bırakır. Bu geçersiz kılma, henüz işlenmediyse bu işlemi işler.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
OnCancel()	Olayı tetikler Cancel .
OnCommit()	Bir işlem yürütmenin fiili çalışmasını gerçekleştirir.
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)

Belirtik Arabirim Kullanımları

IDisposable.Dispose()

DesignerTransaction tarafından kullanılan tüm kaynakları serbest bırakır.

Şunlara uygulanır

Ayrıca bkz.

• IDesignerHost
• IComponentChangeService
• PropertyDescriptor