DT blogi

Task Parallel Library ja PLINQ aktsioonis

Gunnar — Thu, 17 May 2012 10:37:34 +0000

Paralleelarvutus on pühat eesmärki täitev asi – hoiame oma niigi voolu õgivad protsessorid ja arvutustuumad maksimaalselt midagi asjalikku tegemas. Teen selle kohta ühe näite, mis aitab paremini mõista, kuidas .NET raamistikus tänaste vahenditega paralleelarvutus käib. Ühtlasi mõõdame oma tulemusi ja katsed viime läbi reaalelulise koodi peal.

.NET raamistikus on kaks vahendit paralleelarvutuse jaoks:

TPL on võimas raamistik, mis muudab paralleelarvutuse meie jaoks palju lihtsamaks ja koodi paremini mõistetavaks. PLINQ toob LINQ peale võimaluse töödelda andmeid paralleelselt. Seega võime öelda, et TPL on ülesannete põhine ja PLINQ on andmepõhine paralleelarvutus.

RSS-agregaator ja selle mõõtmine

Meie näite südamikuks on RSS-agregaator, mis loeb andmebaasist sisse blogide loendi, tuvastab nende RSS-i aadressid ning loeb sisse viimased postitused. Positused, mida veel andmebaasis pole, lisatakse sinna ära.

internal class FeedClient
{
private readonly INewsService _newsService;
private const int FeedItemContentMaxLength = 255;

public FeedClient()
{
ObjectFactory.Initialize(container =>
{
container.PullConfigurationFromAppConfig = true;
});

_newsService = ObjectFactory.GetInstance();
}

public void Execute()
{
var blogs = _newsService.ListPublishedBlogs();

for (var index = 0; index Count; index++)
{
ImportFeed(blogs[index]);
}
}

private void ImportFeed(BlogDto blog)
{
if(blog == null)
return;
if (string.IsNullOrEmpty(blog.RssUrl))
return;

var uri = new Uri(blog.RssUrl);
SyndicationContentFormat feedFormat;

feedFormat = SyndicationDiscoveryUtility.SyndicationContentFormatGet(uri);

if (feedFormat == SyndicationContentFormat.Rss)
ImportRssFeed(blog);
if (feedFormat == SyndicationContentFormat.Atom)
ImportAtomFeed(blog);

}

private void ImportRssFeed(BlogDto blog)
{
var uri = new Uri(blog.RssUrl);
var feed = RssFeed.Create(uri);

foreach (var item in feed.Channel.Items)
{
SaveRssFeedItem(item, blog.Id, blog.CreatedById);
}
}
private void ImportAtomFeed(BlogDto blog)
{
var uri = new Uri(blog.RssUrl);
var feed = AtomFeed.Create(uri);

foreach (var item in feed.Entries)
{
SaveAtomFeedEntry(item, blog.Id, blog.CreatedById);
}
}
}

Mõõtmiseks kasutame sellist vahendit nagu Stopwatch klass. Programmi alguses lööme kella käima ja kui programm lõpetab, paneme kella seisma.

Seriaalne agregeerimine

Esiteks mõõdame ära tulemused, mida annab eeltoodud kood. Seal tehakse kõik sammud järjest ja korraga midagi käima ei lasta. See tähendab seda, et kõik RSS-id laetakse alla üksteise järel ja nende sisu salvestatakse andmebaasi samuti üks postitus korraga.

Mõõtmisel saame tulemuseks 25.46 sekundit.

Task parallelism

Meie esimene analüüsiülesanne on leida üles punkt, kus me saaksime eraldada muust koodist sõltumatud osad. Need osad koodist võime me käima lasta paralleelselt (me võime ka sõltuvustega osi paralleelselt käivitada, kuid see on oluliselt keerukam ja riskantsem tegevus). Meie juhul on selleks kohaks, kus võiksime kaaluda paralleeltöötlust, näiteks RSS-ide lugemine ja andmebaasi sisestamine.

