Jeg løb fornylig ind i at jeg ville lave et ajax kald ved hjælp af JQuery og $.getJSON, men min action blev aldrig ramt og der blev ikke kastet nogen exceptions. Det viser sig at skyldes at getJSON forsøger at lave kaldet, men hvis det fejler ignorerer den det blot. Løsningen er at for at kunne debugge skal man istedet bruge $.ajax, som gør det muligt at registrere en errorhandler. Herfra kan man så tilgå det response der returneres, og hvis man udskriver det til siden får man en overraskende god fejlside, der gør det nemt at debugge.

Det var ikke et trick jeg fandt beskrevet nogen steder, så jeg synes det var værd at dele - og så er det ellers en af den slags posts jeg tror jeg selv bliver glad for næste gang jeg skal bruge den her lille snippet :-)

$.ajax(
{
    type: "GET",
    url: "/Controller/Action",
    data: { registrationTypeId: selectedValue },
    dataType: "json",
    error: function(xhr, status, error) {
        document.write(xhr.responseText);
    }, success: function(json) {
        alert("Data Returned: " + json);
    }
});

Noget så basalt som validering der på overfladen virker som en simpel ting har alligvel en tendens til at ende med at ende med at blive uskønt i webløsninger. Der er to problemer jeg tit har set når jeg har kigget både mine egne og andres projekter igennem.

1. Man bør implementere sin validering både client- og serverside. Dette fører til at man bryder DRY princippet, og laver valideringen dobbelt i henholdsvis javascript og ens eget CLR language of choise.
2. Om noget er validt er i høj grad afhængig af kontekst  - se who knew domain validation was so hard .

Især punkt 1 er tit en tjørn i øjet på webudviklere, da de færreste synes det er sjovt at lave validering. Ligefrem at skulle gøre det samme to gange kan derfor være en pain - især når det så senere skal vedligeholdes.

Her kommer xVal til undsætning hvis man arbejder med ASP.NET MVC, da det gør det muligt at udtrykke sin validering ved hjælp af attributter man angiver på properties på sine entiteter. Samtidig gør det at man får flyttet sin validering ned i modellen, hvor man gerne vil have den.  Jeg vil undlade at komme med eksempler, da Steve Sanderson allerede har lavet nogle gode eksempler på sin blog. En stor bonus ved frameworket der fortjener at blive nævnt er at det er meget fleksibelt, både i forhold til valg af framework til clientside validering, og når man ønsker at implementere sine egne custom valideringer.

I forhold til punkt 2 bryder xVal umiddelbart med princippet om ikke at ligge valideringen på sine entiteter. Jeg vil imidlertid spille gråzone kortet, idet selve det at foretage valideringen er noget man styrer server- og clientside. Det er dermed helt muligt at lave andre typer af validering også, og anvende xVal specifikt til at validere brugerinput fra formularer.

På mit seneste projekt har jeg kigget nærmere på at lave AOP ved hjælp af henholdsvis PostSharp og Castle Windsors IInterceptor. De to fremgangsmåder har hver sine fordele og ulemper, men begge har også nogle shortcomings.

Castle Windsors bud på AOP virker ved at man implementerer en IInterceptor, hvilket kræver at man skriver en Intercept metode der tager et IInvocation objekt som argument, hvorpå man kan kalde Proceed der hvor metoden skal indkapsles. Interceptoren registreres så for en klasse, hvilket bevirker at alle metoder på klassen indkapsles.
En typisk implementation ser sådan her ud:

public class LoggingInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        // Entry logic
        invocation.Proceed();
        // Exit logic
    }
}

Postsharp, som et et lille framework til at lave AOP i .NET, virker ved at man implementerer en attribut der extender en af frameworkets aspects - eksempelvis OnExceptionAspect, OnMethodInvocationAspect eller OnMethodBoundaryAspect. I og med det er en attribut man implementerer påføres denne blot de metoder man ønsker skal indkapsles.
To helt typiske eksempler kunne være:

public class LoggingAttribute : OnMethodBoundaryAspect   
{       
    public override void OnEntry(MethodExecutionEventArgs eventArgs) { //Entry logic }        
    public override void OnExit(MethodExecutionEventArgs eventArgs) { //Exit logic }   
}

public class LoggingAttribute : OnMethodInvocationAspect   
{
    public override void OnInvocation(MethodInvocationEventArgs eventArgs)       
    {           
        //Entry logic
        eventArgs.Delegate.DynamicInvoke(eventArgs.GetArguments());           
        //Exit logic
    }
}

PostSharp er dermed mere finkornet i forhold til at man kan vælge hvilke metoder der indkapsles, og ved at man implementerer et passende aspect - omvendt er det i scenarier hvor alle metoder skal påvirkes og det virker dejligt ligetil med IInterceptor når amn alligevel bruger castle windsor.

Et punkt hvor castle windsor udmærker sig er at argumenter kan tilgås via IInvocation objektet ud fra navn frem for at de udelukkende kan tilgås via index - som desværre det eneste PostSharp tilbyder. Det er efter min mening en rimelig stor mangel i PostSharp, da det betyder at man ikke kan gøre koden robust i forhold til scenarier hvor et parameters navn er mere pålidelige end index - noget der er typisk i f.eks MVC løsninger.

I et scenarie jeg sad med fornylig var det actions på en controller, der bliver kaldt via reflection af MVC frameworket, som jeg ønskede at indkapsle, således at jeg via AOP kunne styre authorization. Her viste sig nogle uhensigtsmæssighed i begge måder at lave AOP. Det var for det første mere besværligt at finde ud af hvilken action der var kaldt, på grund af begge frameworks egentlig indkapsler de metoder der kalder min action via reflection. Derudover var det svært at lave koden solid i forhold til ændringer i navngivning af controllers og actions - da mine regler for authorization nødvendigvis må bindes op  på hvilken controller/action de gælder for.

Løsningen blev at lave unittests der via reflection verificerer at de authorization regler der er sat op rent faktisk matcher en controller og action. For at sikre at man ikke glemmer at sætte regler op for en given action indførte jeg desuden "secure by default" ved at nægte adgang til actions der ikke er konfigureret authorization for.

Ud af boksen er MVC frameworket udstyret med en AuthorizeAttribute, således at man kan angive på sine actions at det kun er brugere i bestemte roller der har lov at tilgå den.

[Authorize(Roles="Employee")]

Det i sig selv virker smart nok, men hvor tit har du lavet en løsning hvor authentization ikke er mere komplekst end det?

På mit nuværende projekt løb jeg hurtigt på det problem at en bruger godt må tilgå en action, hvis det id metoden tager som parameter er id’et på hans egen bruger. Altså med andre ord, han/hun må godt se egne data.

Jeg ville stadig helst undgå at skulle skrive kode i starten af mine actions til at undersøge den slags, da det er en af de ting der er oplagt at lave ved hjælp af AOP. Da attributter kun kan tage statiske værdier, var det udelukket at løse det ved at lave min egen FilterAttribute. Efter at have været lidt i tænkeboks fandt jeg frem til at bruge Castle Windsors IInterceptor til at lave validering af actions.

public class AuthorizationInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        if (invocation.Arguments != null && invocation.Arguments.Length > 0 && invocation.Arguments[0] != null)
        {
            if (invocation.Arguments[0].GetType() == typeof(RequestContext))
            {
                var context = (RequestContext)invocation.Arguments[0];
                var values = context.RouteData.Values;
                var auth = new AuthorizationManager();

                if (!auth.Authorize((string)values["controller"] + "/" + (string) values["action"], (string) values["id"]))
                {
                    throw new UnauthorizedAccessException("You are not authorized for this action");
                }
            }
        }

        invocation.Proceed();
    }
}

Selve det at lave authorization kan nu implementeres i en separat AuthorizationManager klasse, der også kan bruges i forbindelse med f.eks at generere en menu med de punkter, en bruger har ret til at se.

Efter blandt andet at have ladet mig inspirere af authorization via en config-fil fandt jeg frem til at jeg gerne ville samle konfigurationen, men at jeg dog ville undgå en xml-fil, og istedet have mulighed for at lave mere advanceret authentization. Det førte til nedenstående løsning, som jeg er blevet rimeligt godt tilfreds med, da det giver mig en stor grad af fleksibilitet.

