WorkflowInvoker.InvokeAsync Methode

Definitie

Naamruimte:: System.Activities

Assembly:: System.Activities.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Roept asynchroon een werkstroom aan met behulp van het asynchrone ontwerppatroon op basis van gebeurtenissen.

Overloads

Name	Description
InvokeAsync(TimeSpan, Object)	Roept een werkstroom asynchroon aan met het opgegeven time-outinterval en een unieke id.
InvokeAsync(IDictionary<String,Object>, TimeSpan)	Roept een werkstroom asynchroon aan met de opgegeven IDictionary<TKey,TValue> invoerparameters en het opgegeven time-outinterval.
InvokeAsync(IDictionary<String,Object>, Object)	Roept een werkstroom asynchroon aan met behulp van de opgegeven IDictionary<TKey,TValue> invoerparameters en een unieke id.
InvokeAsync()	Roept asynchroon een werkstroom aan.
InvokeAsync(Object)	Roept asynchroon een werkstroom aan met behulp van de opgegeven unieke id.
InvokeAsync(IDictionary<String,Object>)	Roept een werkstroom asynchroon aan met behulp van de opgegeven IDictionary<TKey,TValue> invoerparameters.
InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)	Roept asynchroon een werkstroom aan met de opgegeven IDictionary<TKey,TValue> invoerparameters, het opgegeven time-outinterval en een unieke id.
InvokeAsync(TimeSpan)	Roept een werkstroom asynchroon aan met het opgegeven time-outinterval.

Opmerkingen

Als u een melding wilt ontvangen wanneer de werkstroom is voltooid, moet u dit verwerken InvokeCompleted. Als u een time-outinterval wilt configureren waarin de werkstroom moet worden voltooid, gebruikt u een van de InvokeAsync overbelastingen die een TimeSpan.

Met deze methode wordt een werkstroom asynchroon aangeroepen met behulp van het asynchrone ontwerppatroon op basis van gebeurtenissen. Zie Asynchroon patroonoverzicht op basis van gebeurtenissenvoor meer informatie.

InvokeAsync(TimeSpan, Object)

Roept een werkstroom asynchroon aan met het opgegeven time-outinterval en een unieke id.

public:
 void InvokeAsync(TimeSpan timeout, System::Object ^ userState);

public void InvokeAsync(TimeSpan timeout, object userState);

member this.InvokeAsync : TimeSpan * obj -> unit

Public Sub InvokeAsync (timeout As TimeSpan, userState As Object)

Parameters

timeout: TimeSpan

Het interval waarin de werkstroom moet worden voltooid voordat deze wordt afgebroken en er een TimeoutException wordt gegenereerd.

userState: Object

Een door de gebruiker verstrekt object dat wordt gebruikt om deze specifieke asynchrone aanroepbewerking te onderscheiden van andere huidige asynchrone aanroepbewerkingen.

Voorbeelden

In het volgende voorbeeld wordt een werkstroom aangeroepen die bestaat uit een LongRunningDiceRoll activiteit. De LongRunningDiceRoll activiteit heeft twee uitvoerargumenten die de resultaten van de dobbelsteendraaibewerking vertegenwoordigen. Wanneer de werkstroom is voltooid, worden deze opgehaald in de InvokeCompleted handler.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Opmerkingen

De userState parameter moet uniek zijn voor alle actieve InvokeAsync bewerkingen voor de huidige activiteit. Als userState dit niet uniek is, wordt er een ArgumentException gegenereerd. userState wordt gebruikt om de werkstroom in InvokeCompletedte identificeren en om de werkstroom te annuleren met behulp van CancelAsync.

Als u een melding wilt ontvangen wanneer de werkstroom is voltooid, moet u dit verwerken InvokeCompleted. Als de werkstroom niet binnen het opgegeven time-outinterval wordt voltooid, wordt de werkstroom afgebroken en wordt er een TimeoutException gegenereerd.

Note

De TimeoutException wordt alleen gegooid als de tijdslimiet is verstreken en de werkstroom tijdens de uitvoering inactief wordt. Een workflow die langer duurt dan het opgegeven time-outinterval, wordt succesvol voltooid als de workflow niet inactief raakt.

Van toepassing op

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Roept een werkstroom asynchroon aan met de opgegeven IDictionary<TKey,TValue> invoerparameters en het opgegeven time-outinterval.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout);

public void InvokeAsync(System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout);

member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> * TimeSpan -> unit

Public Sub InvokeAsync (inputs As IDictionary(Of String, Object), timeout As TimeSpan)

Parameters

inputs: IDictionary<String,Object>

De woordenlijst met invoerparameters voor de werkstroom, met de sleutel op argumentnaam.

timeout: TimeSpan

Het interval waarin de werkstroom moet worden voltooid voordat deze wordt afgebroken en er een TimeoutException wordt gegenereerd.

Voorbeelden

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Opmerkingen

Note

Deze methode slaat op in de taak die alle uitzonderingen voor niet-gebruik retourneert die de synchrone tegenhanger van de methode kan genereren. Als er een uitzondering wordt opgeslagen in de geretourneerde taak, wordt deze uitzondering gegenereerd wanneer de taak wordt gewacht. Gebruiksonderzondering, zoals ArgumentException, worden nog steeds synchroon gegenereerd. Zie de uitzonderingen die zijn gegenereerd door Invoke(IDictionary<String,Object>, TimeSpan)de opgeslagen uitzonderingen voor de opgeslagen uitzonderingen.

Van toepassing op

InvokeAsync(IDictionary<String,Object>, Object)

Roept een werkstroom asynchroon aan met behulp van de opgegeven IDictionary<TKey,TValue> invoerparameters en een unieke id.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, System::Object ^ userState);