internal class FeedClient
{
private readonly INewsService _newsService;
private const int FeedItemContentMaxLength = 255;

public FeedClient()
{
ObjectFactory.Initialize(container =>
{
container.PullConfigurationFromAppConfig = true;
});

_newsService = ObjectFactory.GetInstance();
}

public void Execute()
{
var blogs = _newsService.ListPublishedBlogs();
var tasks = new Task[blogs.Count];

for (var index = 0; index Count; index++)
{
tasks[index] = new Task(ImportFeed, blogs[index]);
tasks[index].Start();
}

Task.WaitAll(tasks);
}
private void ImportFeed(object blogObject)
{
if(blog == null)
return;
var blog = (BlogDto)blogObject;
if (string.IsNullOrEmpty(blog.RssUrl))
return;

var uri = new Uri(blog.RssUrl);
SyndicationContentFormat feedFormat;

feedFormat = SyndicationDiscoveryUtility.SyndicationContentFormatGet(uri);

if (feedFormat == SyndicationContentFormat.Rss)
ImportRssFeed(blog);
if (feedFormat == SyndicationContentFormat.Atom)
ImportAtomFeed(blog);
}

private void ImportRssFeed(BlogDto blog)
{
var uri = new Uri(blog.RssUrl);
var feed = RssFeed.Create(uri);

foreach (var item in feed.Entries)
{
SaveAtomFeedEntry(item, blog.Id, blog.CreatedById);
}
}
}

Muudatused, mis me tegime, on lihtsad – me defineerisime RSS-ide importimiseks eraldi ülesanded ja lasime need paralleelselt käima. Seejärel jäime ootama, millal kõik ülesanded on tehtud.

Kui aega mõõdame, siis saame tulemuseks 17.57 sekundit.

Data parallelism

Järgmiseks vaatame, kas meil on veel kohti, kus võime korraga mitut asja teha. Nagu tellitult vaatab meile vastu RSS-ist loetud postituste loend. Kuna postituste sisestamine andmebaasi on tehtav isolatsioonis (me ei kasuta teiste postituste andmeid), siis proovime, mis juhtub, kui laseme postitused andmebaasi sisestada paralleelselt.

internal class FeedClient
{
private readonly INewsService _newsService;
private const int FeedItemContentMaxLength = 255;

public FeedClient()
{
ObjectFactory.Initialize(container =>
{
container.PullConfigurationFromAppConfig = true;
});

_newsService = ObjectFactory.GetInstance();
}

public void Execute()
{
var blogs = _newsService.ListPublishedBlogs();
var tasks = new Task[blogs.Count];

for (var index = 0; index Count; index++)
{
tasks[index] = new Task(ImportFeed, blogs[index]);
tasks[index].Start();
}

Task.WaitAll(tasks);
}
private void ImportFeed(object blogObject)
{
if(blog == null)
return;
var blog = (BlogDto)blogObject;
if (string.IsNullOrEmpty(blog.RssUrl))
return;

var uri = new Uri(blog.RssUrl);
SyndicationContentFormat feedFormat;

feedFormat = SyndicationDiscoveryUtility.SyndicationContentFormatGet(uri);

if (feedFormat == SyndicationContentFormat.Rss)
ImportRssFeed(blog);
if (feedFormat == SyndicationContentFormat.Atom)
ImportAtomFeed(blog);
}

private void ImportRssFeed(BlogDto blog)
{
var uri = new Uri(blog.RssUrl);
var feed = RssFeed.Create(uri);

feed.Channel.Items.AsParallel().ForAll(a =>
{
SaveRssFeedItem(a, blog.Id, blog.CreatedById);
});
}
private void ImportAtomFeed(BlogDto blog)
{
var uri = new Uri(blog.RssUrl);
var feed = AtomFeed.Create(uri);

feed.Entries.AsParallel().ForAll(a =>
{
SaveAtomFeedEntry(a, blog.Id, blog.CreatedById);
});
}
}

Siin kasutasime TPL asemel PLINQ, sest selle abil on meil mugavam lasta andmete peal operatsioone tööle.

Tulemuseks saame 11.22 sekundit.

Tulemused

Kui tulemused graafikule toome, samme sellise graafiku.

Näeme, et RSS-ide allalaadimine paralleelselt annab meile umbes poolteist korda võitu. Kui andmete uuendamise ka paralleelseks muudame saame võrreldes algsega 2.3 kordse võidu.

Kokkuvõte

Me alustasime tavalise lihtsa koodiga, mis tegi kõike samme järjest. Esimese muudatusena viisime me paralleelsele kujule andmete allalaadimise ja uuendamise. Andmete uuendamine jäi seejuures ikkagi järjestikuseks. Seejärel viisime ka andmete uuendamise paralleelsele kujule ja saime veel võitu. Meil läks seekord hästi, sest erinevate thread-ide peal jooksev kood ei vajanud midagi, mis sealt välja jääks.

Kui oma lähtekoodi hoolikalt analüüsida, siis võib tihti leida kohti, kus paralleeltöötlus võib rakenduse jõudlust tõsta. Oluline on need kohad tuvastada ja mõõta ära, kas paralleelsus annab midagi juurde või ei.

Loe lisaks

Kuidas alustada node.js arendust

Gunnar — Tue, 15 May 2012 06:38:51 +0000

