Egenskaper för arbetsflödeskörning

Via trådlokal lagring (TLS) upprätthåller CLR en körningskontext för varje tråd. Den här körningskontexten styr välkända trådegenskaper som trådidentiteten, den omgivande transaktionen och den aktuella behörighetsuppsättningen utöver användardefinierade trådegenskaper som namngivna fack.

Till skillnad från program som är direkt inriktade på CLR är arbetsflödesprogram hierarkiskt begränsade träd med aktiviteter som körs i en trådagnostisk miljö. Detta innebär att standard-TLS-mekanismerna inte kan användas direkt för att avgöra vilken kontext som finns i omfånget för en viss arbetsuppgift. Två parallella exekveringsgrenar kan till exempel använda olika transaktioner, men schemaläggaren kan sammanfläta deras körning på samma CLR-tråd.

Egenskaper för arbetsflödeskörning ger en mekanism för att lägga till kontextspecifika egenskaper i en aktivitets miljö. Detta gör att en aktivitet kan deklarera vilka egenskaper som finns i omfånget för dess underträd och ger även krokar för att konfigurera och riva ned TLS för att korrekt samverka med CLR-objekt.

Skapa och använda egenskaper för arbetsflödeskörning

Egenskaper för arbetsflödeskörning implementerar gränssnittet IExecutionProperty vanligtvis, men egenskaper som fokuserar på meddelanden kan istället implementera ISendMessageCallback och IReceiveMessageCallback. Skapa en arbetsflödeskörningsegenskap genom att skapa en klass som implementerar IExecutionProperty-gränssnittet och implementera medlemmarna SetupWorkflowThread och CleanupWorkflowThread. Dessa medlemmar ger utförandeegenskapen möjlighet att korrekt konfigurera och nedmontera trådens lokala lagring under varje arbetscykel i aktiviteten som innehåller egenskapen, inklusive alla underordnade aktiviteter. I det här exemplet skapas en ConsoleColorProperty som ställer in Console.ForegroundColor.

class ConsoleColorProperty : IExecutionProperty  
{  
    public const string Name = "ConsoleColorProperty";  
  
    ConsoleColor original;  
    ConsoleColor color;  
  
    public ConsoleColorProperty(ConsoleColor color)  
    {  
        this.color = color;  
    }  
  
    void IExecutionProperty.SetupWorkflowThread()  
    {  
        original = Console.ForegroundColor;  
        Console.ForegroundColor = color;  
    }  
  
    void IExecutionProperty.CleanupWorkflowThread()  
    {  
        Console.ForegroundColor = original;  
    }  
}  

Författare av aktiviteter kan använda den här egenskapen genom att registrera den i aktivitetens exekveraåterställning. I det här exemplet definieras en ConsoleColorScope aktivitet som registrerar ConsoleColorProperty genom att lägga till den i Properties samlingen av den aktuella NativeActivityContext.

public sealed class ConsoleColorScope : NativeActivity  
{  
    public ConsoleColorScope()  
        : base()  
    {  
    }  
  
    public ConsoleColor Color { get; set; }  
    public Activity Body { get; set; }  
  
    protected override void Execute(NativeActivityContext context)  
    {  
        context.Properties.Add(ConsoleColorProperty.Name, new ConsoleColorProperty(this.Color));  
  
        if (this.Body != null)  
        {  
            context.ScheduleActivity(this.Body);  
        }  
    }  
}  

När aktivitetens huvuddel startar en puls av arbete, anropas SetupWorkflowThread-metoden för egenskapen, och när arbetspulsen är klar anropas CleanupWorkflowThread. I det här exemplet skapas ett arbetsflöde som använder en Parallel aktivitet med tre grenar. De första två grenarna använder ConsoleColorScope-aktiviteten, men den tredje grenen använder inte aktiviteten. Alla tre grenarna innehåller två WriteLine aktiviteter och en Delay aktivitet. Parallel När aktiviteten körs körs de aktiviteter som finns i grenarna växelvis, men när varje underaktivitet körs tillämpas rätt konsolfärg av ConsoleColorProperty.

Activity wf = new Parallel  
{  
    Branches =
    {  
        new ConsoleColorScope  
        {  
            Color = ConsoleColor.Blue,  
            Body = new Sequence  
            {  
                Activities =
                {  
                    new WriteLine  
                    {  
                        Text = "Start blue text."  
                    },  
                    new Delay  
                    {  
                        Duration = TimeSpan.FromSeconds(1)  
                    },  
                    new WriteLine  
                    {  
                        Text = "End blue text."  
                    }  
                }  
            }  
        },  
        new ConsoleColorScope  
        {  
            Color = ConsoleColor.Red,  
            Body = new Sequence  
            {  
                Activities =
                {  
                    new WriteLine  
                    {  
                        Text = "Start red text."  
                    },  
                    new Delay  
                    {  
                        Duration = TimeSpan.FromSeconds(1)  
                    },  
                    new WriteLine  
                    {  
                        Text = "End red text."  
                    }  
                }  
            }  
        },  
        new Sequence  
        {  
            Activities =
            {  
                new WriteLine  
                {  
                    Text = "Start default text."  
                },  
                new Delay  
                {  
                    Duration = TimeSpan.FromSeconds(1)  
                },  
                new WriteLine  
                {  
                    Text = "End default text."  
                }  
            }  
        }  
    }  
};  
  
WorkflowInvoker.Invoke(wf);  

När arbetsflödet anropas skrivs följande utdata till konsolfönstret.

Start blue text.  
Start red text.  
Start default text.  
End blue text.  
End red text.  
End default text.  

Egenskaper för arbetsflödeskörning kan användas av anpassade aktivitetsförfattare, och de tillhandahåller även mekanismen för hantering av aktiviteter såsom CorrelationScope och TransactionScope.

Se även

• IExecutionProperty
• IPropertyRegistrationCallback
• RegistrationContext