ContextStack Classe

Definizione

Spazio dei nomi:

System.ComponentModel.Design.Serialization

Assembly:

System.ComponentModel.TypeConverter.dll

Origine:

ContextStack.cs

Fornisce un oggetto stack che può essere utilizzato da un serializzatore per rendere disponibili delle informazioni a serializzatori annidati.

public ref class ContextStack sealed

public sealed class ContextStack

type ContextStack = class

Public NotInheritable Class ContextStack

Ereditarietà

Object

ContextStack

Esempio

Nell'esempio di codice seguente viene illustrato l'uso di un ContextStack oggetto per eseguire il push e quindi rimuovere 10 valori.

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

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

int main()
{
   // Create a ContextStack.
   ContextStack^ stack = gcnew ContextStack;
   
   // Push ten items on to the stack and output the value of each.
   for ( int number = 0; number < 10; number++ )
   {
      Console::WriteLine( "Value pushed to stack: {0}", number );
      stack->Push( number );
   }
   
   // Pop each item off the stack.
   Object^ item = nullptr;
   while ( (item = stack->Pop()) != 0 )
      Console::WriteLine( "Value popped from stack: {0}", item );
}

using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Windows.Forms;

namespace ContextStackExample
{
    class ContextStackExample
    {
        [STAThread]
        static void Main(string[] args)
        {            
            // Create a ContextStack.
            ContextStack stack = new ContextStack();
            
            // Push ten items on to the stack and output the value of each.
            for( int number = 0; number < 10; number ++ )
            {
                Console.WriteLine( "Value pushed to stack: "+number.ToString() );
                stack.Push( number );
            }

            // Pop each item off the stack.
            object item = null;
            while( (item = stack.Pop()) != null )
                Console.WriteLine( "Value popped from stack: "+item.ToString() );
        }
    }
}

Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.ComponentModel.Design.Serialization

Module ContextStackExample

    Sub Main()
        ' Create a ContextStack.
        Dim stack As New ContextStack

        ' Push ten items on to the stack and output the value of each.
        Dim number As Integer
        For number = 0 To 9
            Console.WriteLine(("Value pushed to stack: " + number.ToString()))
            stack.Push(number)
        Next number

        ' Pop each item off the stack.        
        Dim item As Object = stack.Pop()
        While item IsNot Nothing
            Console.WriteLine(("Value popped from stack: " + item.ToString()))
            item = stack.Pop()
        End While
    End Sub

End Module

Commenti

Alcuni serializzatori richiedono informazioni sul contesto di un oggetto per mantenere il loro stato in modo appropriato. La ContextStack classe consente a un serializzatore di impostare i dati sul contesto di un oggetto serializzatore in uno stack in cui un altro serializzatore può accedervi. Il valore della proprietà viene fornito da un IDesignerSerializationManager oggetto per condividere informazioni sull'uso Context per alcuni serializzatori.

Uno stack di contesto è utile perché il processo di serializzazione di un documento di progettazione può essere annidato in modo profondo e gli oggetti a ogni livello di annidamento possono richiedere informazioni di contesto per mantenere correttamente lo stato dell'oggetto. Un serializzatore può impostare un oggetto contesto sullo stack prima di richiamare un serializzatore annidato. Ogni oggetto impostato sullo stack deve essere rimosso dal serializzatore che lo imposta dopo una chiamata a un serializzatore annidato restituisce.

In genere, gli oggetti nello stack contengono informazioni sul contesto dell'oggetto corrente serializzato. Un serializzatore padre aggiunge informazioni di contesto allo stack sull'oggetto successivo da serializzare, chiama un serializzatore appropriato e, quando il serializzatore termina l'esecuzione nell'oggetto, rimuove le informazioni di contesto dallo stack. È fino all'implementazione di ogni serializzatore per determinare quali oggetti vengono inseriti nello stack.

Ad esempio, un oggetto con una proprietà denominata Enabled ha un tipo di dati di Boolean. Se un serializzatore scrive questo valore in un flusso di dati, potrebbe essere necessario includere il contesto o il tipo di proprietà che sta scrivendo. Il serializzatore non dispone di queste informazioni, tuttavia, perché è incaricato solo di scrivere il Boolean valore. Per fornire queste informazioni al serializzatore, il serializzatore padre può eseguire il push di un PropertyDescriptor oggetto che punta alla Enabled proprietà nello stack di contesto.

Costruttori

ContextStack()

Inizializza una nuova istanza della classe ContextStack.

Proprietà

Current	Ottiene l'oggetto corrente nello stack.
Item[Int32]	Ottiene l'oggetto nello stack al livello specificato.
Item[Type]	Ottiene il primo oggetto nello stack che eredita o implementa il tipo specificato.

Metodi

Append(Object)	Accoda un oggetto alla fine dello stack anziché inserirlo all'inizio dello stack.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
Pop()	Rimuove l'oggetto corrente dallo stack restituendone il valore.
Push(Object)	Inserisce l'oggetto specificato nello stack.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Vedi anche

• IDesignerSerializationManager