CodeDomSerializer Klasse

Definition

public ref class CodeDomSerializer abstract

public ref class CodeDomSerializer : System::ComponentModel::Design::Serialization::CodeDomSerializerBase

public abstract class CodeDomSerializer

public class CodeDomSerializer : System.ComponentModel.Design.Serialization.CodeDomSerializerBase

type CodeDomSerializer = class

type CodeDomSerializer = class
    inherit CodeDomSerializerBase

Public MustInherit Class CodeDomSerializer

Public Class CodeDomSerializer
Inherits CodeDomSerializerBase

Vererbung

Object

CodeDomSerializer

Vererbung

Object

CodeDomSerializerBase

CodeDomSerializer

Abgeleitet

System.ComponentModel.Design.Serialization.CollectionCodeDomSerializer

System.Windows.Forms.Design.ImageListCodeDomSerializer

System.Workflow.ComponentModel.Serialization.DependencyObjectCodeDomSerializer

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie sie ein benutzerdefiniertes CodeDOM-Serialisierungsprogramm erstellen, das von abgeleitet wird CodeDomSerializer.

#using <System.Drawing.dll>
#using <System.dll>
#using <System.Design.dll>

using namespace System;
using namespace System::CodeDom;
using namespace System::ComponentModel;
using namespace System::ComponentModel::Design;
using namespace System::ComponentModel::Design::Serialization;
using namespace System::Drawing;
using namespace System::Windows::Forms;

namespace CodeDomSerializerSample
{
   ref class MyComponent;
   private ref class MyCodeDomSerializer: public CodeDomSerializer
   {
   public:
      Object^ Deserialize( IDesignerSerializationManager^ manager, Object^ codeObject ) new
      {
         // This is how we associate the component with the serializer.
         CodeDomSerializer^ baseClassSerializer = (CodeDomSerializer^)(
            manager->GetSerializer(
               MyComponent::typeid->BaseType, CodeDomSerializer::typeid ));
         
         /* This is the simplest case, in which the class just calls the base class
            to do the work. */
         return baseClassSerializer->Deserialize( manager, codeObject );
      }

      Object^ Serialize( IDesignerSerializationManager^ manager, Object^ value ) new
      {
         /* Associate the component with the serializer in the same manner as with
            Deserialize */
         CodeDomSerializer^ baseClassSerializer = (CodeDomSerializer^)(
            manager->GetSerializer(
               MyComponent::typeid->BaseType, CodeDomSerializer::typeid ));

         Object^ codeObject = baseClassSerializer->Serialize( manager, value );
         
         /* Anything could be in the codeObject.  This sample operates on a
            CodeStatementCollection. */
         if ( (CodeStatementCollection^)(codeObject) )
         {
            CodeStatementCollection^ statements = (CodeStatementCollection^)(codeObject);
            
            // The code statement collection is valid, so add a comment.
            String^ commentText = "This comment was added to this object by a custom serializer.";
            CodeCommentStatement^ comment = gcnew CodeCommentStatement( commentText );
            statements->Insert( 0, comment );
         }
         return codeObject;
      }
   };

   [DesignerSerializer(CodeDomSerializerSample::MyCodeDomSerializer::typeid,
      CodeDomSerializer::typeid)]
   public ref class MyComponent: public Component
   {
   private:
      String^ localProperty;

   public:
      MyComponent()
      {
         localProperty = "Component Property Value";
      }

      property String^ LocalProperty 
      {
         String^ get()
         {
            return localProperty;
         }
         void set( String^ value )
         {
            localProperty = value;
         }
      }
   };
}

using System;
using System.CodeDom;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Drawing;
using System.Windows.Forms;
 
namespace CodeDomSerializerSample
{
    internal class MyCodeDomSerializer : CodeDomSerializer {
        public override object Deserialize(IDesignerSerializationManager manager, object codeObject) {
            // This is how we associate the component with the serializer.
                CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.
                GetSerializer(typeof(MyComponent).BaseType, typeof(CodeDomSerializer));

            /* This is the simplest case, in which the class just calls the base class
                to do the work. */
            return baseClassSerializer.Deserialize(manager, codeObject);
        }
 
        public override object Serialize(IDesignerSerializationManager manager, object value) {
            /* Associate the component with the serializer in the same manner as with
                Deserialize */
            CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.
                GetSerializer(typeof(MyComponent).BaseType, typeof(CodeDomSerializer));
 
            object codeObject = baseClassSerializer.Serialize(manager, value);
 
            /* Anything could be in the codeObject.  This sample operates on a
                CodeStatementCollection. */
            if (codeObject is CodeStatementCollection) {
                CodeStatementCollection statements = (CodeStatementCollection)codeObject;
 
                // The code statement collection is valid, so add a comment.
                string commentText = "This comment was added to this object by a custom serializer.";
                CodeCommentStatement comment = new CodeCommentStatement(commentText);
                statements.Insert(0, comment);
            }
            return codeObject;
        }
    }
 
    [DesignerSerializer(typeof(MyCodeDomSerializer), typeof(CodeDomSerializer))]
    public class MyComponent : Component {
        private string localProperty = "Component Property Value";
        public string LocalProperty {
            get {
                return localProperty;
            }
            set {
                localProperty = value;
            }
        }
    }
}

Imports System.CodeDom
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.ComponentModel.Design.Serialization
Imports System.Drawing
Imports System.Windows.Forms

