Jag har tidigare visat hur vi med Windows CardSpace kan posta ett InfoCard till servern i form av XML. Men säg att vi istället vill sköta allt på klienten då vi kanske vill kunna logga in användaren med ett asynkront anrop eller direkt på sidan kunna visa information. Då är det enklast att sköta det direkt med Javascript.

För att trigga Windows CardSpace så räcker det med att vi hämtar value-propertyn i objekt-elementet med javascript. Det kommer sedan att innehålla XML:en från det InfoCard som har skickats in. Det vi kommer att göra nu är helt enkelt att visa det i en textarea, men det skulle som sagt kunna skickas in till någon annan sida asynkront. För mer information om det läs mitt inlägg om Ajax med jQuery.

Det första vi gör är att skapa sidan som skall innehålla informationen:

 

   1:  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
   2:  <html xmlns="http://www.w3.org/1999/xhtml">
   3:  <head runat="server">
   4:      <title>jQuery Demo - Windows CardSpace</title>
   5:      <script src="scripts/jquery-1.2.6.js" type="text/javascript"></script>
   6:      <script src="scripts/cardspace.js" type="text/javascript"></script>
   7:  </head>
   8:  <body>
   9:      <form action="CardSpace.aspx">
  10:      <object type="application/x-informationcard" id="infocard">
  11:          <param name="tokenType" value="urn:oasis:names:tc:SAML:1.0:assertion" />
  12:          <param name="requiredClaims"
  13:              value="http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname"
  14:          />
  15:      </object>
  16:      <div>
  17:          <textarea id="token" cols="100" rows="20"></textarea>
  18:      </div>
  19:      <div>
  20:          <button id="infoButton">Hämta värde</button>
  21:      </div>
  22:      </form>
  23:  </body>
  24:  </html>

De värden vi hämtar med CardSpace är förnamn och efternamn. De skall när användaren klickar på knappen med id:t “infoButton” skickas till textarean med id:t “token”.

Som jag nämnde räcker det med att hämta value-propertyn för att öppna card selectorn.

   1:  $(document).ready(function() { Initialize(); });
   2:   
   3:  function Initialize() {
   4:      $('#infoButton').click(function(e) { GetInfoCard(e); });
   5:  }
   6:   
   7:  function GetInfoCard(e) {
   8:      var xmltkn = document.getElementById("infocard");
   9:      var wcslabel = document.getElementById("token");
  10:      wcslabel.value = xmltkn.value;
  11:  }

Det som händer när användaren klickar på knappen är att card selectorn visas:

cardselector

Efter att vi nu har klickat på send, så skickas XML:en till sidan och visar upp den:

code

Det är alltså möjligt att med bara ett par rader kod skicka in ett InfoCard till klienten med javascript. Med ett par rader extra skulle vi kunna skicka in det asynkront och sedan logga in användaren.

Klicka här för ett exempel.

compiler

Innehållsförteckning

  1. A Brief History of Compiler Technology
  2. A Brief Introduction to the .NET Framework
  3. A Compiler Flyover
  4. The Syntax for the QuickBasic Compiler
  5. The Lexical Analyzer for the QuickBasic Compiler
  6. QuickBasic Object Modeling
  7. The Parser and Code Generator for the QuickBasic Compiler
  8. Developing Assemblers and Interpreters
  9. Code Generation to the Common Language Runtime
  10. Implementing Business Rules
  11. Language Design: Some Notes
  12. Appendix A: quickBasicEngine Language Manual
  13. Appendix B: quickBasicEngine Reference Manual

Har du någonsin funderat på hur man skriver ett eget språk med en kompilator för det? I Build Your Own .NET Language and Compiler av Edward G. Niles från Apress får man en djupgående genomgång på hur man skriver en kompilator för QuickBasic med ren .NET-kod. En fullt fungerande kompilator följer även med! Boken börjar med att ta upp grundläggande om hur en kompilator fungerar och går sedan igenom de olika stegen där man skissar upp själva utséendet på språket med alla regler och visar sedan hur man med Reflection skriver en kompilator i Visual Basic .NET. Boken har inga exempel i C#, utan det är just Visual Basic .NET.

