DesignerSerializationVisibilityAttribute Classe

Definizione

Spazio dei nomi:

System.ComponentModel

Assembly:

System.ComponentModel.Primitives.dll

Source:

DesignerSerializationVisibilityAttribute.cs

Specifica il tipo di persistenza da utilizzare quando si serializza una proprietà su un componente in fase di progettazione.

public ref class DesignerSerializationVisibilityAttribute sealed : Attribute

[System.AttributeUsage(System.AttributeTargets.Event | System.AttributeTargets.Field | System.AttributeTargets.Method | System.AttributeTargets.Property)]
public sealed class DesignerSerializationVisibilityAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Event | System.AttributeTargets.Field | System.AttributeTargets.Method | System.AttributeTargets.Property)>]
type DesignerSerializationVisibilityAttribute = class
    inherit Attribute

Public NotInheritable Class DesignerSerializationVisibilityAttribute
Inherits Attribute

Ereditarietà

Object

Attribute

DesignerSerializationVisibilityAttribute

Attributi

AttributeUsageAttribute

Esempio

Nell'esempio di codice seguente viene illustrato l'uso di un DesignerSerializationVisibilityAttribute set su Content. Mantiene i valori di una proprietà pubblica di un controllo utente, che può essere configurato in fase di progettazione. Per usare l'esempio, compilare prima il codice seguente in una libreria di controlli utente. Aggiungere quindi un riferimento al file di .dll compilato in un nuovo progetto applicazione Di Windows. Se si usa Visual Studio, l'oggetto ContentSerializationExampleControl viene aggiunto automaticamente alla casella degli strumenti.

Trascinare il controllo dalla casella degli strumenti a un modulo e impostare le proprietà dell'oggetto DimensionData elencato nella Finestra Proprietà. Quando si visualizza il codice per il modulo, il codice verrà aggiunto al InitializeComponent metodo del modulo padre. Questo codice imposta i valori delle proprietà del controllo a quelli impostati in modalità di progettazione.

#using <System.Windows.Forms.dll>
#using <System.Drawing.dll>
#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::ComponentModel;
using namespace System::ComponentModel::Design;
using namespace System::Drawing;
using namespace System::Windows::Forms;

// This attribute indicates that the public properties of this object should be listed in the property grid.

[TypeConverterAttribute(System::ComponentModel::ExpandableObjectConverter::typeid)]
public ref class DimensionData
{
private:
   Control^ owner;

internal:

   // This class reads and writes the Location and Size properties from the Control which it is initialized to.
   DimensionData( Control^ owner )
   {
      this->owner = owner;
   }

public:

   property Point Location 
   {
      Point get()
      {
         return owner->Location;
      }

      void set( Point value )
      {
         owner->Location = value;
      }

   }

   property Size FormSize 
   {
      Size get()
      {
         return owner->Size;
      }

      void set( Size value )
      {
         owner->Size = value;
      }
   }
};

// The code for this user control declares a public property of type DimensionData with a DesignerSerializationVisibility 
// attribute set to DesignerSerializationVisibility.Content, indicating that the properties of the object should be serialized.
// The public, not hidden properties of the object that are set at design time will be persisted in the initialization code
// for the class object. Content persistence will not work for structs without a custom TypeConverter.  
public ref class ContentSerializationExampleControl: public System::Windows::Forms::UserControl
{
private:
   System::ComponentModel::Container^ components;

public:

   property DimensionData^ Dimensions 
   {
      [DesignerSerializationVisibility(DesignerSerializationVisibility::Content)]
      DimensionData^ get()
      {
         return gcnew DimensionData( this );
      }
   }
   ContentSerializationExampleControl()
   {
      InitializeComponent();
   }

public:
   ~ContentSerializationExampleControl()
   {
      if ( components != nullptr )
      {
         delete components;
      }
   }

private:
   void InitializeComponent()
   {
      components = gcnew System::ComponentModel::Container;
   }
};

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

namespace DesignerSerializationVisibilityTest
{
    // The code for this user control declares a public property of type DimensionData with a DesignerSerializationVisibility 
    // attribute set to DesignerSerializationVisibility.Content, indicating that the properties of the object should be serialized.

    // The public, not hidden properties of the object that are set at design time will be persisted in the initialization code
    // for the class object. Content persistence will not work for structs without a custom TypeConverter.		

    public class ContentSerializationExampleControl : System.Windows.Forms.UserControl
    {
    private System.ComponentModel.Container components = null;				
    
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
    public DimensionData Dimensions
    {
        get 
        {
        return new DimensionData(this);
        }		
    }

    public ContentSerializationExampleControl()
    {
            InitializeComponent();		
    }
        
    protected override void Dispose( bool disposing )
    {
        if( disposing )
        {
        if( components != null )
            components.Dispose();
        }
        base.Dispose( disposing );
    }

    private void InitializeComponent()
    {
        components = new System.ComponentModel.Container();
    }
    }

    [TypeConverterAttribute(typeof(System.ComponentModel.ExpandableObjectConverter))]
    // This attribute indicates that the public properties of this object should be listed in the property grid.
    public class DimensionData
    {		
    private Control owner;

    // This class reads and writes the Location and Size properties from the Control which it is initialized to.
    internal DimensionData(Control owner)
    {
            this.owner = owner;			
    }

