ContextStack Classe

Definizione

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à
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 Context proprietà viene fornito da un IDesignerSerializationManager oggetto per condividere le informazioni sull'utilizzo per alcuni serializzatori.

Uno stack di contesto è utile perché il processo di serializzazione di un documento di progettazione può essere annidato in modo approfondito 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 la restituzione di una chiamata a un serializzatore annidato.

In genere, gli oggetti nello stack contengono informazioni sul contesto dell'oggetto corrente che viene 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 sull'oggetto, rimuove le informazioni di contesto dallo stack. Spetta all'implementazione di ogni serializzatore determinare quali oggetti vengono inseriti in questo stack.

Ad esempio, un oggetto con una proprietà denominata Enabled ha un tipo di dati .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é viene richiesto solo di scrivere il Boolean valore. Per fornire queste informazioni al serializzatore, il serializzatore padre può eseguire il Enabled push di un PropertyDescriptor oggetto che punta alla 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)

Si applica a

Vedi anche