Boken vänder sig till experter och är absolut ingenting för en nybörjare. Den är dock väldigt pedagogisk och förklarar de olika stegen väldigt noggrant, vilket gör att man hänger med lättare i det som händer. Alla exempel och program som används vid kontrollerna av modelleringen finns för nedladdning på Apress.

Boken rekommenderas starkt till dig som är intresserad av att veta mer om hur man arbetar med kompilatorer, samt vill veta hur man bär sig åt för att skriva ett eget .NET-språk.

Svårighetsgrad: Avancerad

aspnetdatacontrols

Innehållsförteckning

  1. Introduction to Data Binding in ASP.NET
  2. Working with List Controls in ASP.NET
  3. Working with the Repeater Control
  4. Working with the DataList Control
  5. Working with the DataGrid Control in ASP.NET
  6. Displaying Views of Data (Part 1)
  7. Displaying Views of Data (Part 2)
  8. Working with LINQ

Om du undrar hur de olika datakontrollerna används, och hur man anpassar utséendet på vad kontrollerna renderar så är det här en bra bok för dig. I ASP.NET Data Presentation Controls Essentials från Packt Publishing så visar Joydip Kanjilal hur man först och främst hämtar datan och binder den på sidan, och går sedan igenom olika kontroller och visar hur man kan använda dem på olika sätt. Den här boken vänder sig främst till nybörjare som vill veta hur de kan visa datan på sin sida, men även till erfarna programmerare som vill veta hur de kan gå vidare och anpassa utskrifterna. Det finns även exempel på hur man exporterar datan till Excel och Word. Förutom just utskrifter av data i kontrollerna får man även olika exempel på hur man kan använda kontrollerna för att ändra befintlig data med dem, samt anpassa kontrollerna för ens syfte.

Klicka här för mer information om boken.

Svårighetsgrad: Lätt

linqquickly

Innehållsförteckning

  1. Overview
  2. LINQ to Objects
  3. LINQ to XML
  4. LINQ to SQL
  5. LINQ over DataSet
  6. LINQ to XSD
  7. Standard Query Operators
  8. Appendix A: Building an ASP.NET Application
  9. Appendix B: LINQ with Outlook

I LINQ Quickly från Packt Publishing går N Satheesh Kumar igenom de flesta funktioner som finns i Linq. Boken börjar med att gå igenom olika nyheter i C# 3.0 som anonyma typer, anonyma metoder, expression trees med mera, och går sedan vidare med olika varianter av Linq. Boken innehåller väldigt många exempel och bilder, vilket gör att det är väldigt lätt att förstå vad som händer när man använder de olika exemplen. Efter de olika varianterna av Linq så tar han även upp Standard Query Operators, det vill säga Select, Join, Intersect, Union, GroupBy osv. Även här med bra exempel för varje metod. Som avslutning kommer två exempel där man först får se hur man skapar en ny ASP.NET-sida som använder Linq, men även en applikation som hämtar information från Outlook med hjälp av Linq.

Boken kan dels läsas från pärm till pärm, men fungerar även utmärkt som referens när man behöver kolla upp snabbt vad en viss metod gör.

Jag rekommenderar den här boken för de som kan C# någorlunda bra och vill lära sig mer om hur Linq fungerar.

Klicka här för mer information om boken.

Svårighetsgrad: Medel

När man arbetar med jQuery, eller rättare sagt webbsidor överlag, så bör man alltid se till att dela på koden så gott det går samt se till att den ser bra ut även om användaren inte har CSS eller Javascript aktiverat (vilket kan vara fallet bland till exempel blinda som får sidan uppläst eller personer som av säkerhetsskäl vill surfa utan javascript).

Jag kommer att gå igenom hur vi skapar en meny som använder jQuery för att visa en del i taget. Jag kommer att börja med HTML-koden, sedan CSS:en och till sist javascriptet.

