DesignerTransaction-Klasse
Stellt ein Verfahren zum Gruppieren einer Reihe von Entwurfszeitaktionen bereit, um die Leistung zu verbessern und das Rückgängigmachen der meisten Arten von Änderungen zu ermöglichen.
Namespace: System.ComponentModel.Design
Assembly: System (in system.dll)
Syntax
'Declaration
Public MustInherit Class DesignerTransaction
Implements IDisposable
'Usage
Dim instance As DesignerTransaction
public abstract class DesignerTransaction : IDisposable
public ref class DesignerTransaction abstract : IDisposable
public abstract class DesignerTransaction implements IDisposable
public abstract class DesignerTransaction implements IDisposable
Hinweise
Transaktionen können Aktionen verfolgen, die später rückgängig gemacht werden können. Die während einer Transaktion vorgenommenen Änderungen können durch Löschen der Transaktion rückgängig gemacht werden. Dabei wird automatisch versucht, alle Änderungen rückgängig zu machen, indem die einzelnen geänderten Eigenschaften auf den ursprünglichen Wert festgelegt werden. Bei Transaktionen kann außerdem während einer Reihe von Vorgängen die Leistung gesteigert werden, indem Aktualisierungen der Anzeige bis zum Abschluss der Transaktion verzögert werden.
Während eine Transaktion stattfindet, wird die Verarbeitung einiger Komponenten von diesen durch Überwachung des TransactionOpening-Ereignisses und des TransactionClosed-Ereignisses so lange verzögert, bis die Transaktion beendet ist. So wird die Anzeige des Eigenschaftenfensters nach dem Öffnen einer Transaktion erst dann aktualisiert, nachdem die Transaktion geschlossen wurde.
Zur Verwendung von Transaktionen für mehrere Vorgänge bzw. solche, die rückgängig gemacht werden können, erstellen Sie mithilfe des Designers eine DesignerTransaction-Klasse für alle Vorgänge bzw. die Reihe von Vorgängen, für die das Rückgängigmachen möglich sein soll. Achten Sie darauf, außerhalb von Transaktionen keine Aktionen durchzuführen, die eine ordnungsgemäße Durchführung einer Folge von Rückgängig-Ereignissen verhindern könnten.
Sie können eine neue DesignerTransaction-Klasse erhalten, indem Sie die CreateTransaction-Methode einer IDesignerHost-Schnittstelle aufrufen. Erstellen Sie eine neue DesignerTransaction-Klasse nicht direkt, sondern achten Sie darauf, jede DesignerTransaction-Klasse von der aktiven IDesignerHost-Schnittstelle zu erhalten, um eine ordnungsgemäße Integration mit dem Verarbeitungsmechanismus für Designertransaktionen zu gewährleisten.
Um eine Aktion innerhalb einer Transaktion auszuführen, müssen Sie zunächst eine Transaktion erstellen. Dann müssen Sie vor dem Auftreten der einzelnen Änderungen oder Gruppen von Änderungen die OnComponentChanging-Methode und nach dem Auftreten der einzelnen Änderungen oder Gruppen von Änderungen die OnComponentChanged-Methode aufrufen. Beenden und schließen Sie abschließend die Transaktion, indem Sie die Commit-Methode aufrufen.
Hinweis
Bei Änderungen an Eigenschaftenwerten verwenden Sie die SetValue-Methode einer PropertyDescriptor-Klasse, wodurch die Methode zur Komponentenänderung der IComponentChangeService-Schnittstelle aufgerufen und automatisch eine DesignerTransaction-Klasse erstellt wird, die die Änderung darstellt.
Gehen Sie wie folgt vor, um eine Transaktion auszuführen:
Rufen Sie die CreateTransaction-Methode auf, um eine DesignerTransaction-Klasse zu erhalten, mit der die Transaktion gesteuert werden kann.
Rufen Sie in einem try-Block für jede Aktion, die innerhalb einer DesignerTransaction-Klasse nachverfolgt werden soll, die OnComponentChanging-Methode auf, nehmen Sie die Änderung bzw. die Änderungen vor, und signalisieren Sie dann durch Aufrufen der OnComponentChanged-Methode, dass die Änderung bzw. die Änderungen ausgeführt worden sind.
Zum Abschluss der Transaktion rufen Sie die Commit-Methode aus einem finally-Block auf.
In C# können Sie die using-Anweisung anstatt eines try/finally-Blocks verwenden, wie im folgenden Beispiel dargestellt.
using (host.CreateTransaction() {
// Insert your code here.
}
Um eine Transaktion abzubrechen und zu versuchen, vor der Ausführung eines Commits einen Rollback für sie auszuführen, rufen Sie die Cancel-Methode auf. Wenn die Cancel-Methode aufgerufen wird, werden die von der DesignerTransaction-Klasse überwachten Aktionen umgekehrt, um einen Rollback der Änderungen zu versuchen. Um Aktionen rückgängig zu machen, die als Teil von früheren Transaktionen ausgeführt wurden, müssen Sie den durch die Entwicklungsumgebung bereitgestellten Rückgängig-Befehl verwenden.
Hinweis
Das auf diese Klasse angewendete HostProtectionAttribute-Attribut besitzt den Resources-Eigenschaftenwert SharedState. Das HostProtectionAttribute hat keine Auswirkungen auf Desktopanwendungen (die normalerweise durch Doppelklicken auf ein Symbol, Eingeben eines Befehls oder eines URL in einem Browser gestartet werden). Weitere Informationen finden Sie unter der HostProtectionAttribute-Klasse oder unter SQL Server-Programmierung und Hostschutzattribute.
Beispiel
Das folgende Codebeispielprogramm veranschaulicht, wie aus einem Designer eine DesignerTransaction-Klasse erstellt wird. Optional kann der Designer Benachrichtigungen über Ereignisse von Designertransaktionen anzeigen. Um dieses Beispiel auszuführen, kompilieren Sie den Quellcode in eine Klassenbibliothek, fügen Sie einem Projekt einen Verweis auf die kompilierte DLL hinzu, und fügen Sie der Toolbox die Komponente in der Bibliothek hinzu.
Für dieses Feature ist in Visual Studio umfangreiche Unterstützung vorhanden.
Exemplarische Vorgehensweise: Automatisches Füllen der Toolbox mit benutzerdefinierten Komponenten
Exemplarische Vorgehensweise: Automatisches Füllen der Toolbox mit benutzerdefinierten Komponenten
Exemplarische Vorgehensweise: Automatisches Füllen der Toolbox mit benutzerdefinierten Komponenten
Exemplarische Vorgehensweise: Automatisches Füllen der Toolbox mit benutzerdefinierten Komponenten
Wenn Sie einem Formular im Entwurfsmodus eine Instanz von DTComponent hinzufügen, wird ein Meldungsfeld angezeigt, in dem Sie gefragt werden, ob Sie Benachrichtigungen über Ereignisse von Designertransaktionen erhalten möchten. Wenn Sie mit der rechten Maustaste auf eine Instanz von DTComponent klicken, wird ein Kontextmenü angezeigt, in dem Sie diese Benachrichtigungen aktivieren bzw. deaktivieren können. Transaktionen werden erstellt, wenn Sie im Eigenschaftenfenster Werte ändern. Außerdem können Sie den Designer zur Durchführung einer Transaktion veranlassen, indem Sie im Kontextmenü für die Komponente auf Beispieltransaktion ausführen klicken.
Imports System
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Windows.Forms
Imports 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 are being 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(GetType(DTDesigner))> _
Public Class DTComponent
Inherits System.ComponentModel.Component
Private m_String As String
Private m_Count As Integer
Public Property StringProperty() As String
Get
Return m_String
End Get
Set(ByVal Value As String)
m_String = Value
End Set
End Property
Public Property CountProperty() As Integer
Get
Return m_Count
End Get
Set(ByVal Value As Integer)
m_Count = Value
End Set
End Property
Private Sub InitializeComponent()
m_String = "Initial Value"
m_Count = 0
End Sub 'InitializeComponent
End Class 'DTComponent
Friend Class DTDesigner
Inherits ComponentDesigner
Private notification_mode As Boolean = False
Private count As Integer = 10
' The Verbs property is overridden from ComponentDesigner
Public Overrides ReadOnly Property Verbs() As DesignerVerbCollection
Get
Dim dvc As New DesignerVerbCollection()
dvc.Add(New DesignerVerb("Perform Example Transaction", AddressOf Me.DoTransaction))
If notification_mode Then
dvc.Add(New DesignerVerb("End Designer Transaction Notifications", AddressOf Me.UnlinkDTNotifications))
Else
dvc.Add(New DesignerVerb("Show Designer Transaction Notifications", AddressOf Me.LinkDTNotifications))
End If
Return dvc
End Get
End Property
Public Overrides Sub Initialize(ByVal component As System.ComponentModel.IComponent)
MyBase.Initialize(component)
Dim host As IDesignerHost = CType(GetService(GetType(IDesignerHost)), IDesignerHost)
If host Is Nothing Then
MessageBox.Show("The IDesignerHost service interface could not be obtained.")
Return
End If
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 Then
AddHandler host.TransactionOpened, AddressOf OnDesignerTransactionOpened
AddHandler host.TransactionClosed, AddressOf OnDesignerTransactionClosed
notification_mode = True
End If
End Sub 'Initialize
Private Sub LinkDTNotifications(ByVal sender As Object, ByVal e As EventArgs)
If notification_mode = False Then
Dim host As IDesignerHost = CType(GetService(GetType(IDesignerHost)), IDesignerHost)
If Not (host Is Nothing) Then
notification_mode = True
AddHandler host.TransactionOpened, AddressOf OnDesignerTransactionOpened
AddHandler host.TransactionClosed, AddressOf OnDesignerTransactionClosed
End If
End If
End Sub 'LinkDTNotifications
Private Sub UnlinkDTNotifications(ByVal sender As Object, ByVal e As EventArgs)
If notification_mode Then
Dim host As IDesignerHost = CType(GetService(GetType(IDesignerHost)), IDesignerHost)
If Not (host Is Nothing) Then
notification_mode = False
RemoveHandler host.TransactionOpened, AddressOf Me.OnDesignerTransactionOpened
RemoveHandler host.TransactionClosed, AddressOf Me.OnDesignerTransactionClosed
End If
End If
End Sub 'UnlinkDTNotifications
Private Sub OnDesignerTransactionOpened(ByVal sender As Object, ByVal e As EventArgs)
System.Windows.Forms.MessageBox.Show("A Designer Transaction was started. (TransactionOpened)")
End Sub 'OnDesignerTransactionOpened
Private Sub OnDesignerTransactionClosed(ByVal sender As Object, ByVal e As DesignerTransactionCloseEventArgs)
System.Windows.Forms.MessageBox.Show("A Designer Transaction was completed. (TransactionClosed)")
End Sub 'OnDesignerTransactionClosed
Private Sub DoTransaction(ByVal sender As Object, ByVal e As EventArgs)
Dim host As IDesignerHost = CType(GetService(GetType(IDesignerHost)), IDesignerHost)
Dim t As DesignerTransaction = 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.
Try
If (notification_mode) Then
System.Windows.Forms.MessageBox.Show("Entering a Designer-Initiated Designer Transaction")
End If
Dim someText As PropertyDescriptor = TypeDescriptor.GetProperties(Component)("StringProperty")
someText.SetValue(Component, "This text was set by the designer for this component.")
Dim anInteger As PropertyDescriptor = TypeDescriptor.GetProperties(Component)("CountProperty")
anInteger.SetValue(Component, count)
count = count + 1
Exit Try
Finally
t.Commit()
End Try
If (notification_mode) Then
System.Windows.Forms.MessageBox.Show("Designer-Initiated Designer Transaction Completed")
End If
End Sub 'DoTransaction
Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
UnlinkDTNotifications(Me, New EventArgs())
MyBase.Dispose(disposing)
End Sub 'Dispose
End Class 'DTDesigner
End Namespace 'DesignerTransactionSample
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);
}
}
}
#using <system.dll>
#using <system.design.dll>
#using <system.windows.forms.dll>
using namespace System;
using namespace System::ComponentModel;
using namespace System::ComponentModel::Design;
using namespace System::Windows::Forms;
using namespace 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.
*/
private ref class DTDesigner: public ComponentDesigner
{
private:
bool notification_mode;
int count;
void LinkDTNotifications( Object^ /*sender*/, EventArgs^ /*e*/ )
{
if ( !notification_mode )
{
IDesignerHost^ host = dynamic_cast<IDesignerHost^>(GetService( IDesignerHost::typeid ));
if ( host != nullptr )
{
notification_mode = true;
host->TransactionOpened += gcnew EventHandler( this, &DTDesigner::OnDesignerTransactionOpened );
host->TransactionClosed += gcnew DesignerTransactionCloseEventHandler( this, &DTDesigner::OnDesignerTransactionClosed );
}
}
}
void UnlinkDTNotifications( Object^ /*sender*/, EventArgs^ /*e*/ )
{
if ( notification_mode )
{
IDesignerHost^ host = dynamic_cast<IDesignerHost^>(GetService( IDesignerHost::typeid ));
if ( host != nullptr )
{
notification_mode = false;
host->TransactionOpened -= gcnew EventHandler( this, &DTDesigner::OnDesignerTransactionOpened );
host->TransactionClosed -= gcnew DesignerTransactionCloseEventHandler( this, &DTDesigner::OnDesignerTransactionClosed );
}
}
}
void OnDesignerTransactionOpened( Object^ /*sender*/, EventArgs^ /*e*/ )
{
MessageBox::Show( "A Designer Transaction was started. (TransactionOpened)" );
}
void OnDesignerTransactionClosed( Object^ /*sender*/, DesignerTransactionCloseEventArgs^ /*e*/ )
{
MessageBox::Show( "A Designer Transaction was completed. (TransactionClosed)" );
}
void DoTransaction( Object^ /*sender*/, EventArgs^ /*e*/ )
{
IDesignerHost^ host = static_cast<IDesignerHost^>(GetService( IDesignerHost::typeid ));
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.
*/
if ( notification_mode )
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 )
MessageBox::Show( "Designer-Initiated Designer Transaction Completed" );
}
public:
property DesignerVerbCollection^ Verbs
{
// The Verbs property is overridden from ComponentDesigner
virtual DesignerVerbCollection^ get() override
{
DesignerVerbCollection^ dvc = gcnew DesignerVerbCollection;
dvc->Add( gcnew DesignerVerb( "Perform Example Transaction",gcnew EventHandler( this, &DTDesigner::DoTransaction ) ) );
if ( notification_mode )
dvc->Add( gcnew DesignerVerb( "End Designer Transaction Notifications",
gcnew EventHandler( this, &DTDesigner::UnlinkDTNotifications ) ) );
else
dvc->Add( gcnew DesignerVerb( "Show Designer Transaction Notifications",
gcnew EventHandler( this, &DTDesigner::LinkDTNotifications ) ) );
return dvc;
}
}
virtual void Initialize( IComponent^ component ) override
{
ComponentDesigner::Initialize( component );
notification_mode = false;
count = 10;
IDesignerHost^ host = dynamic_cast<IDesignerHost^>(GetService( IDesignerHost::typeid ));
if ( host == nullptr )
{
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 += gcnew EventHandler( this, &DTDesigner::OnDesignerTransactionOpened );
host->TransactionClosed += gcnew DesignerTransactionCloseEventHandler( this, &DTDesigner::OnDesignerTransactionClosed );
notification_mode = true;
}
}
public:
~DTDesigner()
{
UnlinkDTNotifications( this, gcnew EventArgs );
}
};
// Associate the DTDesigner with this component
[DesignerAttribute(DTDesigner::typeid)]
public ref class DTComponent: public System::ComponentModel::Component
{
private:
String^ m_String;
int m_Count;
void InitializeComponent()
{
m_String = "Initial Value";
m_Count = 0;
}
public:
property String^ StringProperty
{
String^ get()
{
return m_String;
}
void set( String^ value )
{
m_String = value;
}
}
property int CountProperty
{
int get()
{
return m_Count;
}
void set( int value )
{
m_Count = value;
}
}
};
.NET Framework-Sicherheit
- NamedPermissionSet für Vollzugriff auf Systemressourcen. Anforderungswert: InheritanceDemand. Zugeordneter Zustand: FullTrust
Vererbungshierarchie
System.Object
System.ComponentModel.Design.DesignerTransaction
Threadsicherheit
Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Plattformen
Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
Siehe auch
Referenz
DesignerTransaction-Member
System.ComponentModel.Design-Namespace
IDesignerHost
IComponentChangeService
PropertyDescriptor-Klasse