WorkflowInvoker.InvokeAsync Metoda

Reference

Definice

Obor názvů:: System.Activities

Sestavení:: System.Activities.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Vyvolá pracovní postup asynchronně pomocí vzoru asynchronního návrhu založeného na událostech.

Přetížení

InvokeAsync(TimeSpan, Object)	Vyvolá pracovní postup asynchronně se zadaným intervalem časového limitu a jedinečným identifikátorem.
InvokeAsync(IDictionary<String,Object>, TimeSpan)	Vyvolá pracovní postup asynchronně se zadanými IDictionary<TKey,TValue> vstupními parametry a zadaným intervalem časového limitu.
InvokeAsync(IDictionary<String,Object>, Object)	Vyvolá pracovní postup asynchronně pomocí zadaných IDictionary<TKey,TValue> vstupních parametrů a jedinečného identifikátoru.
InvokeAsync()	Vyvolá asynchronně pracovní postup.
InvokeAsync(Object)	Vyvolá pracovní postup asynchronně pomocí zadaného jedinečného identifikátoru.
InvokeAsync(IDictionary<String,Object>)	Vyvolá pracovní postup asynchronně pomocí zadaných IDictionary<TKey,TValue> vstupních parametrů.
InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)	Vyvolá pracovní postup asynchronně se zadanými IDictionary<TKey,TValue> vstupními parametry, zadaným intervalem časového limitu a jedinečným identifikátorem.
InvokeAsync(TimeSpan)	Vyvolá pracovní postup asynchronně se zadaným intervalem časového limitu.

Poznámky

Pokud chcete být upozorněni na dokončení pracovního postupu, zpracujte .InvokeCompleted Pokud chcete nakonfigurovat interval časového limitu, ve kterém se musí pracovní postup dokončit, použijte jedno z InvokeAsync přetížení, které přebírají TimeSpan.

Tato metoda vyvolá pracovní postup asynchronně pomocí vzoru asynchronního návrhu založeného na událostech. Další informace najdete v tématu Přehled asynchronního vzoru založeného na událostech.

InvokeAsync(TimeSpan, Object)

Vyvolá pracovní postup asynchronně se zadaným intervalem časového limitu a jedinečným identifikátorem.

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)

Parametry

timeout: TimeSpan

Interval, ve kterém se pracovní postup musí dokončit, než bude přerušen a TimeoutException vyvolán.

userState: Object

Objekt zadaný uživatelem, který slouží k odlišení této konkrétní asynchronní operace vyvolání od jiných aktuálních asynchronních operací vyvolání.

Příklady

Následující příklad vyvolá pracovní postup, který se skládá z LongRunningDiceRoll aktivity. Aktivita LongRunningDiceRoll má dva výstupní argumenty, které představují výsledky operace hodu kostkou. Po dokončení pracovního postupu se načtou v obslužné rutině InvokeCompleted .

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 == true)
    {
        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.");

Poznámky

Parametr userState musí být jedinečný ve všech aktuálně spuštěných InvokeAsync operacích pro aktuální aktivitu. Pokud userState není jedinečný, ArgumentException je vyvolán. userState slouží k identifikaci pracovního postupu v InvokeCompleteda ke zrušení pracovního postupu pomocí CancelAsync.

Pokud chcete být upozorněni na dokončení pracovního postupu, zpracujte .InvokeCompleted Pokud se pracovní postup nedokončí v zadaném intervalu časového limitu, pracovní postup se přeruší a TimeoutException vyvolá se.

Poznámka

Vyvolá TimeoutException se pouze v případě, že uběhl časový limit a pracovní postup se během provádění stane nečinný. Pracovní postup, který trvá déle, než je zadaný časový limit, se úspěšně dokončí, pokud pracovní postup nebude nečinný.

Tato metoda vyvolá pracovní postup asynchronně pomocí asynchronního vzoru návrhu založeného na událostech. Další informace najdete v tématu Přehled asynchronního vzoru založeného na událostech.

Platí pro

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Vyvolá pracovní postup asynchronně se zadanými IDictionary<TKey,TValue> vstupními parametry a zadaným intervalem časového limitu.

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)

Parametry

inputs: IDictionary<String,Object>

Slovník vstupních parametrů pracovního postupu s klíčem podle názvu argumentu.

timeout: TimeSpan

Interval, ve kterém se pracovní postup musí dokončit, než bude přerušen a TimeoutException vyvolán.

Příklady

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 == true)
    {
        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.");

Poznámky

Poznámka

Tato metoda ukládá do úlohy, která vrací všechny výjimky nesouvisejí s používáním, které může vyvolat synchronní protějšek metody. Pokud je ve vrácené úloze uložena výjimka, bude tato výjimka vyvolána při čekání na úkol. Výjimky použití, například ArgumentException, jsou stále vyvolány synchronně. Informace o uložených výjimkách najdete v tématu Výjimky vyvolané nástrojem Invoke(IDictionary<String,Object>, TimeSpan).

Platí pro

InvokeAsync(IDictionary<String,Object>, Object)

Vyvolá pracovní postup asynchronně pomocí zadaných IDictionary<TKey,TValue> vstupních parametrů a jedinečného identifikátoru.

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)