Då det är en vanlig lista vi skall ha så skall vi använda ett ul-element och sedan nästlade ul-element för de olika kategorierna.

   1:  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
   2:  <html xmlns="http://www.w3.org/1999/xhtml">
   3:  <head>
   4:      <title>jQuery Demo - Meny</title>
   5:      <link href="menu.css" rel="Stylesheet" type="text/css" />
   6:      <script src="scripts/jquery-1.2.6.js" type="text/javascript"></script>
   7:      <script src="scripts/slidemenu.js" type="text/javascript"></script>
   8:  </head>
   9:  <body>
  10:      <div id="menu">
  11:          <h1>Meny</h1>
  12:          <ul>
  13:              <li>
  14:                  <a href="#">Länk #1</a>
  15:                  <ul>
  16:                      <li><a href="#">Länk #1.1</a></li>
  17:                      <li><a href="#">Länk #1.2</a></li>
  18:                      <li><a href="#">Länk #1.3</a></li>
  19:                      <li><a href="#">Länk #1.4</a></li>
  20:                      <li><a href="#">Länk #1.5</a></li>
  21:                  </ul>
  22:              </li>
  23:              <li>
  24:                  <a href="#">Länk #2</a>
  25:                  <ul>
  26:                      <li><a href="#">Länk #2.1</a></li>
  27:                      <li><a href="#">Länk #2.2</a></li>
  28:                      <li><a href="#">Länk #2.3</a></li>
  29:                      <li><a href="#">Länk #2.4</a></li>
  30:                      <li><a href="#">Länk #2.5</a></li>
  31:                  </ul>
  32:              </li>
  33:              <li>
  34:                  <a href="#">Länk #3</a>
  35:                  <ul>
  36:                      <li><a href="#">Länk #3.1</a></li>
  37:                      <li><a href="#">Länk #3.2</a></li>
  38:                      <li><a href="#">Länk #3.3</a></li>
  39:                      <li><a href="#">Länk #3.4</a></li>
  40:                      <li><a href="#">Länk #3.5</a></li>
  41:                  </ul>
  42:              </li>
  43:          </ul>
  44:      </div>
  45:  </body>
  46:  </html>

Tanken här är att när besökaren går in på sidan så skall de tre länkarna direkt under ul li visas, samtidigt som de under skall vara dolda till användaren klickar på en länk. Menyn under Länk #1 skall dock visas från början.

Om vi ser på sidan utan att ha skapat javascriptet och css-filen så ser den ut så här:

nocss

Det ser logiskt ut, vilket gör att man även utan CSS kan se strukturen på menyn. Allt är som det ska än så länge. :-)

Nästa steg är att lägga till en CSS-fil där vi visar hur den skall se ut med CSS påslaget. Hur ni skriver CSS:en kommer inte att påverka JavaScriptet sedan, utan här kan ni göra som ni själva vill. Jag bifogar den CSS:en jag hade med:

   1:  body
   2:  {
   3:      font-family: Verdana;
   4:  }
   5:   
   6:  ul
   7:  {
   8:      margin: 0px;
   9:      padding: 0px;
  10:      width: 200px;
  11:  }
  12:   
  13:  ul li a
  14:  {
  15:      margin: 0px;
  16:      padding: 0px;
  17:      width: 200px;
  18:      background-color: #210;
  19:      color: #fff;
  20:      display: block;
  21:      padding: 5px;
  22:      text-decoration: none;
  23:      border-right: 10px solid #210;
  24:  }
  25:   
  26:  ul li ul li a
  27:  {
  28:      background-color: #630;
  29:      border-left: 10px solid #210;
  30:      border-right: 0px;
  31:  }
  32:   
  33:  ul li ul li a:hover
  34:  {
  35:      background-color: #963;
  36:      border-left: 10px solid #630;
  37:      border-right: 0px;
  38:  }

Med den inlagd så bör sidan se ut i stil med det här:

css

Stiligt!

Det här som jag har visat nu är dock helt vanlig HTML och CSS. Sidan ser relativt bra ut både med och utan CSS, vilket gör att vi får ökad tillgänglighet på sidan. Om personen har inaktiverat CSS så får vi upp en enkel lista, och har denne CSS så får vi upp en snygg meny där man lättare kan se de olika kategorierna.

Nästa steg nu är att applicera javascriptet. Det vi skall göra här är att först dölja alla undermenyer, och sedan visa den första av dem. När menyn byts ut så skall den gamla dras in och den nya fällas ut med en enkel animering.