Namespace CodeDomSerializerSample
   Friend Class MyCodeDomSerializer
      Inherits CodeDomSerializer

      Public Overrides Function Deserialize(ByVal manager As IDesignerSerializationManager, _
                                                ByVal codeObject As Object) As Object
         ' This is how we associate the component with the serializer.
         Dim baseClassSerializer As CodeDomSerializer = CType(manager.GetSerializer( _
                GetType(MyComponent).BaseType, GetType(CodeDomSerializer)), CodeDomSerializer)

         ' This is the simplest case, in which the class just calls the base class
         '  to do the work. 
         Return baseClassSerializer.Deserialize(manager, codeObject)
      End Function 'Deserialize

      Public Overrides Function Serialize(ByVal manager As IDesignerSerializationManager, _
                                            ByVal value As Object) As Object
         ' Associate the component with the serializer in the same manner as with
         '  Deserialize
         Dim baseClassSerializer As CodeDomSerializer = CType(manager.GetSerializer( _
                GetType(MyComponent).BaseType, GetType(CodeDomSerializer)), CodeDomSerializer)

         Dim codeObject As Object = baseClassSerializer.Serialize(manager, value)

         ' Anything could be in the codeObject.  This sample operates on a
         '  CodeStatementCollection.
         If TypeOf codeObject Is CodeStatementCollection Then
            Dim statements As CodeStatementCollection = CType(codeObject, CodeStatementCollection)

            ' The code statement collection is valid, so add a comment.
            Dim commentText As String = "This comment was added to this object by a custom serializer."
            Dim comment As New CodeCommentStatement(commentText)
            statements.Insert(0, comment)
         End If
         Return codeObject
      End Function 'Serialize
   End Class

   <DesignerSerializer(GetType(MyCodeDomSerializer), GetType(CodeDomSerializer))> _
   Public Class MyComponent
      Inherits Component
      Private localProperty As String = "Component Property Value"

      Public Property LocalProp() As String
         Get
            Return localProperty
         End Get
         Set(ByVal Value As String)
            localProperty = Value
         End Set
      End Property
   End Class

End Namespace

Hinweise

Sie können eine benutzerdefinierte CodeDomSerializer implementieren, um die Generierung von Komponenteninitialisierungscode für einen Komponententyp zur Entwurfszeit zu steuern.

Um eine benutzerdefinierte CodeDomSerializer für einen Typ zu implementieren, müssen Sie:

1. Definieren Sie eine Klasse, die sich von CodeDomSerializer ableitet.

2. Implementieren Sie Methodenüberschreibungen für Serialisierungs- oder Deserialisierungsmethoden. (Weitere Informationen finden Sie in den folgenden Informationen.)

3. Ordnen Sie Ihre benutzerdefinierte CodeDomSerializer Implementierung mit einem Typ von Komponente zu DesignerSerializerAttribute.

So implementieren Sie eine Serialisierungsmethode zum Generieren von Konfigurationscode für eine Komponente:

1. Überschreiben Sie innerhalb einer Klasse, die von abgeleitet ist CodeDomSerializer, eine geeignete Serialisierungs- oder Deserialisierungsmethode der Basisklasse.

2. Wenn das Standardserialisierungsprogramm Codeanweisungen generieren soll, die die Standardkomponentenkonfiguration ausführen, müssen Sie das Basisserialisierungsprogramm für die Komponente abrufen und aufrufen. Um das Basisserialisierungsprogramm für die Komponente zu erhalten, rufen Sie die GetSerializer -Methode der IDesignerSerializationManager an Ihre Methodenüberschreibung übergebenen auf. Übergeben Sie der GetSerializer Methode den Typ der Komponente, um die Konfiguration von zu serialisieren, zusammen mit dem Basistyp des Serialisierungsprogramms, den Sie anfordern, der lautet CodeDomSerializer. Rufen Sie die Methode mit dem gleichen Namen auf, den Sie im Basisserialisierungsprogramm überschreiben, und verwenden Sie dabei das - und -Objekt, das IDesignerSerializationManager an Die Methodenüberschreibung übergeben wird. Wenn Sie die Serialize -Methode implementieren, gibt die Serialize -Methode des Basisserialisierungsprogramms ein -Objekt zurück. Der Typ dieses Objekts hängt vom Typ des Basisserialisierers ab, der vom Typ der Komponente abhängt, für die Sie die Werte serialisieren. Wenn Sie die SerializeEvents-, SerializeProperties- oder SerializePropertiesToResources -Methode implementieren, müssen Sie eine neue CodeStatementCollection erstellen, die die generierten Codeanweisungen enthält, und sie an die -Methode übergeben.

3. Wenn Sie eine Basisserialisierungsmethode aufgerufen haben, verfügen Sie über eine CodeStatementCollection , die die anweisungen enthält, die generiert werden sollen, um die Komponente zu initialisieren. Andernfalls sollten Sie eine CodeStatementCollectionerstellen. Sie können dieser Auflistung Objekte hinzufügen CodeStatement , die Anweisungen darstellen, die im Komponentenkonfigurationscode generiert werden sollen.

4. Gibt den zurück, der CodeStatementCollection den Quellcode darstellt, der zum Konfigurieren der Komponente generiert werden soll.

Hinweise für Ausführende

Wenn Sie von CodeDomSerializer erben, müssen die folgenden Member überschrieben werden: Deserialize(IDesignerSerializationManager, Object) und Serialize(IDesignerSerializationManager, Object).

Konstruktoren

Methoden

Gilt für:

Weitere Informationen

• DesignerSerializerAttribute
• Generieren und Kompilieren von dynamischem Quellcode