Node.js on Chrome nimelise brauseri JavaScripti mootoril põhinev õhuke platvorm, mille otstarbeks on skaleeritavate võrgurakenduste jooksutamine. Ümar definitsioon küll, kuid kui node.js olemusse süveneme, siis näeme, et selle abil lahendab ära päris palju probleeme.

Mis on node.js?

Oma sisemuses toimib node.js lihtsasti. Me kirjutame valmis skripti, mis töötleb HTTP-pöördumisi ning saadab neile välja vastuseid. Veebiserver, mis node.js koosseisu kuulub, on äärmiselt lakooniline ja väike. Iga pöördumine töödeldakse ära erineva thread-i peal ja see tähendab võimet vastata korraga suurele arvule pöördumistele. Pöördumised on õhukesed ja jätavad maksimaalselt ruumile tööle, mis nende raames peab juhtuma.

Kuidas node.js käima saada?

node.js saamiseks tuleb minna node.js kodukale ja see allalaadida. Installer on mõned megad suur ja mingiks suuremaks installiks ja konfimiseks pole seega vaja valmistuda. Failid paigaldatakse kataloogi

C:\Program Files\nodejs

Seal asub ka node.exe, mis on siis protsess, mille all skriptid jooksevad.

Laiendused ja arendus

Kuigi node.js jaoks tuleb juba installeriga terve hulk laiendusi, saab neid iseseisvalt juurde laadida node.js laienduste hoidlast. Laiendusi saab allalaadida ka käsurealt töötava klientrakenduse abil. Kellel huvi, siis vaadaku olemasolevate laienduste nimekirja.

Päris hea ülevaate node.js kasutamisest annab Patterns & Practices Symposium Online 2012 raames Yavor Georgievi poolt antud loeng “node.js on Azure”.

Ma arvan, et otste lahti tegemiseks on nüüd piisav info koos ja selleks, et

Näiterakendus

Et Node.js pole ressurside osas nõudlik, sobib see ideaalselt näiteks lihtsate HTTP-põhiste rakenduste jaoks, mis jooksevad eraldi thread-ide peal. Kuigi node.js peal saab teha palju muud tarka ja kasulikku, toon ma näitena välja lihtsa skripti, mis kuvab pöördumiste vastuseks pilte veebiserveri juurkataloogist.

Viimistlemata kood, mida mu pisike server kasutab, näeb välja selline:

var sys = require("sys"),
http = require("http"),
url = require("url"),
path = require("path"),
fs = require("fs");

http.createServer(function (request, response) {
var uri = url.parse(request.url).pathname;
var filename = path.join(process.cwd(), uri);
path.exists(filename, function(exists) {
if(!exists) {
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not Found\n");
response.end();
return;
}

if(path.extname(filename) != '.jpg')
{
response.writeHead(500, {"Content-Type": "text/plain"});
response.write("Forbidden extension!\n");
response.end();
return;
}

fs.readFile(filename, "binary", function(err, file) {
if(err) {
response.writeHead(500, {"Content-Type": "text/plain"});
response.write("error: " + err + "\n");
response.end();
return;
}

response.writeHead(200, {"Content-Type": "image/jpeg"});
response.write(file, "binary");
response.end();
});
});

}).listen(8124);

console.log('Server running at http://127.0.0.1:8124/');

Selle koodi käivitan käsurealt käsuga node.exe test.js. Järgmiseks ühendan ennast brauseriga aadressile http://localhost:8124/ ja küsin faili nimega something.txt. Tulemus, nagu oodata, on selline:

Kui aga küsin rabbit.jpg, siis saan sellise tulemuse:

Lõpetuseks

node.js peale saab ehitada erinevaid rakendusi ja saadaval on lausa veebiraamistikud, mille abil saab node.js peale kirjutada MVC-mustrit järgivaid veebirakendusi, kuid peamiselt on node.js eesmärk siiski pakkuda serveripoolset punkti, kus mingeid toiminguid kiiresti ja eriliste ressursikuludeta toime pannakse. Muide, node.js töötab ka Windows Azure peal ja ka Microsoft panustab sellesse, et node.js oleks tulevikus paremini toetatud nii Visual Studio kui ka Windows Azure peal.

Loe lisaks

WiFi-kindel tapeet Prantsusmaalt

Gunnar — Sat, 12 May 2012 10:00:30 +0000

Ajal, mis küberkaitsekeskuseid rajatakse nii siin- kui sealpool suurt lompi, püüavad teemasse anda oma panuse ka Prantsusmaa teadlased, kes leiutavad WiFi-kindlat tapeeti. Eesmärk – kaitsta oma WiFi-võrku võõraste eest.