Med jQuery kan vi lösa detta på ett väldigt enkelt sätt.

   1:  $(document).ready(function() { Initialize(); });
   2:   
   3:  function Initialize() {
   4:      $('#menu>ul ul').hide();
   5:      $('#menu>ul a').click(function() { ShowMenu(this); });
   6:      $('#menu>ul a:first').click();
   7:  }
   8:   
   9:  function ShowMenu(e) {
  10:      $('#menu>ul ul').slideUp();
  11:      $(e).parent().children('ul').slideDown();
  12:  }

Det första vi gör här är precis som i de andra exemplen jag har visat tidigare, att anropa en metod som körs när DOM:en är fit for fight. Där väljer vi att direkt gömma alla ul som ligger under en ul som i sin tur ligger direkt under #menu. Vi använder selectorn #menu>ul visar att det gäller en ul som är direkt under #menu. Sedan ser vi till att ShowMenu(this) anropas när användaren klickar på en länk som ligger under vår första ul. Det sista som sker är att vi clickar på den första länken under ul, vilket är “Länk #1”.

I ShowMenu(e) så väljer vi först att dölja alla undermenyer med slideUp, vilket gör att den som är utfälld kommer att slide:a up och sedan döljas. Sedan väljer vi att hämta först föräldern till länken som det klickades på (dvs en ul), sedan den undermeny som är kopplad till den och till sist visar vi den med slideDown() som fäller ut undermenyn.

Kikar vi på sidan nu så ser den ut så här:

cssjs

Nu har vi skapat en meny som fungerar i tre olika scenarion, där användaren inte har css, där användaren inte har javascript och där användaren har både css och javascript. Genom att dela upp allt på det här viset har vi dessutom lyckats skilja dem åt helt och kan utan problem sedan byta ut t.ex. CSS:en eller använda något annat javascript (eller skippa det helt och hållet) utan att behöva ändra någon annanstans än i just den filen som berörs.

Värt att tänka på är att HTML skall finnas i HTML-filen, javascript i js-filen och CSS i css-filen. På så sätt får vi kod som blir lätt att underhålla och som dessutom ser bra ut.

En demo på scriptet finns här.

Med jQuery så kan man på ett otroligt smidigt sätt använda Ajax. Jag kommer att gå igenom hur man gör för att skriva en enkel sida som hämtar in olika sidor med Ajax-anrop, samtidigt som den gamla texten suddas bort med en animering.

När man använder javascript - och därmed jQuery – så bör man alltid se till så att koden är semantiskt korrekt innan man applicerar javascripten. Koden bör vara så ren som möjligt och HTML-koden bör innehålla just HTML och inget annat.

HTML-koden jag kommer att använda ser ut som sådan:

   1:  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
   2:  <html xmlns="http://www.w3.org/1999/xhtml">
   3:  <head>
   4:      <title>jQuery Demo</title>
   5:      <link href="style.css" rel="Stylesheet" type="text/css" />
   6:      <script src="scripts/jquery-1.2.6.js" type="text/javascript"></script>
   7:      <script src="scripts/menu.js" type="text/javascript"></script>
   8:  </head>
   9:  <body>
  10:      <div id="mainContainer">
  11:          <h1>
  12:              jQuery Demo
  13:          </h1>
  14:          <ul id="menu">
  15:              <li><a href="#" class="menu-startpage">Startsidan</a></li>
  16:              <li><a href="#" class="menu-aboutme">Om mig</a></li>
  17:              <li><a href="#" class="menu-other">Annat</a></li>
  18:          </ul>
  19:          <div id="main">
  20:          </div>
  21:      </div>
  22:  </body>
  23:  </html>

Det är alltså helt vanlig XHTML. Jag har inga javascript eller annat i koden, utan allt kommer att läggas i menu.js.

Det vi kommer att göra i javascriptet är att vi kommer att sätta ett onclick-event på alla länkar under #menu li där vi använder klassnamnet för att visa vilken sida som skall hämtas. När vi sedan klickar på en länk så kommer div-elementet med id:t “main” att försvinna med en animering, fyllas på med HTML genom ett Ajax-anrop och sedan visas igen med en liknande animering.