public bool Authorize(string controllerAction, string id)
{
    IPrincipal user = HttpContext.Current.User;
    Employee empl = _repo.GetByUserName(user.Identity.Name);
    var employeeId = 0;
    int.TryParse(id, out employeeId);
    var dic = new Dictionary<string, Predicate<Employee>>
                  {
                      {
                          "Employee/Edit", employee => user.IsInRole(Config.Admin) ||
                                                       (user.IsInRole(Config.Employee) &&
                                                       employee.Id == employeeId)
                          },
                  };

    Predicate<Employee> pred;
    return !dic.TryGetValue(controllerAction, out pred) || pred.Invoke(empl);
}

Forleden sad jeg og bankede hovedet imod en mur i form af et build der skulle konfigureres til at afvikle NUnit tests. Jeg fandt en række forskellige eksempler, men det gav mig alligevel lidt bøvl. Løsningen viste sig imidlertid at være simpel nok, men det er det jo tit når det først virker.

1. Hent og installer MSBuild Community tasks
2. Konfigurer TFSBuild.proj, som findes igennem Team Explorer, under build definitions, hvor der skal tilføjes:

<Target Name="AfterCompile">
    <CreateItem Include="$(OutDir)..\**\*Test.dll">
      <Output TaskParameter="Include" ItemName="TestAssembly" />
    </CreateItem>
    <NUnit
      Assemblies="@(TestAssembly)"
      OutputXmlFile="$(OutDir)UnitTests.xml"
      ContinueOnError="false"
      ToolPath="C:\Program Files (x86)\NUnit 2.5\bin\net-2.0" />   
  </Target>

CreateItem bruges til at skabe en liste over assemblies der som konvention hedder noget med Test.dll til sidst, og denne liste fodres så til NUnit tasken, der desuden skal peges hen til hvor NUnit er installeret.

Efter at konfigurationen var på plads prøvede jeg Build Notification Tool som er en del af TFS powertools – det kan klart anbefales frem for blot at få tilsendt en stribe e-mails når builds er kørt.

Nye frameworks, tools og principper

Starten på det nye år, som samtig har været starten på nyt job for mig, har betydet at det var tid til at lære nogle frameworks at kende som jeg ikke tidligere har brugt professionelt. Det har været rigtigt spændende, men har også fået mit hoved til at eksplodere i forhold til tanken om at skulle blogge om det. Jeg vil derfor skrive lidt om hvad jeg har set på, fordi det nok er en del af de ting bloggen kommer til at omhandle fremadrettet.

Vi er en shop der gør alvor af at arbejde efter agile pricipper så jeg har haft tid til at kigge på ORM, Unit testing, mocking, Dependency Injection, Continuous Integration og Migrations. Dertil kommer Office Interop og ASP.NET MVC, som jeg endelig får mulighed for at bruge professionelt, hvor det ellers har været på todo-listen hjemme siden jeg fik leget med de helt tidlige bits. Og sidste men ikke mindst har jeg kigget op tools til synkronisering og deling af data.

Object relationel mappers

Mere præcist har jeg i forbindelse med ORM's kigget på NHibernate, Fluent NHibernate og LINQ to NHibernate, samtidig med at jeg har en bog på vej om LINQ to entities. Jeg håber LINQ to Entities udvikler sig til et reelt alternativ til NHibernate, som jeg lige knap synes det er idag. Hovedanklagen idag er at det ikke giver persistence ignorence, hvilket er et stort minus i forhold til at få et pænt løst koblet design. Det er dog et issue Microsoft er klar over, og noget de arbejder på til vNext. Et andet issue der arbejdes på som er væsentligt er iøvrigt model drevet design, hvor LINQ to Entities idag er meget datadriven.

Continuous Integration

Opsætning af et continuous integration miljø, som skal baseres på Team Foundation Server er en anden ting jeg er ved at se på. Umiddelbart virker det nemt at komme igang med, men udarbejdning af build scrips skal nok blive interessant at se på. En overvejelse er blandt andet om man skal holde sig til at bruge MS Build Server eller om NAnt viser sig at være den rigtige vej at gå?

Migrations

Migrator.NET har været rimeligt nemt at komme igang med, bortset fra at dokumentationen er rimeligt tynd, så selve konfigurationen skulle det lige pilles lidt ved for at få det til at spille.

Data synkronisering og deling af data

Idet jeg er begyndt at pendle er synkronisering af data imellem min desk- og laptop også blevet et super relevant emne, hvilket fik mig til at afprøve synctoy, live sync, mesh, skydrive samt servicen delicious. Mesh har jeg forelsket mig lidt i, selvom jeg må erkende at stabiliteten ikke er god nok endnu i beta versionen, samtidig med at de 5 GB plads man får idag er lidt tyndt når man på et skydrive får 25 GB.