Võlutapeet on tehtud hõbeda kristallidest, mis peatavad raadiolained sagedustel, mida kasutavad WiFi-ruuterid. Grenoble tehnoloogiainstituudi uurija Pierre Lemaitre-Auger näeb tapeedis kaitseinglit WiFi-ruuteritele, mida muidu võidakse häkkida. Kummalisel kombel jääb arutluskäik seinte juurde, kuid laest ja põrandast juttu ei tehta.

Tapeet, millest saaks arvatavasti ka tinamütsikesi teha, tuleb müüki järgmise aasta alguses. Hinnad pidid tulema keskmised ning samas oluliselt odavamad kui varasematel katsetel.

Põhjalikumat lugemist pakub CIO artikkel Wi-Fi-Blocking Wallpaper Keeps Your Signal In, Intruders Out.

Loe lisaks

TechEd Europe 2012 sinu taskus

Gunnar — Thu, 10 May 2012 07:26:52 +0000

Midagi uut TechEd Europe 2012 külastajatele. Need, kellel Windows Phone 7, Android või iPhone taskus, saavad omale koostada seminaride kava telefoni peal. Selleks on eraldi rakendus, mis jagab seminari kohta ka muud infot, töötavad meeldetuletused ja kuskilt hakkas silma ka live tile tugi.

Microsoft on teinud diili sellise firmaga nagu Falafel Software, kelle üks teenustest on EventBoard. EventBoard on professionaalne organiseerijatele mõeldud teenus oma sündmuste toetamiseks. Osalejatele on kogu lõbu loomikult tasuta.

Nii palju kui EventBoardiga hommikul mängida jõudsin tundus see igati mugav ja asjalik rakendus olevat. Millestki sellisest olen puudust tundnud mitmetel suurematel sündmustel osaledes.

Vist parim on see, et oma seminarikava saab kokku laduda otse mobiili peal ja selleks saab kasutada igasuguseid hetki, kus midagi tarka niigi teha pole.

Üks hea lisa, mis EventBoardil on, on Twitteri ja mõnede muude infokanalite tugi. Juba praegu saab TechEd Europe 2012 kohta vaadata jooksvat infot, mis uueneb päris tihedalt.

Allalaadimine: EventBoard

Loe lisaks

Arenduskeskkonna optimeerimine: Kuidas suurendada paralleelselt kompileeritavate projektide arvu

Gunnar — Fri, 04 May 2012 06:16:05 +0000

Et reede kiiremini õhtusse saada, siis annan väikse vihje Visual Studio projektide kompileerimise kiirendamiseks. Sedapuhku pole tegu peenema putitamise ja ehitamisega – pääseme optsioonide dialoogiga.

Visual Studio lubab öelda, et mitu projekti ta korraga kompileerib. Seejuures loomulikult arvestab ta ka projektide sõltuvusi (üks viitab teisele ja seega üks kompileeritakse enne teist valmis). Paralleelselt kompileeritavate projektide arvu saab määrata Tool => Options menüü alt.

Visual Studio 2010: Build and Run jaotusest saab määrata korraga
kompileeritavate projektide maksimaalse arvu.

See väike optimeerimise trikk töötab hästi lahendustega, kus on mitu sõltumatut projekti. Kõik projektid, mis teineteisest ei sõltu või millel puuduvad omavahelised sõltuvused või on neil ühesugused sõltuvused teistest projektidest, saab samaaegselt kompileerima panna.

Kellele ikka tundub, et justkui asjad masinal ei edene piisavas tempos, siis peenemast optimeerimisest saab lugeda minu postitust Arenduskeskkonna optimeerimine: Visual Studio lahenduste kompileerimine.

Loe lisaks

Kuidas ehitada wizard ASP.NET MVC peal

Gunnar — Thu, 03 May 2012 21:53:42 +0000

Ja jõudsingi õhtuga ideelahendusest esimese tulemuseni. Läbi mitmete katsete kirjutasingi valmis ASP.NET MVC jaoks mõeldud wizard-ite baasklassid. Seejuures jäin kenasti püsima raamistiku mängureeglitesse ja mingeid jubedaid häkke ei teinud. Anna oma esimesed bitid-baidid teilegi vaadata ja torkida.

Esmane lahendus wizarditele

Minu lahendus on lihtne – meil on baasklass wizard-ite kontrollerite jaoks. Kõik need kontrollerid laiendavad samat baasklassi ning ütlevad sellele ette oma “suure” mudeli tüübi.