public void InvokeAsync(System.Collections.Generic.IDictionary<string,object> inputs, object userState);

member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> * obj -> unit

Public Sub InvokeAsync (inputs As IDictionary(Of String, Object), userState As Object)

Parameters

inputs: IDictionary<String,Object>

De woordenlijst met invoerparameters voor de werkstroom, met de sleutel op argumentnaam.

userState: Object

Een door de gebruiker verstrekt object dat wordt gebruikt om deze specifieke asynchrone aanroepbewerking te onderscheiden van andere huidige asynchrone aanroepbewerkingen.

Voorbeelden

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Opmerkingen

Van toepassing op

InvokeAsync()

Roept asynchroon een werkstroom aan.

public:
 void InvokeAsync();

public void InvokeAsync();

member this.InvokeAsync : unit -> unit

Public Sub InvokeAsync ()

Voorbeelden

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Opmerkingen

Deze methode slaat op in de taak die alle uitzonderingen voor niet-gebruik retourneert die de synchrone tegenhanger van de methode kan genereren. Als er een uitzondering wordt opgeslagen in de geretourneerde taak, wordt deze uitzondering gegenereerd wanneer de taak wordt gewacht. Gebruiksonderzondering, zoals ArgumentException, worden nog steeds synchroon gegenereerd. Zie de uitzonderingen die zijn gegenereerd door Invoke()de opgeslagen uitzonderingen voor de opgeslagen uitzonderingen.

Van toepassing op

InvokeAsync(Object)

Roept asynchroon een werkstroom aan met behulp van de opgegeven unieke id.

public:
 void InvokeAsync(System::Object ^ userState);

public void InvokeAsync(object userState);

member this.InvokeAsync : obj -> unit

Public Sub InvokeAsync (userState As Object)

Parameters

userState: Object

Een door de gebruiker verstrekt object dat wordt gebruikt om deze specifieke asynchrone aanroepbewerking te onderscheiden van andere huidige asynchrone aanroepbewerkingen.

Voorbeelden

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Opmerkingen

De userState parameter moet uniek zijn voor alle actieve InvokeAsync bewerkingen voor de huidige activiteit. Als de userState parameter niet uniek is, wordt er een ArgumentException gegenereerd. userState wordt gebruikt om de werkstroom in InvokeCompletedte identificeren en om de werkstroom te annuleren met behulp van CancelAsync.

Van toepassing op

InvokeAsync(IDictionary<String,Object>)

Roept een werkstroom asynchroon aan met behulp van de opgegeven IDictionary<TKey,TValue> invoerparameters.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs);

public void InvokeAsync(System.Collections.Generic.IDictionary<string,object> inputs);

member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> -> unit

Public Sub InvokeAsync (inputs As IDictionary(Of String, Object))

Parameters

inputs: IDictionary<String,Object>

De woordenlijst met invoerparameters voor de werkstroom, met de sleutel op argumentnaam.

Voorbeelden

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Opmerkingen

Deze methode slaat op in de taak die alle uitzonderingen voor niet-gebruik retourneert die de synchrone tegenhanger van de methode kan genereren. Als er een uitzondering wordt opgeslagen in de geretourneerde taak, wordt deze uitzondering gegenereerd wanneer de taak wordt gewacht. Gebruiksonderzondering, zoals ArgumentException, worden nog steeds synchroon gegenereerd. Zie de uitzonderingen die zijn gegenereerd door Invoke(IDictionary<String,Object>)de opgeslagen uitzonderingen voor de opgeslagen uitzonderingen.

Van toepassing op

InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)

Roept asynchroon een werkstroom aan met de opgegeven IDictionary<TKey,TValue> invoerparameters, het opgegeven time-outinterval en een unieke id.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout, System::Object ^ userState);

public void InvokeAsync(System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout, object userState);

member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> * TimeSpan * obj -> unit

Public Sub InvokeAsync (inputs As IDictionary(Of String, Object), timeout As TimeSpan, userState As Object)

Parameters

inputs: IDictionary<String,Object>

De woordenlijst met invoerparameters voor de werkstroom, met de sleutel op argumentnaam.

timeout: TimeSpan

Het interval waarin de werkstroom moet worden voltooid voordat deze wordt afgebroken en er een TimeoutException wordt gegenereerd.

userState: Object

Een door de gebruiker verstrekt object dat wordt gebruikt om deze specifieke asynchrone aanroepbewerking te onderscheiden van andere huidige asynchrone aanroepbewerkingen.

Voorbeelden

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Opmerkingen

Note

Van toepassing op

InvokeAsync(TimeSpan)

Roept een werkstroom asynchroon aan met het opgegeven time-outinterval.

public:
 void InvokeAsync(TimeSpan timeout);

public void InvokeAsync(TimeSpan timeout);

member this.InvokeAsync : TimeSpan -> unit

Public Sub InvokeAsync (timeout As TimeSpan)

Parameters

timeout: TimeSpan

Het interval waarin de werkstroom moet worden voltooid voordat deze wordt afgebroken en er een TimeoutException wordt gegenereerd.

Voorbeelden

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Opmerkingen

Note

Deze methode slaat op in de taak die alle uitzonderingen voor niet-gebruik retourneert die de synchrone tegenhanger van de methode kan genereren. Als er een uitzondering wordt opgeslagen in de geretourneerde taak, wordt deze uitzondering gegenereerd wanneer de taak wordt gewacht. Gebruiksonderzondering, zoals ArgumentException, worden nog steeds synchroon gegenereerd. Zie de uitzonderingen die zijn gegenereerd door Invoke(TimeSpan)de opgeslagen uitzonderingen voor de opgeslagen uitzonderingen.

Van toepassing op

Feedback

Is deze pagina nuttig?