CodeDomSerializer Clase

Definición

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

Herencia

Object

CodeDomSerializer

Herencia

Object

CodeDomSerializerBase

CodeDomSerializer

Derivado

System.ComponentModel.Design.Serialization.CollectionCodeDomSerializer

System.Windows.Forms.Design.ImageListCodeDomSerializer

System.Workflow.ComponentModel.Serialization.DependencyObjectCodeDomSerializer

Ejemplos

En el ejemplo de código siguiente se muestra cómo crear un serializador CodeDOM personalizado que deriva de 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

Comentarios

Puede implementar un personalizado CodeDomSerializer para controlar la generación de código de inicialización de componentes para un tipo de componente en tiempo de diseño.

Para implementar un personalizado CodeDomSerializer para un tipo, debe hacer lo siguiente:

1. Defina una clase que se derive de CodeDomSerializer.

2. Implemente invalidaciones de método para los métodos de serialización o deserialización. (Consulte la información siguiente para obtener más información).

3. Asocie la implementación personalizada CodeDomSerializer a un tipo de componente mediante .DesignerSerializerAttribute

Para implementar un método de serialización para generar código de configuración para un componente:

1. Dentro de una clase que deriva de CodeDomSerializer, invalide un método de serialización o deserialización adecuado de la clase base.

2. Si desea que el serializador predeterminado genere instrucciones de código que realicen la configuración de componente predeterminada, debe obtener y llamar al serializador base para el componente. Para obtener el serializador base para el componente, llame al GetSerializer método de la IDesignerSerializationManager invalidación del método pasado. Pase el GetSerializer método el tipo del componente para serializar la configuración de, junto con el tipo base de serializador que solicita, que es CodeDomSerializer. Llame al método del mismo nombre que está reemplazando en el serializador base, utilizando el IDesignerSerializationManager objeto y pasado a la invalidación del método . Si va a implementar el Serialize método , el Serialize método del serializador base devolverá un objeto . El tipo de este objeto depende del tipo de serializador base que depende del tipo de componente del que se serializan los valores de . Si va a implementar el SerializeEventsmétodo , SerializePropertieso SerializePropertiesToResources , debe crear un nuevo CodeStatementCollection para que contenga las instrucciones de código generadas y pasarla al método .

3. Si ha llamado a un método de serializador base, tendrá un CodeStatementCollection que contiene las instrucciones que se van a generar para inicializar el componente. De lo contrario, debe crear un CodeStatementCollection. Puede agregar CodeStatement objetos que representan instrucciones para generar en el código de configuración del componente a esta colección.

4. Devuelve que CodeStatementCollection representa el código fuente que se va a generar para configurar el componente.

Notas a los implementadores

Al heredar de CodeDomSerializer, es necesario reemplazar los miembros siguientes: Deserialize(IDesignerSerializationManager, Object) y Serialize(IDesignerSerializationManager, Object).

Constructores

Métodos

Se aplica a

Consulte también

• DesignerSerializerAttribute
• Generación y compilación dinámicas de código fuente