Kontrolleri aktsioonid kasutavad wizard-i sammude kuvamiseks eraldi alammudeleid. Need kõik pärivad ennast wizard-i mudelite jaoks mõeldud baasklassist. Kui pöördumine tuleb kontrollerisse sisse, siis püüab kontroller “suure” mudeli valmis luua kas operaatoriga new või siis serialiseeritud andmetest.

Kui pöördumisele hakatakse vastust saatma, siis otsib baasklass üles mudeli küljest välja, kuhu “suur” mudel maha salvestatakse ning nii elab “suur” mudel üle lehtede vahel liikumise.

Sammude mudelid

Wizard-i sammude jaoks mõeldud baasklass on selline:

public class WizardStepBase
{
[NonSerialized]
public string SerializedModel;
}

Seda kasutavad mu wizard-i kaks sammu:

[Serializable]
public class Step1AskName : WizardStepBase
{
[Required]
public string FirstName { get; set; }

[Required]
public string LastName { get; set; }
public string SSN { get; set; }
}

[Serializable]
public class Step2AskPhone : WizardStepBase
{
[Required]
public string WorkPhone { get; set; }

public string HomePhone { get; set; }
public string MobilePhone { get; set; }
}

Siiani peaks kõik lihtne olema – mudelite baasklass sisaldab lihtsalt atribuuti mudeli serialiseeritud versiooni kohta.

Wizardi kontroller

Järgmiseks see kõikse keerukam osa – wizard-i baasklass.

public class WizardControllerBase : Controller where T : new()
{
protected T WizardModel { get; set; }

protected override void Initialize(RequestContext requestContext)
{
base.Initialize(requestContext);

var serializedModel = requestContext.HttpContext.Request["SerializedModel"];
if (string.IsNullOrEmpty(serializedModel))
{
WizardModel = new T();
return;
}

WizardModel = Deserialize(serializedModel);
}

protected override void OnActionExecuting(ActionExecutingContext filterContext)
{
var parameters = filterContext.ActionParameters;
if (parameters.Count == 0)
return;

var publicPropertyMask = BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty;
var wizardProperties = WizardModel.GetType().GetProperties(publicPropertyMask);
if (wizardProperties.Length == 0)
return;

foreach (var key in parameters.Keys)
foreach (var property in wizardProperties)
if (property.PropertyType == parameters[key].GetType())
{
var type = WizardModel.GetType();
type.InvokeMember(property.Name, publicPropertyMask, null, WizardModel, new object[] { parameters[key] });
}

base.OnActionExecuting(filterContext);
}

protected override void OnResultExecuting(ResultExecutingContext filterContext)
{
var result = filterContext.Result as ViewResult;
if (result != null)
if (result.Model is WizardStepBase)
{
var stepModel = (WizardStepBase)result.Model;
stepModel.SerializedModel = Serialize();
}

base.OnResultExecuting(filterContext);
}

[NonAction]
private string Serialize()
{
var serializer = new XmlSerializer(typeof(T));
var builder = new StringBuilder(10000);

using (var writer = new StringWriter(builder))
{
serializer.Serialize(writer, WizardModel);
}

var serializedBytes = Encoding.UTF8.GetBytes(builder.ToString());

return Convert.ToBase64String(serializedBytes);
}

[NonAction]
public T Deserialize(string serializedModel)
{
var deserializedBytes = Convert.FromBase64String(serializedModel);
var modelString = Encoding.UTF8.GetString(deserializedBytes);
var serializer = new XmlSerializer(typeof(T));

using (var reader = new StringReader(modelString))
{
return (T)serializer.Deserialize(reader);
}
}
}

Ja siin on minu lihtne kontroller, mis küsib esimese sammu vaates külastaja nime ja teises sammus tahab teada telefoninumbreid. Sealt liigub see edasi andmete kinnitamise vaatesse, kus saab kontrollida, kas kõik andmed tulid ootuspäraselt kaasa.

public class HomeController : WizardControllerBase
{
[HttpGet]
public ActionResult Index()
{
return View("Step1AskName", WizardModel.AskNameStep);
}

[HttpPost]
public ActionResult Index(Step1AskName nameStep)
{
if (!ModelState.IsValid)
return View("Step1AskName", nameStep);

return View("Step2AskPhone", WizardModel.AskPhoneStep);
}

[HttpPost]
public ActionResult Step2(Step2AskPhone phoneStep)
{
if (!ModelState.IsValid)
return View("Step2AskPhone", phoneStep);

return View("Confirm", WizardModel);
}
}

Sellega on nüüd suurem tegemine möödas. Asi, millele rõhku tuleb pöörata, on see, et kasutage alati WizardModel omadust, kui alammudelitega töötate kontrolleris, sest muidu pole wizard-ite kontroller kursis sellega, et midagi muutus.

