Transmite o boot Foo (params []) ca metoda Argument

Există momente în care o metodă trebuie executată de mai multe ori până când aceasta se validează. În cazul meu, există expresii ca bar.Name.Equals ("John Doe") pe care vreau să le rulez și să le rulez până când această expresie este validată.

Ceva asemănător cu:

bool succeeded = TryUntillOk(bar.Name.Equals("John Doe"), 15, 100);

unde TryUntillOk ar fi o metodă care rulează această expresie de 15 ori cu un somn de 100 ms între fiecare apel.

Am citit această listă de răspunsuri la excelent probleme similare, dar în cazul meu nu există nici un delegar standar că această metodă TryUntillOk ar accepta.

Titlul întrebării nu este constructiv. Simțiți-vă liber să o editați :)

0
@GeorgeDuckett DA. Îmi pare rău că nu l-am menționat.
adăugat autor Odys, sursa
Ar fi rulat într-un fir separat? În caz contrar, nu va exista nici o șansă ca valoarea să se schimbe.
adăugat autor George Duckett, sursa

3 răspunsuri

Trebuie să adaptați invocația. Răspunsul lui Jon are lambda invoaction, această versiune separă compararea de la delegat

using System;
using System.Threading;

namespace test
{
    class something
    {
        public String Name;
    }

    class Program
    {
        private delegate bool TryableFunction(String s);

        private static bool TryUntillOk(TryableFunction f, String s, int howoften, int sleepms)
        {
            while (howoften-->0)
            {
                if (f(s)) return true;
                Thread.Sleep(sleepms);
            }
            return false;
        }

        static void Main(string[] args)
        {
            something bar=new something();

            bar.Name="Jane Doe";
            bool succeeded = TryUntillOk(bar.Name.Equals,"John Doe", 15, 100);
            Console.WriteLine("Succeeded with '{0}': {1}",bar.Name,succeeded);

            bar.Name="John Doe";
            succeeded = TryUntillOk(bar.Name.Equals,"John Doe", 15, 100);
            Console.WriteLine("Succeeded with '{0}': {1}",bar.Name,succeeded);
        }


    }
}
0
adăugat
Exact aceasta a fost prima mea încercare. Mai târziu mi-am dat seama că ar putea exista mai multe metode de apel, ceea ce înseamnă că trebuia să declar atât de mulți delegați, ceea ce vreau să evit.
adăugat autor Odys, sursa
... care este exact ceea ce rezolvă versiunea lambda!
adăugat autor Eugen Rieck, sursa

Probabil căutați ceva asemănător:

bool TryRepeatedly(Func condition, int maxRepeats, TimeSpan repeatInterval)
{
    for (var i = 0; i < maxRepeats; ++i)
    {
        if (condition()) return true;
        Thread.Sleep(repeatInterval);//or your choice of waiting mechanism
    }
    return false;
}

Care ar fi invocat după cum urmează:

bool succeeded = TryRepeatedly(() => bar.Name.Equals("John Doe"),
                               15,
                               TimeSpan.FromMilliseconds(100));

The only interesting part here is that you specify the condition as a Func, which is a delegate to a method that takes no parameters and returns a boolean. Lambda expression syntax allows you to trivially construct such a delegate at the call site.

0
adăugat
@GeorgeDuckett îmi pare rău că nu menționez acest lucru. Toate acestea s-ar face în fire de lucru
adăugat autor Odys, sursa
Ar trebui, probabil, să remarcăm că acest lucru se bazează pe ceva extern (thread separat etc), determinând condiția de a evalua în cele din urmă la adevărat.
adăugat autor George Duckett, sursa

Puteți să-l verificați

delegate void d_name(string s);

d_name obj =new d_name(bar.Name.Equals);

bool succeeded = TryUntillOk(obj("John Doe"), 15, 100);

TryUntillOk(obj d,type parameter2,type parameter3 )
{
  //do your work
}  
0
adăugat