Javascriptet i sin helhet ser ut på detta sätt:

   1:  $(document).ready(function() { Initialize(); });
   2:   
   3:  function Initialize() {
   4:      SetupMenu();
   5:      $('#main').hide();
   6:      $('.menu-startpage').click();
   7:  }
   8:   
   9:  function SetupMenu() {
  10:      $('#menu li a').click(function() { LoadPage(this); });
  11:  }
  12:   
  13:  function LoadPage(e) {
  14:      var page = e.className.split(' ')[0];
  15:      $('#menu li a').removeClass('active');
  16:      $(e).addClass('active');
  17:      $.ajax({
  18:          method: "get",
  19:          url: "LoadPage.aspx",
  20:          data: "page=" + page,
  21:          beforeSend: function() { $('#main').hide('slow').fadeOut(); },
  22:          complete: function() { $('#main').show('slow').fadeIn(); },
  23:          success: function(result) { $("#main").html(result); }
  24:      });
  25:  }

Vi börjar med att anropa metoden Initialize() när DOM:en är redo för förändringar. Som jag har skrivit i ett tidigare blogginlägg så är det inte detsamma som window.load då den sistnämnde även väntar på att alla bilder och annat skall laddas.

I Initialize() så börjar vi med att köra metoden SetupMenu() där vi sätter ett onclick-event på alla länkar under #menu li. När användaren klickar på en länk så skall LoadPage(e) köras där e är en referens till elementet. Efter det så gömmer vi div-elementet då vi inte har någon information att visa än, och efter det trigga click-eventet för startsidan så att den skall laddas in när besökaren går till sidan.

Än så länge är det inga konstigheter, utan det är just när användaren klickar på en länk som det magiska sker. Det som händer då är att LoadPage(e) körs, och där så börjar vi med att plocka fram första klassen för elementet då den aktuella länken blir tilldelad klassnamnet “active”. Sedan tar vi bort klassen “active” från alla länkar för att kunna sätta den igen på länken som det har klickats på.

Nästa steg är att köra ajax-metoden. jQuery har en metod som heter just ajax och som tar emot en anonym funktion. I den funktionen som i själva verket är en Json-sträng anger vi olika properties för Ajax-anropet. Att tilldela properties på detta sätt är standard i jQuery och används av de flesta funktioner där. Det går även att använda när man skriver egna funktioner för jQuery.

De metoder vi använder här är:

  • method – Anger vilken metod som skall användas vid anropet. Vi använder här get, men skulle lika gärna kunna använda post.
  • url – URL till sidan som skall anropas. Här anropar vi LoadPage.aspx som returnerar olika texter beroende på vad som skickas in till sidan. Det här kan vara vilken typ av sida som helst, och returnera antingen HTML, XML eller Json. Sedan tar jQuery hand om outputen och parse:ar den om så behövs.
  • data – Här anger vi datan som skall skickas. Då vi kör med get som metod så skickas den som en querystring till sidan som vi har angett.
  • beforeSend – Funktion som skall köras innan datan skickas. Här gömmer vi undan den gamla informationen med dels hide(‘slow’) som “viker ihop” elementet, och sedan fadeOut() som gör att opaciteten sänks för elementet.
  • complete – Det här körs när datan är hämtad. Här väljer vi att visa div-elementet igen på samma sätt som vi nyss gömde det på.
  • success – När vi har hämtat datan så kör vi en funktion som tar emot datan som parameter. Det vi gör här är att sätta HTML-koden för elementet genom metoden html().

När vi nu kör sidan så kommer den att ladda in startsidan och sedan visa informationen där. När vi sedan klickar på en länk så försvinner den gamla informationen samtidigt som den nya laddas in och sedan visas. Vi kan alltså med så lite som 25 rader kod göra ett Ajax-anrop och dessutom animera div-elementet och sätta klasser på länkarna! Det här är en av anledningarna till varför jQuery har blivit så populärt bland utvecklare som det är, och det är dessutom anledningen till varför Microsoft valde att ha med detta i de kommande versionerna av ASP.NET.

Jag har även lagt upp ett demo där du kan se hur det fungerar.