Vaated

Vaated võite lasta omale Visual Studio poolt genereerida, kuid arvestage sellega, et HTML-i vormidele tuleb ette öelda õige kontrolleri aktsioon, kuhu andmed postitada. Ma tegin viimaseks vaate, kus on näha kõik andmed, mis sai sisestatud:

Paistab, et saimegi toimima. Teha on veel paar riukalikumat sammu, kuid need jätan järgmisteks päevadeks.

Kokkuvõtteks

Kuigi ASP.NET MVC ei paku välja kõiki ASP.NET Forms tugevaid külgi, on raamistik piisavalt paindlik, et sellega kõik viisakalt lahendatud saaks. Tuleb enne vaid võtta pits ja aru pidada. Nagu ennist mainisin, siis inspiratsiooni sain ühest suht jubedast wizard-i lahendusest ja paari tunniga sain valmis oma lahenduse, mis oluliselt viisakam.

Loe lisaks

Ideelahendus: Wizardi loomine ASP.NET MVC peal

Gunnar — Thu, 03 May 2012 16:36:47 +0000

Tänase läbukoodi ülesande lahendusele mõeldes tuli üks päris hea mõte pähe. Kuulasin juttu ühest olemasolevast lahendusest ja mõtlesin vaikselt, et kuidas seal iga samm järgmist keerukamaks muudab. Ja pärast koduteel tuligi vist õige mõte pähe. Proovime nüüd ideelisel tasemel lahendada ära ASP.NET MVC raamistikus wizard-ite loomise.

Probleemid

ASP.NET Formsi all on wizard-ite tegemine lihtne. Meil on olemas kuvakontroller selle jaoks ning selle sees paneme paika, millist pilti ühe või teise sammu juures kuvatakse ning milliseid toiminguid tehakse. Natukese CSS-iga mängimist ja ongi täitsa nagu päris.

MVC peal meil midagi sellist ettevalmistatud kujul olemas ei ole. On olemas erinevaid lahendusi, mida kaaluda, kuid lõppeks peame ikkagi ise ehitama üles millegi, mis on mõistlik ja inimesi peast halliks ei aja.

Probleemkohad arendaja jaoks on siin järgmised:

milline mudel või millised mudelid tuleks koostada wizard-i jaoks?
kuidas mudeli andmeid hoida pöördumiste vahel?
kuidas kirjutada wizard-i jaoks midagi lakoonilist ja lihtsat?
kuidas see miski võiks olla korduvkasutatav?
kuidas teha nii, et selle miski silumine ja parandamine oleks lihtne?

Ma leidsin sellele esmase ideelise lahenduse. Panen selle kirja ja siis mõtlen edasi, kuidas asi selliselt vormistada, et nii võikski jääda.

Minu lahenduse idee

Ühe pealtnäha lihtsa lahenduse wizard-i ehitamiseks pakub välja Nadeem Afana oma postituses Create a Wizard in ASP.NET MVC 3. Siin kasutatakse AJAX-it, et korjata vormile kogu mudeli jaoks vajalikud andmed kokku. Seejärel alles saadetakse andmed serverisse. Tundub hea lahendus, kuid mida teha suvalise mobiili korral, millel mõni keskmiselt juust mobiilidele mõeldud brauser peal jookseb?

Minu lahenduse skeem on selline.

Me jaotame wizard-i taga oleva mudeli mitmeks pisemaks mudeliks, millele vastavad vaated. Iga vaade tegeleb selle mudeliga, mida temal vaja on. Selleks, et erinevate sammude jooksul sisestatud andmed oleksid meile koguaeg saadaval serveri pooles, siis loome wizard-i mudeli, mille omadusteks on sammude mudelid.

Selleks, et seni kasutaja poolt sisestatu säiliks, võtame ASP.NET Forms maailmast appi ViewState-i idee. Iga sammu mudeli koosseisu kuulub ka meie suur mudel serialiseeritud kujul. Seda hoiame mõnel peidetud väljal krüpteerituna peidus. Sessiooni me midagi ei kirjuta, sest kasutajal võib wizard olla samal ajal avatud rohkem kui ühes brauseri aknas.

Selleks, et saaksime “suure” mudeli tagasi, kasutame model binder-it, mis taastab deserialiseerimise teel suure mudeli ja uuendab seda vormilt tulnud andmetega. Seega me võime kõikide sammude vaadetes tegeleda suure mudeliga ja sealt lihtsalt sammudele vastavaid omadusi vaadetes renderdada. Samuti võime esikohale tuua just alammudelid ja hoida nendel viidet suurele mudelile, kust saame vajadusel andmeid juurde küsida mõne sammu jaoks.