En af mine gamle lidenskaber der indimellem popper frem er at lege med billeder, og nu jeg har haft ferie gav det sig udslag i at jeg ville prøve at lave en billedvæg til mit site, hvor billederne skulle trækkes fra flickr. Jeg havde egentlig forventet lidt bøvl, men selve det at trække billeder kræver ikke andet end følgende.

Flickr flickr = new Flickr("apiKey", "sharedSecret");
PhotoSearchOptions options = new PhotoSearchOptions();
options.Tags = "Christian";
options.Extras |= PhotoSearchExtras.DateTaken | PhotoSearchExtras.OriginalFormat;
options.UserId = flickr.PeopleFindByEmail("[email protected]").UserId;
options.TagMode = TagMode.AnyTag;
options.SortOrder = PhotoSearchSortOrder.DateTakenDesc;
options.PerPage = 6;
Photos photos = flickr.PhotosSearch(options);

Photos indeholder så en PhotoCollection som hver har urls til billederne i original, medium, lille og thumbnail størrelse.

Herfra manglede jeg så bare en eller anden smart måde at vise billederne på. Jeg faldt hurtigt over FancyBox, som er en JQuery plugin der også er rigtigt nem at bruge, og lader brugere trykke på en thumbnail og se hele billedet. Dagen efter poppede der tilfældigvis en blogpost ind omkring TinySlideShow, som lige som navnet antyder giver mulighed for at lave et slideshow. Det skulle naturligvis også prøves af, og da jeg i noget tid gerne have ville finde på noget nyt til hovedsiden på dotnetnerd.dk var det jo oplagt.

Så er min sidste dag hos Hedal:Kruse:Brohus overstået efter lige knap to rigtigt gode år. Det har været en fornøjelse at arbejder der, men jeg har haft brug for at kaste mig ud i nogen nye udfordringer, som jeg nu er sikker på jeg vil få hos Vertica hvor jeg starter fra begyndelsen af det nye år.

Nu vil jeg nyde min ferie, om end det også skal nørdes lidt hjemme i løbet af de 14 dage. God jul og godt nytår til jer derude.

Som afslutning på året vil Microsoft kåre årete blogger herhjemme, hvilket man kan læse mere om i den seneste udgave af MSDN flash newsletter.

Stem venligst på den blog du synes har været mest interessant på [email protected], med navnet på bloggeren, og den blog som du synes fortjener titlen.

Jeg vil naturligvis være glad for at modtage din stemme, da det kunne være en sjov titel af få. Det er desuden altid rart hvis folk sætter pris på det man skriver om - det er trodsalt det at det hele handler om ;-) 

Nu synes jeg igen det er ved at være på tide at rode lidt med et nyt sprog, så jeg har kastet mig over (Iron)Ruby, som opfylder samme krav som F# gjorde da jeg gik i krig med det. Det er nemlig et sprog der giver nye udfordringer idet jeg ikke får har arbejdet så meget med dynamiske sprog, og samtidig er det anvendeligt på .NET platformen.

Udover at IronRuby er anvendeligt på .NET platform er det samtidig Ruby varianter der er skrevet til andre platforme, så der er helt sikkert gode perspektiver i at lære sproget. En mulighed for fremtiden er også at se på Ruby on Rails, som de fleste nok har hørt omtalt som et virkelig interessant framework til udvikling af RAD MVC webapplikationer.

Hvis man skal i gang er der tre sider jeg vil anbefale som er:

http://ironruby.net/ - den officielle side der fungerer som en wiki.

http://www.ruby-lang.org/en/ - en god side om Ruby med adgang til en RIPL der kører i browseren så man kan lege lidt.

http://www.fincher.org/tips/Languages/Ruby/ - en rigtig god intro side der gør at min blogserie om emnet nok bliver en del kortere end den om F#, da man allerede kan finde meget her J

Derudover skal man for at komme i gang rubyforge.org. Herfra kan man hente og installere Ruby fra http://rubyforge.org/projects/rubyinstaller/ og nyeste version af IronRuby kan hentes fra deres svn repository svn://rubyforge.org/var/svn/ironruby. For at komme i gang kan man blot compile solutionen og køre console applikationen, så har man mulighed for at lege med lidt kode.