Då Microsoft har sagt att jQuery följer med i framtida versioner av ASP.NET så kan det vara bra att veta vad som egentligen går att göra med det. Det finns väldigt många som inte vågar peta på javascript, utan istället använder antingen helt färdiga javascript, eller använder t.ex. ASP.NET Ajax Control Toolkit (inget illa om det, det gör det möjligt att på ett snabbt sätt få in smutt funktionalitet på sidan) för att få sidan lite mer dynamisk. Problemet här är dock att man inte alltid får det exakt som man har tänkt sig, och för att få det så måste man faktiskt våga skapa den där lite småläskiga js-filen och börja skriva.

Visual Studio 2008 kom med utbyggd intellisense för javascript, inklusive möjligheten att ha XML-kommentarer på funktionerna. I och med implementerandet av jQuery i ASP.NET så kommer vi även att få full intellisense med kommentarer även för det, vilket underlättar en hel del.

Jag kommer här att gå igenom en snabb introduktion av selectors i jQuery. Selectors var något som fanns med på ASP.NET Ajax Roadmap, men varför uppfinna hjulet på nytt? Selectors i jQuery är väldigt användbara och välutvecklade och vi kan med dem hämta vissa kontroller på ett mycket smidigare sätt än med vanlig javascript.

HTML-filen jag kommer att använda mig utav ser ut på detta sätt:

   1:  <html xmlns="http://www.w3.org/1999/xhtml">
   2:  <head>
   3:      <title>jQuery Demo</title>
   4:      <script src="scripts/jquery-1.2.6.js" type="text/javascript"></script>
   5:      <style type="text/css">
   6:          .redBackground { background-color: #f00; }
   7:      </style>
   8:  </head>
   9:  <body>
  10:      <div id="mainContainer">
  11:          <h1>jQuery Demo</h1>
  12:          <ul id="ul1">
  13:              <li><a href="#1">Link #1</a></li>
  14:              <li><a href="#2">Link #2</a></li>
  15:              <li><a href="#3" class="link3">Link #3</a></li>
  16:              <li><a href="#4">Link #4</a></li>
  17:              <li><a href="#5">Link #5</a></li>
  18:          </ul>
  19:          
  20:          <ul id="ul2">
  21:              <li><a href="#1">Link #1</a></li>
  22:              <li><a href="#2">Link #2</a></li>
  23:              <li><a href="#3" class="link3">Link #3</a></li>
  24:              <li><a href="#4">Link #4</a></li>
  25:              <li><a href="#5">Link #5</a></li>
  26:              <li><a href="#6">Link #6</a></li>
  27:              <li><a href="#7">Link #7</a></li>
  28:              <li><a href="#8">Link #8</a></li>
  29:              <li><a href="#9">Link #9</a></li>
  30:              <li><a href="#10">Link #10</a></li>
  31:          </ul>
  32:      </div>
  33:  </body>
  34:  </html>

Det är inga konstigheter här, det enda jag har lagt till här förutom den vanliga HTML-koden är en css-klass kallad redBackground samt att jag hämtar in jQuery 1.2.6 som är den senaste versionen i nuläget.

Selectors i jQuery gör att man kan hämta ett eller flera element med minimal kod. Nedan finns en lista på enkla selectors samt en beskrivning på vad de gör:

$("*")

Hämtar alla element på sidan.

$("ul")

Hämtar alla ul-element på sidan.

$("ul li")

Hämtar alla li-element som ligger någonstans under en ul.

$("#ul1 li")

Hämtar alla li som ligger under ett element med id satt till “ul1”.

$("#ul1 li a:first")

Hämtar den första länken av alla länkar som ligger under någon li i den ul som har id “ul1”.

$(".link3")

Hämtar alla element som har klassen “link3”.

Detta är bara ett handplock av alla varianter som finns med jQuery. När vi har hämtat någon av dessa så kan vi sedan antingen använda dem som vanligt med javascript, eller använda någon utav de funktioner som följer med jQuery. Vill vi sätta klassen “redBackground” på de element som har klassen “link3” så kan vi köra följande kod:

$(".link3").addClass("redBackground");

Då alla metoder returnerar objektet i sig så kan man helt enkelt lägga till nästa metod direkt efter på samma rad. Ett annat exempel där vi vill “fade:a” ut och sedan in varannan li i den ul som har id:t “ul2” så kan vi göra det på detta sätt:

$("#ul2 li:odd").fadeOut().fadeIn();

Sådant som kräver mängder med rader kod om vi hade behövt skriva det själva kan vi nu skriva med en enkel rad!

Vill ni testa de här exemplen snabbt så kan ni lägga till den här koden på sidan efter att referensen till jQuery-javascriptet:

   1:  <script type="text/javascript">
   2:      $(document).ready(function() { RunScripts(); });
   3:   
   4:      function RunScripts() {
   5:          $("#mainContainer").fadeOut().fadeIn().fadeOut().fadeIn();
   6:          alert('All: ' + $("*").length);
   7:          alert('ul: ' + $("ul").length);
   8:          alert('ul li: ' + $("ul li").length);
   9:          alert('#ul1 li: ' + $("#ul1 li").length);
  10:          alert('#ul1 li a:first: ' + $("#ul1 li a:first")[0].length);
  11:          alert('.link3: ' + $(".link3").length);
  12:          $("#ul2 li:odd").fadeOut().fadeIn();
  13:          $(".link3").addClass("redBackground");
  14:      }
  15:  </script>

I javascriptet ovan så kör jag $(document).ready(function); för att köra RunScripts. Anledningen till att jag kör det istället för window.onload = function; är att den sistnämnda kör scriptet när allt på sidan är laddat, inklusive stora bilder och annat som körs på sidan. Med ready-metoden som ingår i jQuery så kan man köra metoden när all HTML-kod har laddats in, vilket gör att det går mycket snabbare.

Ni kan även se att $ används flitigt, och det är i själva verket bara ett alias för jQuery. Det går att skriva till exempel jQuery(“*”), men det kräver extra tecken vilket är anledningen. Används andra bibliotek som t.ex. prototype eller mootools så kan det vara bra att använda originalet då det kan krocka annars.

För mer info om de metoder och selectors som finns, besök jQuery.

Om du har önskemål på något annat om jQuery, så lämna gärna en kommentar så kan jag se vad jag kan göra.

Microsoft gick nyss ut med att Visual Studio 2010 (codename “Rosario”) och .NET Framework 4.0 kommer att finnas tillgängligt på MSDN 1 oktober. Det finns många nyheter, speciellt för testare.

Jag har inte så mycket information om det än, annat än det som finns i länkarna nedan, men så fort jag får tag på en kopia så blir det att testa för fulla muggar. :-)