Mis edasi?

Edasi ma tuulutan korraks aju ja mõtlen natukene järgi, kuidas see asi valmis kirjutada. Sealt edasi saab mu Visual Studio 11 jälle loovas protsessis osaleda kui koodi kallale asun. Kui midagi üldist siit ei sünni, siis vähemasti saame siit kokku lahenduse, mida kasvõi lahenduse mustri osas annab oma ASP.NET MVC projektides kasutada.

Kui kellelegi mõni kasvõi uitmõte pähe turgatas praegu, siis andke kommentaariumi vahendusel märku. Äkki saame kamba peale midagi veel vingemat kokku.

Loe lisaks

DevReach 2012 registreerumine on avatud!

Gunnar — Thu, 03 May 2012 08:57:44 +0000

Eelmisel aastal külastasin elus esimest korda sellist vahvad .NET seminari nagu DevReach 2011, mis toimub meile sobivalt ja soodsalt Bulgaaria pealinnas Sofias. Teleriku eestvedamisel toimuvale seminarile tuuakse kohale mitmed maailma suurnimed. Käesoleva aasta DevReach-ile registreerumine on alanud ja oodatud on kõik huvilised ka Eestist.

Miks minna?

Toon välja mõned põhjused:

esitajate nimekiri on tavaliselt olnud väga tugev (need nimed peaks tuttavad olema kõikidele tõsistele .NET arendajatele: Todd Anglin, Maarten Balliauw, Richard Campbell, Stephen Forte, Scott Hanselman, Tim Huckaby, Jesse Liberty, lisaks kohaliku regiooni staarid),
hinnad on soodsas – VIP-pass, mille koosseisu kuulub osalemine ürituse sulgemispeol, maksab alla 200EUR (arenenud Lääne-Euroopas tähendab analoogse seminari tavapilet umbes 600-800 EUR suurust väljaminekut),
bulgaarlased on sõbralikud inimesed ja uusi kontakte luua on seal küllaltki lihtne, samuti on head võimalused leida omale uusi sõpru arendajate hulgast,
hinnad on Bulgaarias suhteliselt madalad ja kui hoida turistilõksudest eemale, siis pole ka õhtused õlleringid oluline kulu.

Sofia ja Tallinna vahel on lennuühendus päris hea ja hätta ei jää ka kohapealse majutusega. Hotelle on nii vanemast ajastust – rajud raudbetoon monstrumid – kui ka uuemad ja moodsamad (Radisson jt).

Millal toimub?

Toimumisajaks on 04.10-05.10.2012. See tähendab seda, et Tallinnast on mõttekas startida 03.10 ja tagasi Tallinnasse võiks ennast sättida 06.10 pealelõunal – jääb natuke aega Sofias ringi kolamiseks ka. Kes muidugi soovib linnaga tutvust teha pikemalt, siis võib ka 07.10.2012 peale tagasituleku plaanida. Mina saaksin omalt poolt rääkida kohalikega, kes meile äkki linna oleks nõus tutvustama.

Kohalik olustik on mulle selge ja kellel on plaani tulla, siis võite julgesti minuga ühenduda. Oskan eelmise aasta põhjalt küsimused ära vastata, mis esimest korda minejatel tekkida võivad.

On Eestist veel minejaid?

Peale sinu läheb sinna veel inimesi, kuigi arvatavasti mitte just palju. Loodame, et sellel aastal tuleb minuga kaasa paar kolleegi, kes .NET ja SharePoint arendusega tegelevad. Kui oled ka huviline, siis võtame teisi tulijaid ka hea meelega kampa.

Registreerumine

DevReach registreerumise lehel saate valida omale sobiva paketi ning selle eest tasuda. Kohapeal tuleb ennast esimesel päeval kirja panna ning tavaliselt saab registreerumisel ka kotikese nänni. Särk, pastakas, kaustik ja mingid kohalikus keeles värvilised paberid, pluss loomulikult seminari kava. Praegu on hinnad ülisoodsad ja kes kiirustab, see saab ka hea kokkuhoiu!

Loe lisaks

ASP.NET MVC: Laiendusmeetod kuupäevade vahemiku kuvamiseks

Gunnar — Wed, 02 May 2012 09:55:28 +0000

Mul oli vaja ühel ASP.NET MVC lehel kuvada sündmuste algus- ja lõpuaegu. Vaja oli pisut peenemat kuupäevade formaati, mis ei kuvaks kuupäeva kaks korda kui sündmus algab ja lõppeb samal päeval. Kirjutasin selle jaoks lihtsa laiendusmeetodi. Kellel vaja, siis võite siit julgelt haarata.