    public Point Location
    {
        get
        {
        return owner.Location;
        }
        set
        {
        owner.Location = value;
        }
    }

    public Size FormSize
    {
        get
            {
        return owner.Size;
        }
        set
        {
        owner.Size = value;
        }
    }
    }
}

Imports System.Collections
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Drawing
Imports System.Windows.Forms

Namespace DesignerSerializationVisibilityTest
    _
    ' The code for this user control declares a public property of type DimensionData with a DesignerSerializationVisibility 
    ' attribute set to DesignerSerializationVisibility.Content, indicating that the properties of the object should be serialized.

    ' The public, not hidden properties of the object that are set at design time will be persisted in the initialization code
    ' for the class object. Content persistence will not work for structs without a custom TypeConverter.		
    Public Class ContentSerializationExampleControl
        Inherits System.Windows.Forms.UserControl
        Private components As System.ComponentModel.Container = Nothing


        <DesignerSerializationVisibility(DesignerSerializationVisibility.Content)> _
        Public ReadOnly Property Dimensions() As DimensionData
            Get
                Return New DimensionData(Me)
            End Get
        End Property


        Public Sub New()
            InitializeComponent()
        End Sub


        Protected Overloads Sub Dispose(ByVal disposing As Boolean)
            If disposing Then
                If (components IsNot Nothing) Then
                    components.Dispose()
                End If
            End If
            MyBase.Dispose(disposing)
        End Sub


        Private Sub InitializeComponent()
        End Sub
    End Class

    ' This attribute indicates that the public properties of this object should be listed in the property grid.
   <TypeConverterAttribute(GetType(System.ComponentModel.ExpandableObjectConverter))> _   
    Public Class DimensionData
        Private owner As Control

        ' This class reads and writes the Location and Size properties from the Control which it is initialized to.
        Friend Sub New(ByVal owner As Control)
            Me.owner = owner
        End Sub


        Public Property Location() As Point
            Get
                Return owner.Location
            End Get
            Set(ByVal Value As Point)
                owner.Location = Value
            End Set
        End Property


        Public Property FormSize() As Size
            Get
                Return owner.Size
            End Get
            Set(ByVal Value As Size)
                owner.Size = Value
            End Set
        End Property
    End Class
End Namespace 'DesignerSerializationVisibilityTest

Commenti

Quando un serializzatore mantiene lo stato persistente di un documento in modalità progettazione, spesso aggiunge codice al metodo di inizializzazione dei componenti per rendere persistenti i valori delle proprietà impostate in fase di progettazione. Ciò avviene per impostazione predefinita per la maggior parte dei tipi di base, se non è stato impostato alcun attributo per indirizzare altri comportamenti.

DesignerSerializationVisibilityAttributeCon , è possibile indicare se il valore per una proprietà è Visible, e deve essere persistente nel codice di inizializzazione, Hiddene non deve essere persistente nel codice di inizializzazione oppure è costituito Contentda , che deve avere il codice di inizializzazione generato per ogni oggetto pubblico, non nascosto della proprietà assegnata alla proprietà.

I membri che non dispongono di un DesignerSerializationVisibilityAttribute oggetto verranno considerati come se abbiano un DesignerSerializationVisibilityAttribute valore di Visible. I valori di una proprietà contrassegnati come Visible verranno serializzati, se possibile, da un serializzatore per il tipo. Per specificare la serializzazione personalizzata per un tipo o una proprietà specifica, usare .DesignerSerializerAttribute

Per altre informazioni, vedere Attributi.

Costruttori

DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility)

Inizializza una nuova istanza della classe DesignerSerializationVisibilityAttribute con il valore DesignerSerializationVisibility specificato.

Campi

Content	Specifica che in un serializzatore dovrebbe essere serializzato il contenuto della proprietà, anziché la proprietà stessa. Questo campo è di sola lettura.
Default	Specifica il valore predefinito, ovvero Visible, che indica che la finestra di progettazione visiva genera il valore di una proprietà utilizzando regole predefinite. Questo campo static è di sola lettura.
Hidden	Specifica che in un serializzatore non dovrebbe essere serializzato il valore della proprietà. Questo campo static è di sola lettura.
Visible	Specifica che in un serializzatore deve essere possibile serializzare il valore della proprietà. Questo campo static è di sola lettura.

Proprietà

TypeId	Quando è implementata in una classe derivata, ottiene un identificatore univoco della classe Attribute. (Ereditato da Attribute)
Visibility	Ottiene un valore che indica la modalità di serializzazione di base da utilizzare per determinare se e come rendere persistente il valore di una proprietà.

Metodi

Equals(Object)	Indica se questa istanza e un oggetto specificato sono uguali.
GetHashCode()	Restituisce il codice hash per questo oggetto.
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
IsDefaultAttribute()	Ottiene un valore che indica se il valore corrente dell'attributo è il valore predefinito dell'attributo stesso.
Match(Object)	Quando è sottoposto a override in una classe derivata, restituisce un valore che indica se questa istanza equivale a un oggetto specificato. (Ereditato da Attribute)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Vedi anche

• Attribute
• PropertyDescriptor
• AttributeCollection
• PropertyDescriptorCollection
• Procedura: serializzare raccolte di tipi standard mediante DesignerSerializationVisibilityAttribute