Microsoft gick tidigare under kvällen ut officiellt med att de har påbörjat ett samarbete med jQuery-teamet. För de som inte visste det så är jQuery ett alldeles utmärkt javascript-bibliotek med mängder av finnesser. Det finns otroligt bra funktioner som kan användas för att med några enstaka rader kod modifiera stora delar av sidan samt animera dem. Det finns även en hel del plugins som gör det möjligt att på ett busenkelt sätt få in avancerade javascript på sin sida.

Samarbetet leder bland annat till att Microsoft officiellt kommer att ha support för jQuery! För utvecklare betyder detta även att vi kommer att få med jQuery framtida versioner av ASP.NET Ajax, samt att det kommer inbyggt med ASP.NET MVC. Förutom det så kommer Microsoft även att se till att intellisense fungerar perfekt med Visual Studio 2008.

Vi kommer att kunna ta del av detta inom en snar framtid, men vill du experimentera med jQuery redan nu så finns det att ladda ned här.

Det här är totally awesome!

Mer information:

ASP.NET 4.0 Ajax har en ny funktion som kallas templates. Med templates kan du på ett enkelt sätt hämta data och visa på sidan, utan att behöva skapa upp alla element i javascriptet. Först skapar man själva mallen och sedan har man ett element som skall populeras med data och rendera den efter mallens utseende.

Jag kommer att hämta data från en PageMethod och sedan rendera den på sidan i en lista. Datan kommer att vara en List<Customer> där Customer är en klass med tre egenskaper, Name (string), Company (string) samt Age (int?).