Väljund on samal päeval algava ja lõppeva sündmuse korral midagi sellist (stiilide abil saate endale sobiva välimuse külge ajada):

Kui algus ja lõpp on erinevatel kuupäevadel, siis on väljund selline:

Vaate sees on sellist asja niisama lihtsasti ilma loetavust kaotamata ära ei tee. Teine asi, mis räägib vaate sees formaatimise vastu antud juhul, on see, et taolist kuupäevade kuvamise loogikat võib meil kasutada mitu vaadet.

Laiendusmeetod ise on selline:

public static MvcHtmlString DisplayDateRange(this HtmlHelper helper, DateTime from, DateTime to)
{
var buffer = new StringBuilder(100);

buffer.Append(@"

"dateRange"">");

buffer.Append(from.ToShortDateString());
buffer.Append(" ");
buffer.Append(from.ToShortTimeString());
buffer.Append(" - ");

if (from.Date == to.Date)
{
buffer.Append(to.ToShortTimeString());
}
else
{
buffer.Append(to.ToShortDateString());
buffer.Append(" ");
buffer.Append(to.ToShortTimeString());
}

buffer.Append("

");

return new MvcHtmlString(buffer.ToString());
}

Lisa see mõnda staatilisse klassi, et saaksid seda vaadetes kasutada.

Loe lisaks

Objektipuu laadimine ja salvestamine kettale

Gunnar — Wed, 02 May 2012 09:11:43 +0000

Kui ehitame mõnda demorakendust, siis pole meil tihti mõtet kulutada aega andmebaasi ehitamisele. Ma näitan ette ühe lihtsa nõksu kuidas oma objektid faili salvestada ja kuidas neid failist laadida. Ühtlasi seletan paari sõnaga ära mõned serialiseerimise nüansid .NET raamistikus.

Alustuseks veidike serialiseerimisest. Serialiseerimise formaate on .NET-is mitmeid: kahendformaat, XML ja JSON. Kindlasti leidub serialiseerijaid veelgi. Viimased kaks kapriissemad, sest ringviiteid objektide graafis esineda ei tohi. See tähendab seda, et invoiceRow.Invoice ja invoice.Rows pole toetatud, sest mööda sama graafi liikudes saame tagasi jõuda algpunkti. Binary format on sellest probleemist vaba ja selle võtame kasutusele ka käesolevas näites.

Enne kui salvestamise kallale asume, on meil vaja klassi, mis hoiaks objekte, mis ei pruugi teineteisega seotud olla. Näiteks arved ja kasutajad võivad täiesti sõltumatut elu elada samas objektmudelis. Meie andmehoidja võiks välja näha midagi sellist:

[Serializable]
internal class SampleDataHolder
{
public IList Contacts { get; set; }
public IList Invoices { get; set; }

public SampleDataHolder()
{
Contacts = new List();
Invoices = new List();
}
}

Järgmiseks kirjutame klassi, mis andmeid laeb ja maha salvestab. Selle klassi käest saame alati küsida andmeid hoidva objekti:

public class SampleDataProvider
{
private static SampleDataHolder _dataHolder;
private static string _dataFilePath;

static SampleDataProvider()
{
var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase);
_dataFilePath = Path.Combine(path, "data.dat").Replace("file:\\", "");
}

public static SampleDataHolder DataHolder
{
get
{
if (_dataHolder != null)
return _dataHolder;

if (!File.Exists(_dataFilePath))
{
_dataHolder = new SampleDataHolder();
return _dataHolder;
}

using (var file = File.OpenRead(_dataFilePath))
{
var formatter = new BinaryFormatter();
_dataHolder = (SampleDataHolder)formatter.Deserialize(file);
}

return _dataHolder;
}
}

public static void Save()
{
if (File.Exists(_dataFilePath))
File.Delete(_dataFilePath);

using (var file = File.OpenWrite(_dataFilePath))
{
var formatter = new BinaryFormatter();
formatter.Serialize(file, DataHolder);
}
}
}

Igal korral kui oleme teinud muudatusi objektipuusse kutsume Save() meetodi, et andmed maha salvestada. Kui on piisavalt kindlust rakenduse tulevase ülesehituse osas, siis võib siin ehitatud klassid peita ka andmekihi klassidesse ajutise lahendusena ära. Hiljem, kui rakenduse osas selgus majas on, saab luua päris andmebaasi toe ning rakendus ise ei pruugi sellest muutusest midagi teada.

Loe lisaks