Parametry

inputs: IDictionary<String,Object>

Slovník vstupních parametrů pracovního postupu s klíčem podle názvu argumentu.

userState: Object

Objekt zadaný uživatelem, který slouží k odlišení této konkrétní asynchronní operace vyvolání od jiných aktuálních asynchronních operací vyvolání.

Příklady

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 == true)
    {
        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.");

Poznámky

Platí pro

InvokeAsync()

Vyvolá asynchronně pracovní postup.

public:
 void InvokeAsync();

public void InvokeAsync ();

member this.InvokeAsync : unit -> unit

Public Sub InvokeAsync ()

Příklady

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 == true)
    {
        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.");

Poznámky

Platí pro

InvokeAsync(Object)

Vyvolá pracovní postup asynchronně pomocí zadaného jedinečného identifikátoru.

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

public void InvokeAsync (object userState);

member this.InvokeAsync : obj -> unit

Public Sub InvokeAsync (userState As Object)

Parametry

userState: Object

Objekt zadaný uživatelem, který slouží k odlišení této konkrétní asynchronní operace vyvolání od jiných aktuálních asynchronních operací vyvolání.

Příklady

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 == true)
    {
        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.");

Poznámky

Parametr userState musí být jedinečný ve všech aktuálně spuštěných InvokeAsync operacích pro aktuální aktivitu. userState Pokud parametr není jedinečný, ArgumentException vyvolá se parametr . userState slouží k identifikaci pracovního postupu v InvokeCompleteda ke zrušení pracovního postupu pomocí CancelAsync.

Platí pro

InvokeAsync(IDictionary<String,Object>)

Vyvolá pracovní postup asynchronně pomocí zadaných IDictionary<TKey,TValue> vstupních parametrů.

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))

Parametry

inputs: IDictionary<String,Object>

Slovník vstupních parametrů pracovního postupu s klíčem podle názvu argumentu.

Příklady

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 == true)
    {
        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.");

Poznámky

Platí pro

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

Vyvolá pracovní postup asynchronně se zadanými IDictionary<TKey,TValue> vstupními parametry, zadaným intervalem časového limitu a jedinečným identifikátorem.

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)

Parametry

inputs: IDictionary<String,Object>

Slovník vstupních parametrů pracovního postupu s klíči podle názvu argumentu.

timeout: TimeSpan

Interval, ve kterém musí být pracovní postup dokončen před jeho přerušením a TimeoutException vyvolán.

userState: Object

Uživatelem zadaný objekt, který slouží k odlišení této konkrétní asynchronní vyvolání operace od jiných aktuálních asynchronních vyvolání operací.

Příklady

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 == true)
    {
        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.");

Poznámky

Parametr userState musí být jedinečný pro všechny aktuálně spuštěné InvokeAsync operace pro aktuální aktivitu. Pokud userState není jedinečný, ArgumentException je vyvolán. userState slouží k identifikaci pracovního postupu v InvokeCompleteda ke zrušení pracovního postupu pomocí CancelAsync.

Poznámka

Vyvolá TimeoutException se pouze v případě, že vyprší interval časového limitu a pracovní postup se během provádění stane nečinný. Pracovní postup, který trvá déle než zadaný interval časového limitu k dokončení, je úspěšně dokončen, pokud pracovní postup není nečinný.

Platí pro

InvokeAsync(TimeSpan)

Vyvolá pracovní postup asynchronně se zadaným intervalem časového limitu.

public:
 void InvokeAsync(TimeSpan timeout);

public void InvokeAsync (TimeSpan timeout);

member this.InvokeAsync : TimeSpan -> unit

Public Sub InvokeAsync (timeout As TimeSpan)

Parametry

timeout: TimeSpan

Interval, ve kterém musí být pracovní postup dokončen před jeho přerušením a TimeoutException vyvolán.

Příklady

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 == true)
    {
        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.");

Poznámky

Poznámka

Tato metoda ukládá do úlohy, která vrací všechny výjimky nepouužování, které může vyvolat synchronní protějšek metody. Pokud je do vrácené úlohy uložena výjimka, bude tato výjimka vyvolána, když je úloha očekávána. Výjimky použití, jako ArgumentExceptionje , se stále vyvolává synchronně. Informace o uložených výjimkách najdete v tématu Výjimky vyvolané nástrojem Invoke(TimeSpan).

Platí pro

Sdílet prostřednictvím

WorkflowInvoker.InvokeAsync Metoda

Definice

Přetížení

Poznámky

InvokeAsync(TimeSpan, Object)

Parametry

Příklady

Poznámky

Platí pro

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Parametry

Příklady

Poznámky

Platí pro

InvokeAsync(IDictionary<String,Object>, Object)

Parametry

Příklady

Poznámky

Platí pro

InvokeAsync()

Příklady

Poznámky

Platí pro

InvokeAsync(Object)

Parametry

Příklady

Poznámky

Platí pro

InvokeAsync(IDictionary<String,Object>)

Parametry

Příklady

Poznámky

Platí pro

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

Parametry

Příklady

Poznámky

Platí pro

InvokeAsync(TimeSpan)

Parametry

Příklady

Poznámky

Platí pro

Váš názor

Další materiály