16

Aprill

Programmeerimine ilma tsükliteta

Marek Tihkan 5 kommentaari

Hiljuti leidsin ühest ajaveebist huvitava artikli nimega “If you are using a loop, you’re doing it wrong” ning autoriks on Chuck Jazdzewski. Selle peamiseks ideeks on kasutada LINQ päringuid tsüklite asemel ja pigistada välja C# 3.0  uutest võimalustest sellest piisavalt, et tsüklit ei ole vajagi.

Ainuke küsimus, mis sellega kerkis on see, et kas koodi loetavus paraneb sellega või halveneb.

foreach (var project in projects)
{
    if (project.EstimatedTime > 10)
        yield return project;
}

või

var result = from project in projects
             where project.EstimatedTime > 10
             select project;

Lugeda tundub selliseid lihtsamaid päringuid veidi parem. Katsetuste käigus selgus, et ilma tsükliteta päris edukalt nagu ikka ei saa – ekraanile tuleks ka midagi trükkida. Seega mängisin veidi ning jõudsin järgmise tulemuseni:

int[] list = new int[] {1,2,3,4,5,6,7,8,9,10}; 

(
    from value in list
    where value % 2 == 1
    select value
).Do(x => Console.WriteLine(x))

Kuna siin seisneb peamine probleem selles, et select‘is ei anna lihtsalt käivitada mingit meetodit, siis tuleb lisada juurde laiendusmeetod IEnumerable<T>-le nimega Do:

static class Extension
{
    public static IEnumerable<T> Do<T>(this IEnumerable<T> list, Action<T> action)
    {
        foreach (T value in list)
        {
            action.Invoke(value);
        }
        return list;
    }
}

Sellele saab kenasti veel mõned overload‘id juurde teha ning nimekirja tagastamine on puhtalt selleks, et saaks teha list.Do(…).Do(…)… Alternatiiv sellele oleks ka teha staatiline klass:

class Command
{
    static public Action<T> Execute<T>(Action<T> action, T value)
    {
        action.Invoke(value);
        return action;
    }
}

Ning siis saame pärida järgnevalt;

(
    from value in list
    where value % 2 == 1
    select Command.Execute((x => Console.WriteLine(x)), value)
).ToList();

Siinjuures peab kindlalt kutsuma lõpus välja mingisuguse meetod, mis sunnib LINQ päringut käivitama.

Ma ei ole kindel, et selline lähenemine oleks kõige mõistlikum, kuid siiski üks võimalikke. Hea oleks kuulda, mida teised arvad sellisest vaatenurgast. Lisaks oleks kasulik teha sellele kiirusetest ja vaadata ka milline IL koodis välja näeb.

Loe veel sarnastel teemadel:

  • Share/Bookmark

KATEGOORIAD » .NET

SILDID » , ,

5 kommentaari

1

Ma arvan, et seda ettekirjutust sõnasõnalt järgida on liiast. Eesmärk on ikkagi kood kõige selgemalt ja ülevaatlikumalt teisele inimlugejale mõistetavaks teha.

Oma viimases projektis kasutan väga ulatuslikult LINQt, ja just tihti IEnumerable laiendusmeetodeid selle query-keele asemel, olenevalt kumb parasjagu loetavam tundub. Tavaliselt on määravaks see, kas päringu lõpus selectitakse midagi uut ja huvitavat või mitte: kui ei, siis tekib kaks mittevajalikku rida alguses ja lõpus:
from x in xs
where tingimused
select x

Näiteks esimene näide oleks minuarust kõige selgem nii:
var result = projects.Where(p => p.EstimatedTime > 10);

Kusjuures kui tegu ei ole suure (näiteks mitme listi üheaegse töötlemisega) avaldisega, siis ühetähelised muutujad soodustavad loetavust, mitte ei sega seda.

Sinu teksti teises pooles toodud leiutis tegevuste käivitamiseks tundub lausa hirmus..
( from value in list where value % 2 == 1 select Command.Execute((x => Console.WriteLine(x)), value) ).ToList();
peidab sügavale rea keskele ära kogu info selle kohta, mis tehakse! Arvan, et siin on ikkagi kõige parem ja loetavam kasutada lihtsalt foreach loopi:
foreach (int i in list.Where(x => x % 2 == 1))
Console.WriteLine(i);

Teine võimalus oleks kasutada juba olemasolevat Listi (aga mitte IEnumerable) meetodit ForEach, mis võtab Action tüüpi funktsiooni, mida iga elemendiga käivitada.
list.Where(x => x % 2 == 1).ToList().ForEach(x => Console.WriteLine(x));

Mõlemad on veidi selgemad ja lühemad, sest nendes ei ole mitmeid sulge ja üksteise sisse peidetud avaldisi – saab lugeda vasakult paremale ja ülevalt alla. Aga isiklikult pean siin kõige selgemaks ikkagi foreach loopi.

mattias
11:00, 16. aprill

2

Jah, see näide oli toodud juba olemasolevaid meetodeid kasutadaes.

Selle ForEachi (Do nime all) oled juba valmis kirjutanud :)

mattias
12:15, 16. aprill

3

Küllap tuleb mõne aja pärast APIsse. C# meeskond võiks kuhugi üles panna ka hääletuse teemal, milliseid funktsioonidest puudust tuntakse, sest puudu on ka palju teisi kasulikke laiendusmeetodeid, mis võiks ise kirjutamise asemel standard librarys olla.
Näiteks minimaalse väärtusega objekti tagastamine (mitte selle väärtuse), kus objekt -> väärtus funktsioon on parameetriks, erinevad tükeldamised jms.

mattias
13:08, 16. aprill

4

Viimane variant on juba suhteliselt mõnus,
list.Where(x => x % 2 == 1).ToList().ForEach(x => Console.WriteLine(x));
kuigi mind häirib selle juures ToList() meetod. Veel parem oleks midagi sellist:
list.Where(x => x % 2 == 1).ForEach(x => Console.WriteLine(x));

Marek Tihkan
11:32, 16. aprill

5

“Selle ForEachi (Do nime all) oled juba valmis kirjutanud”

Seda ma panin tähele isegi. Kuigi imestan, et miks seda praeguses API-s pole.

Marek Tihkan
12:28, 16. aprill

Lisa kommentaar

  • * Kuvatakse kommentaari juures
  • * Ei publitseerita