Det första som måste göras är att skapa en referens till dels MicrosoftAjaxTemplates.js (jag kommer att använda mig utav den som kom med Preview 2, den som finns för Preview 1 har en annorlunda struktur) samt även till Customer.js där jag har funktionaliteten för att hämta data samt fylla den.

   1:  <asp:ScriptManager runat="server" ID="sManager" EnablePageMethods="true">
   2:      <Scripts>
   3:          <asp:ScriptReference Path="~/MicrosoftAjaxTemplates.js" />
   4:          <asp:ScriptReference Path="~/Customer.js" />
   5:      </Scripts>
   6:  </asp:ScriptManager>

 

Vår page method:

   1:  [WebMethod]
   2:  public static List<Customer> GetCustomers()
   3:  {        
   4:      List<Customer> coll = new List<Customer>();
   5:      coll.Add(new Customer() { Name = "Mikael Söderström", Company = "Strand Interconnect", Age = 23 });
   6:      coll.Add(new Customer() { Name = "Bill Gates", Company = "Microsoft", Age = null });
   7:      return coll;
   8:  }

Koden för Customer-klassen:

   1:  public class Customer
   2:  {
   3:      public string Name { get; set; }
   4:      public string Company { get; set; }
   5:      public int? Age { get; set; }
   6:  }

Koden ovan är ganska självförklarande, så den kommer jag inte att gå igenom utförligt, men det vi gör är iaf att vi i GetCustomers returnerar en List<Customer> med två personer, jag själv och Bill Gates. Jag är 23 år, och Bill Gates har ingen ålder (läs: odödlig).

Det vi ska göra med den här datan är att visa upp den i en enkel ul-lista. För att göra det så skapar vi först upp koden för vår template, vilken kommer att fyllas med data.

   1:  <div id="CustomerTemplate" class="sys-template">
   2:      <ul>
   3:          <li>Namn: {{ Name }}</li>
   4:          <li>Företag: {{ Company }}</li>
   5:          <li>
   6:              Ålder: 
   7:              <!--* if (Age) { *-->
   8:              {{ Age }}
   9:              <!--* } *-->
  10:              <!--* if (!Age) { *-->
  11:              Odödlig
  12:              <!--* } *-->
  13:          </li>
  14:      </ul>
  15:  </div>

 

Det vi har här är ett div-element som är en container för vår template. Den behöver ett id för att vi skall kunna hämta den från javascriptet, och den bör ha ett klassnamn för att vi skall kunna dölja den. När vi hämtar datan så är det inte det här div-elementet som fylls med datan, utan den är enbart en mall för hur det skall se ut.

När vi hämtar datan så har vi tre fält, Name, Company samt Age och genom att lägga in dessa inom {{ och }} så kan vi specifiera vart vi vill ha dem. Det går även att använda till exempel fältet.format(formatering) för att formatera texten, vilket kan vara bra om det är ett datum som skall visas. I koden ovan har vi även med if-satser för att kunna rendera olika texter baserat på vilket värde som kommer. Då vi har en nullable int för åldern, så skriver vi ut åldern om den har ett värde, annars skriver vi ut “Odödlig”.

När vi har hämtat datan så kommer den som jag har nämnt tidigare, att fyllas på i ett annat element, men med vår template för utséendet. Vi kommer att ha ett tomt div-element för det:

   1:  <div id="CustomerData"></div>

Även detta element behöver ett id för att vi enkelt skall kunna veta vilket element som skall fyllas.

Nästa steg är att skapa javascriptet som skall användas för att hämta datan och skriva ut den på sidan. Här använder vi Sys.UI.Template(element) samt dess metod createInstance(element, data) för att hämta vår template samt skriva ut en Json-sträng till elementet som skall innehålla datan.

   1:  function pageLoad() {
   2:      PageMethods.GetCustomers(LoadCustomers);
   3:  }
   4:   
   5:  function LoadCustomers(args)
   6:  {
   7:      var template = new Sys.UI.Template($get("CustomerTemplate"));
   8:      for (var i = 0; i < args.length; i++)
   9:      {
  10:          template.createInstance($get("CustomerData"),
  11:                  {
  12:                      Name: args[i].Name,
  13:                      Company: args[i].Company,
  14:                      Age: args[i].Age
  15:                  });
  16:      }
  17:  }