Gaia Ajax 4.0 is in the nightly!

by Stian Solberg 18. June 2013 11:03

Gaia Ajax 4.0We have been spending a lot of time the last months wrapping up what will be the upcoming 4.0-release.

It is easy to grab the latest bits:

To get a summary of what has changed, take a look at front page of nightly samples.

We'd love to get your feedback, please use the forum.

Kind regards
The Gaiaware team

 

 

Using Flickr API with ASP.NET, Gaia Ajax and JSON

by Kariem 4. December 2010 00:39

As we go through this simple tutorial you will be introduced to some of the features of the Gaia Ajax Framework. This tutorial is ideal for those who are new to Gaia. We will build a simple app that searches for images with a specific tag on Flickr, reads and parses the JSON response and loads the images on the page.

Search Flickr

Setting The Stage

You can start with a regular ASP.NET Website (or web project) and add references to the Gaia dlls. We just announced a public beta release of Gaia Ajax 3.7, you can read about it and download the dlls and smaples from there. Then register the Gaia Controls either at the page level:

   1:  <%@ Register 
   2:      Assembly="Gaia.WebWidgets" 
   3:      Namespace="Gaia.WebWidgets"
   4:      TagPrefix="gaia" %>
   5:   
   6:  <%@ Register 
   7:      Assembly="Gaia.WebWidgets.Extensions"
   8:      Namespace="Gaia.WebWidgets.Extensions" 
   9:      TagPrefix="gaia" %>

 

or globally for your entire app in web.config:

   1:  <system.web>
   2:   <pages>
   3:     <controls>
   4:       <add assembly="Gaia.WebWidgets" 
   5:            namespace="Gaia.WebWidgets" 
   6:            tagPrefix="gaia" />
   7:       <add assembly="Gaia.WebWidgets.Extensions"     
   8:            namespace="Gaia.WebWidgets.Extensions" 
   9:            tagPrefix="gaia" />
  10:     </controls>
  11:   </pages>
  12:  </system.web>


Gaia Controls

After that we will add a Gaia TextBox, Gaia Button and a Gaia Panel to the page: 

   1:  <gaia:TextBox runat="server" ID="searchFlickrTextBox" />
   2:  <gaia:Button 
   3:        runat="server" 
   4:        ID="searchFlickrButton" 
   5:        Text="Search Flickr" 
   6:        OnClick="searchFlickrButton_Click" />
   7:  <gaia:Panel 
   8:        runat="server" 
   9:        ID="flickrPhotosPanel" 
  10:        CssClass="flickr-images-container" /> 

 

These Gaia controls extend their ASP.NET counterparts to give you Ajax functionality out-of-the-box. We will use the Gaia Panel as a container for the images we will load on the page. By handling the Click event of the Gaia Button we can start to write the functionality.

We use the Property SearchTag to store the search text entered by the user in the ViewState. Then we clear the Controls collection of the container Panel and call LoadFlickrImages:

   1:  protected void searchFlickrButton_Click(object sender, EventArgs e)
   2:  {
   3:      SearchTag = searchFlickrTextBox.Text;
   4:      flickrPhotosPanel.Controls.Clear();
   5:      LoadFlickrImages();
   6:  }

 

We need to store some information in the ViewState in order to recreate the images on subsequent postbacks. Since we will add the images dynamically to the page, it is our responsibility (not ASP.NET's) to keep them "alive" between postbacks. We need to persist the search tag and the list of images and in Page_Load we can recreate the Image controls on each postback by calling LoadFlickrImages:

 

   1:  private List<FlickrImage> Images
   2:  {
   3:      get
   4:      {
   5:          if (ViewState["images"] == null)
   6:              ViewState["images"] = new List<FlickrImage>();
   7:          return (List<FlickrImage>) ViewState["images"];
   8:      }
   9:  }
  10:   
  11:  private string SearchTag
  12:  {
  13:      get { return (string)(ViewState["searchtag"] ?? string.Empty); }
  14:      set { ViewState["searchtag"] = value; }
  15:  }
  16:   
  17:  protected void Page_Load(object sender, EventArgs e)
  18:  {
  19:      if (IsPostBack && !string.IsNullOrEmpty(SearchTag) && Images.Count > 0)
  20:          LoadFlickrImages();
  21:  }

 

The LoadFlickrImages method is where the magic happens, so let's dive into it.

 

Communicating With Flickr

We start by calling another method, GetResponseJsonString, to ummm, get the response JSON string Smile.

   1:  var jsonString = GetResponseJsonString();

 

So let's look into that method first. We start by creating a Post HttpWebRequest object to communicate with the Flickr service:

   1:  var webRequest = (HttpWebRequest)WebRequest
   2:      .Create(string.Format(FlickrServiceUrl, SearchTag));
   3:     webRequest.Method = "POST";
   4:     webRequest.KeepAlive = false;

 

The service URL looks like this:

"http://api.flickr.com/services/feeds/photos_public.gne?tags={0}&tagmode=any&format=json&jsoncallback=%3F"

For a provided tag this would return JSON similar to the following:

   1:  ({
   2:   "title": "...",
   3:   "link": "...",
   4:   ...
   5:   "items": [
   6:      {
   7:         "title": "...",
   8:         "link": "...",
   9:         "media": {"m":"..."},
  10:         ... 
  11:      },
  12:      {
  13:         "title": "...",
  14:         "link": "...",
  15:         "media": {"m":"..."},
  16:         ... 
  17:      },
  18:      ...
  19:   ]
  20:  })

 

Then we will read the response stream into a string:

   1:  string jsonString;
   2:  using (var flickrResponse = webRequest.GetResponse() as HttpWebResponse)
   3:  {
   4:       if (flickrResponse == null)
   5:           return string.Empty;
   6:       // Get the response stream to read the response
   7:       using (var responseStream = flickrResponse.GetResponseStream())
   8:       {
   9:           if (responseStream == null)
  10:               return string.Empty;
  11:           // Read the response
  12:           using (var reader = new StreamReader(responseStream))
  13:           {
  14:               jsonString = reader.ReadToEnd();
  15:           }
  16:       }
  17:  }

 

Notice that the returned JSON above is wrapped in parentheses, so we need to remove those and return the JSON string back to the caller, LoadFlickrImages:

   1:  jsonString = jsonString.Remove(jsonString.IndexOf("("), 1);
   2:  return jsonString.Remove(jsonString.LastIndexOf(")"), 1);

 

Back in LoadFlickrImages we parse the returned JSON string using JSON.NET:

   1:  var responseJson = JObject.Parse(jsonString);

 

Then using linq to JSON, also part of JSON.NET, we can extract the useful information we want about each Image. For example here we extract the Title, the URL of the image's page on Flickr (Link) and the URL of the actual image thumbnail (Media).

 

   1:  var images = from item in responseJson["items"].Children()
   2:               select new FlickrImage 
   3:               {
   4:                   Title = (string)item["title"],
   5:                   Link = (string)item["link"],
   6:                   Media = (string)item["media"]["m"]
   7:               };

 

Then we need to update the generic list of images (List<FlickrImage>) that we keep in the ViewState:

   1:  Images.Clear();
   2:  Images.AddRange(images);

 

After that we can iterate over it and create a Gaia Image control for each one:

   1:  foreach (var image in Images)
   2:  {
   3:      var imageControl = new Image
   4:      {
   5:          ImageUrl = image.Media,
   6:          AlternateText = image.Title,
   7:          CssClass = "flickr-image"
   8:      };
   9:      imageControl.Aspects.Add(new AspectHoverable());
  10:      imageControl.Effects.Add(
  11:          AspectHoverable.EffectEventMouseOver, 
  12:          new EffectPulsate(1));
  13:   
  14:      flickrPhotosPanel.Controls.Add(imageControl);
  15:  }

 

Let's have a closer look at this code. Here we create the Gaia Image control and set its CssClass property. This CSS class "flickr-image" sets the margin style property on the images so that they would have a nice space between them when they are loaded on the page:

   1:  var imageControl = new Image
   2:  {
   3:      ImageUrl = image.Media,
   4:      AlternateText = image.Title,
   5:      CssClass = "flickr-image"
   6:  };

 

Then, we add a little effect that fires when the user hovers over the image:

   1:  imageControl.Aspects.Add(new AspectHoverable());
   2:  imageControl.Effects.Add(
   3:      AspectHoverable.EffectEventMouseOver, 
   4:      new EffectPulsate(1));


Aspects and Effects

This introduces us to two interesting features of Gaia, Aspects and Effects. Aspects are little pieces of functionality that you can add to Gaia controls. For example, if you need to make a Label clickable you can add an AspectClickable to its Aspects collection and this would give you a server-side event that you can handle when the Label is clicked. Effects are simply animations that you can apply on a Gaia control. 

 

   1:  imageControl.Aspects.Add(new AspectHoverable());

 

Here we are adding an AspectHoverable to the Image control. Doing this we have the opportunity to handle server-side events that fire when the user hovers over an image or away from it. In other words this way you can handle client-side events like OnMouseOver and OnMouseOut on the server using regular ASP.NET server-side events. This, of course, happens without needing to worry about client-side details or to write any Javascript. 

 

However, that is not the purpose behind adding AspectHoverable to the Image control. Looking at the other line we can see why:

   1:  imageControl.Effects.Add(
   2:      AspectHoverable.EffectEventMouseOver, 
   3:      new EffectPulsate(1));

 

We are adding an EffectPulsate to the Effects collection of the Image control. However, here we are also using what we call an effect event. These allow you to combine the use of both Aspects and Effects to have the Effects (which run on the client-side) fire in response to a client-side event like OnMouseOver in our case here. So unless you have explicitly chosen to handle server-side events for AspectHoverable, this will be purely client-side. And the best part is that you are able to achieve this without writing any Javascript.

 

DRIMR

Then we add the Image control to the Gaia Panel that is used as a container for the images:

   1:  flickrPhotosPanel.Controls.Add(imageControl);

 

This brings us to one of the most intelligent features of Gaia, DRIMR. DRIMR almost eliminates the need for partial rendering. Usually here we would have needed to re-render the Panel and it's child controls (the images) to the client, since we have changed the Controls collection of the Panel. However, Gaia, with DRIMR, is smart enough to know that the client-side hierarchy almost doesn't change, so it will get re-used instead of being destroyed and rebuilt. You will specially notice this on the second time (and subsequent times) you use the app. You can almost see that the images are changing without the client-side hierarchy being destroyed and rebuilt. You don't need to worry about learning anything new or doing anything yourself to get this amazing benefit. If you are using Gaia, DRIMR is doing what it's supposed to behind the scenes.

 

Conclusion

As you can see using Gaia Ajax you can basically rely on the knowledge you already have about ASP.NET to automatically get Ajax functionality and much more. You are also able to tap into client-side events and handle them using regular server-side events and you can even have pure client-side Effects. All that can be achieved without writing any Javascript or worrying about any client-side details. 



Gaia Ajax 3.7 *beta*

by Jan Blomquist 22. November 2010 15:13

Highlights

  • VS.NET 2010 Support (Improved Design Time Experience)
  • DRIMR enhancements (All extensions now utilize DRIMR)
  • Compatibility with ASP.NET and 3rd party control libraries

Links

Gaia Ajax 3.7 beta is a solid product that probably could have been labeled a release. It's currently deployed to multiple large scale production applications and is running smooth and fast. We do however strongly believe in getting some bits out for public consumption before we do the final mark and make it an official release.

Since we believe so strongly in open standards we have continued to evolve and innovate on top of the ASP.NET platform. Gaia Ajax 3.7 is yet another proof that Gaiaware is committed to you as a long term partner that you can put some trust in. Also due to the nature of our dual license policy and inclusion of source code you are guaranteed the ability to modify and extend the product.

GWF - Gaia Web Framework Video Demo

If you want to learn more about the possibilties with Gaia Ajax -we recommend you watch the following video demonstrating the GWF framework which we will ship with the final version of Gaia Ajax 3.7. It nicely demonstrates the power of Gaia Ajax as the best toolset for building powerful web applications on top of ASP.NET.

Where to from here

The 3.7 beta download only contains the dlls -so we are considering various installation frameworks to create a good install experience before we go live with the 3.7 release. We will fix reported issues asap and make them available via our build servers. If you want to go in production with the 3.7 beta simply just buy the 3.6 version which entitles you to use the 3.7 bits. Smile

Tags: , , ,

Ajax | Gaia | Mono

MVC on ASP.NET without ASP.NET MVC

by Jan Blomquist 10. February 2010 09:54

Background

MVC (Model View Controller) is an architectural pattern and in many ways the preferred approach for layering your application. ASP.NET MVC is Microsoft's solution to a set of common challenges that face web developers today. Some of these problems are: -

ASP.NET MVC "forces" the developer to model their application according to their MVC architecture and brings greater control and granularity over markup. Because of this, ASP.NET Ajax (or jQuery for that matter) becomes easier to use since you no longer need to deal with for example autogenerated IDs (ie: ctl101_panelContainer_GridView1) which can be hard to use in client-side ajax applications.

Throwing the baby out with the bath water

Another alleged "benefit" of ASP.NET MVC is that the WebForms model is thrown out, so concepts like ViewState, Postbacks and fully templated event driven server controls doesn't exist anymore. This can be a good thing for an html/css/javascript ninja who wants the pedal to the metal and don't like too many abstractions, however I would argue that MVC on top of the WebForms model is far more superior and in this blog we are going to outline the structure of such an application.

An example of a successful ASP.NET MVC implementation today is StackOverflow -one of the most frequently visited websites for professional developers online today. The development of this project is a small group of developers (3?) who work day to day on the project and have deep intrinsic knowledge of it's inner workings. 

ASP.NET MVC might be the right choice for you depending on your requirements, but creating ANY ASP.NET application today without utilizing some form of MVC seems outrageous IMHO. I would put forth the following postulate derived from this claim:

A well designed ASP.NET WebForms application is an MVC application

Let's take a closer look at how you would assemble such an MVC application using the WebForms model. Don't forget the following regarding design patterns: "A a design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations" - Wikipedia

MVC without ASP.NET MVC

We've created a small application that utilizes the MVC pattern on top of the WebForms model today. Currently it's published at one of our build servers.

When you open the sample you can click the (Click here to get the details]) button to expand various code listings and some code explainations. Let's walk through the application structure together. It's a simple list of Tasks that can be filtered by date and contact person. Since the whole idea is to separate the business code/logic from each UI/View I've created a few models and multiple views. The model is basically just a contract (interface) which defines the operations which the controller needs in order to function. Each View must implement the contract so the controller can do it's work. You have full freedom to architect your models as you find suitable and I would recommend you to favor composition over inheritance .


Models

Here's the code for the IActivityModel

Codebehind (C#/.cs)

   1:  namespace Gaia.WebWidgets.Samples.Combinations.WebApps.MVC.Models
   2:  {
   3:      /// <summary>
   4:      /// This is the model that "glues" together the filter and results and is the
   5:      /// main input to the Controller which then works against this model
   6:      /// </summary>
   7:      public interface IActivityModel
   8:      {
   9:          IActivityFilter Filter { get;}
  10:          IActivityList ViewResults { get;} 
  11:      }
  12:  }

 In order to reuse the Filter I've created it as a separate model. Then I went ahead and created a model which will be used to viewed the results based on the filter. This is the IActivityList model which can be seen here:

Codebehind (C#/.cs)

   1:  namespace Gaia.WebWidgets.Samples.Combinations.WebApps.MVC.Models
   2:  {
   3:      using System.Collections.Generic;
   4:      using Utilities;
   5:   
   6:      /// <summary>
   7:      /// Model that allows binding of results to a View
   8:      /// </summary>
   9:      public interface IActivityList
  10:      {
  11:          void View(IEnumerable<CalendarItem> data);
  12:      }
  13:  }

As you can see, the only operation currently needed is the View method which takes an IEnumerable in order to bind the data. By using such a low common denominator, we can bind to almost anything for presentation, even a custom scheduler component if one were to require such functionality.

Views

The sample has defined 3 views (Repeater, GridView and Listbox) + 1 Mock View used in UnitTests. The codebehind file for the GridView View can be seen here:

Codebehind (C#/.cs)

   1:  namespace Gaia.WebWidgets.Samples.Combinations.WebApps.MVC.Views
   2:  {
   3:      using System.Web.UI;
   4:      using System.Collections.Generic;
   5:      using Models;
   6:      using Utilities;
   7:   
   8:      public partial class ActivityListGridView : UserControl, IActivityList
   9:      {
  10:          void IActivityList.View(IEnumerable<CalendarItem> data)
  11:          {
  12:              zGrid.DataSource = data;
  13:              zGrid.DataBind();
  14:          }
  15:   
  16:      }
  17:  }

In this case we created a UserControl, but it could also have been a server control or an arbitrary class also. It just doesn't matter when modelling after the MVC pattern.

Some have argued that you loose control over markup with the WebForms model and that is true when using powerful components like (GridView, Scheduler, Window, TabControl, etc), but it doesn't have to. Here's a code excerpt from the RepeaterView and as you can see this will give you full control over rendered markup:

Markup (ASPX/.aspx)

   1:  <%@ Control 
   2:      Language="C#" 
   3:      AutoEventWireup="true" 
   4:      CodeBehind="ActivityListRepeater.ascx.cs" 
   5:      Inherits="Gaia.WebWidgets.Samples.Combinations.WebApps.MVC.Views.ActivityListRepeater" %>
   6:   
   7:  <gaia:Panel ID="w" runat="server">
   8:      <ul style="border: 1px solid #999; margin: 5px 5px 5px 0px;">
   9:          <asp:Repeater ID="zView" runat="server">
  10:              <ItemTemplate>           
  11:                     <gaia:Label ID="f" runat="server"><li></gaia:Label>
  12:                     <gaia:Label ID="dt" runat="server" Text='<%# Eval("ActivityDate", "{0:ddd dd. MMM}")%>' />
  13:                     <gaia:Label ID="p" Font-Bold="true" runat="server" Text=' <%# Eval("ContactPerson")%>' />
  14:                     <gaia:Label ID="t" ForeColor="red" runat="server" Text='<%# Eval("ActivityName")%>' />
  15:                     <gaia:Label ID="l" runat="server" /></li>
  16:              </ItemTemplate>
  17:          </asp:Repeater>
  18:      </ul>
  19:  </gaia:Panel>

And really? Are abstractions like Window, Scheduler, Grid bad? I would'n want to develop without my reusable server controls!

The C in MVC - Controllers

Ok - we have defined the model and seen the code for some views. Let's examine the Controller and see how that works.

Codebehind (C#/.cs)

   1:  namespace Gaia.WebWidgets.Samples.Combinations.WebApps.MVC.Controllers
   2:  {
   3:      using System;
   4:      using System.Collections.Generic;
   5:      using Utilities;
   6:      using Data;
   7:      using Models;
   8:   
   9:      /// <summary>
  10:      /// This is the Controller in the MVC pattern and it acts as the "hub" and is responsible for
  11:      /// working on the models and implementing business rules, DAL communication, etc
  12:      /// </summary>
  13:      public class ActivityController : ControllerBase
  14:      {
  15:          private readonly IActivityModel _activityModel;
  16:   
  17:          public ActivityController(IActivityModel activityModel)
  18:          {
  19:              _activityModel = activityModel;
  20:          }
  21:   
  22:          public override void Initialize()
  23:          {
  24:              _activityModel.Filter.BindPersons(ActivityDataLayer.GetContacts());
  25:              _activityModel.Filter.When = DateTime.Now.Date;
  26:   
  27:              ViewChanged();
  28:          }
  29:   
  30:          IEnumerable<CalendarItem> GetItems()
  31:          {
  32:              return ActivityDataLayer.GetByDateAndPerson(_activityModel.Filter.When, _activityModel.Filter.SelectedPerson);
  33:          }
  34:   
  35:          public override void ViewChanged()
  36:          {
  37:              _activityModel.ViewResults.View(GetItems());
  38:          }
  39:    
  40:      }
  41:  }

Another model From the code you can see that we take a model as input parameter to the constructor. This model will be the View itself. In the initialize method we set default values for the DateTime filter and populate the list of available ContactPersons from which the UI can select a person. The IActivityFilter also denotes the SelectedPerson so we should have sufficient information to perform a Filter operation and retrieve data.

Notice the call to the View method on the model where the data is passed in. This takes place in the ViewChanged() operation which can be invoked from the UI too. For example in the SelectedIndexChanged event of the dropdownlist. Ok, so now you have seen the three layers in the MVC architecture. The benefits we have seen so far is

  • Disconnected UI from business logic.
  • UI/Client could easily have been something else (Mobile, WinForms, etc)
  • Removed code from the UI where it might introduce "spaghetti code"
  • Stricter adherence to contract lessens error likeliness

Unit Testing

Ok, but how would you go about and test this stuff? We could have tested this in multiple ways, but the easiest is probably to create mock objects that represent the Views and then pass these MockModels as input parameters to the Controller. Here's a few "dummy" examples of some unit tests. I've just faked the unit test framework and you can swap this out with your favorite unit testing framework. 

Codebehind (C#/.cs)

   1:  namespace Gaia.WebWidgets.Samples.Combinations.WebApps.MVC.Tests
   2:  {
   3:      using System;
   4:      using Controllers;
   5:      using Data;
   6:   
   7:      /// <summary>
   8:      /// This is just a "dummy" test-suite to demonstrate that it's easy to write
   9:      /// TDD - Test Driven Development against an MVC application
  10:      /// </summary>
  11:      public class ActivityTests
  12:      {
  13:          public void Test_ActivityController_TestInitialize()
  14:          {
  15:              ActivityModelMock mock = new ActivityModelMock();
  16:              new ActivityController(mock).Initialize();
  17:   
  18:              bool dateInitialized = mock.Filter.When == DateTime.Now.Date;
  19:              DummyAssert.IsTrue(dateInitialized);
  20:          }
  21:   
  22:          public void Test_ActivityController_TestFilter()
  23:          {
  24:              ActivityModelMock mock = new ActivityModelMock();
  25:              new ActivityController(mock).Initialize();
  26:   
  27:              ActivityListMock view = mock.ViewResults as ActivityListMock;
  28:   
  29:              bool sameData = ActivityDataLayer.GetByDateAndPerson(
  30:                  mock.Filter.When, mock.Filter.SelectedPerson).Count== view.CalendarItems.Count;
  31:              DummyAssert.IsTrue(sameData, "Different data based on same filter");
  32:          }
  33:   
  34:          public void Test_ActivityController_TestMockObject()
  35:          {
  36:              ActivityModelMock mock = new ActivityModelMock();
  37:              new ActivityController(mock).Initialize();
  38:   
  39:              ActivityListMock view = mock.ViewResults as ActivityListMock;
  40:              DummyAssert.IsTrue(view != null, "Unable to get test implementation");
  41:          }
  42:   
  43:      }
  44:  }

Suddenly we've created a robust architecture based on the principles of MVC. Also we've taken advantage of all the good things that come for free in Gaia Ajax and we've built on top of the powerful WebForms model on ASP.NET. And we've made our code highly testable and reusable.

Routing / Dynamic Loading

What more could there be? Well, since you're asking we could have implemented dynamic loading of views (routing?) based on some scheme (url, page, configuration, etc) and in fact this sample automatically loads the available Views dynamically and populates the DropDownList with all the Views that implement the model that we are looking for. This functionality is implemented on the page level and allows you to switch out UI/View on-the-fly. Just click here and  try it out for yourself.

Other ASP.NET MVC drawbacks

An author behind one of the ASP.NET MVC books (Jeff Putz) points out some of the ASP.NET MVC drawbacks on his blog

  1. It also lacks the kind of UX encapsulation that we get with Webforms. For example, I have a template based image gallery control that I've used time and time again. The markup that appears in each cell of the table can be anything I want, and I can tell it to leave a "hole" for a template containing an advertisement. All I do is drop it on a Webform and fill in the templates and it automagically works. This kind of reuse isn't in the strictest sense possible in MVC if you're adhering to the design pattern.
  2. The magic of having a simulated stateful form is also gone, with no postback mechanism. The entire event model is thrown out.
  3. Views feel a little like spaghetti code from old ASP (the scripting platform that used the tragic VBscript)
  4. And the biggest concern I have is that developers won't be thinking about security the way they should. It's already possible in Webforms (or any other platform) to put together an HTTP request with the right information to simulate a legitimate user action and do naughty things when the right preventative code is not in place, but it's even easier in MVC. A URL like "/cats/kill/42" is probably intended to execute cat.Lives-- and it's easy to guess. A lot more care has to be taken to validate data and enforce security.

At the moment I don't see any reason to abandon the WebForms model in favor of ASP.NET MVC, generally because we've had MVC for a long time already, but more specifically for the reasons outlined above and in particular because of simulated Windows Forms development experience brought by the WebForms model. I can respect that many developers don't see this from my point of view if they are using jquery/asp.net ajax and similar client-side technologies. The MVC architecture on top of the WebForms model becomes truly aparent with the right tooling and proper abstractions -like Gaia Ajax. The same would go for related techologies like (Google Web Toolkit)

Conclusion

The following quote from Jeff Atwoods blog pretty much summarizes my feelings about the ASP.NET MVC stuff:

"As we work with ASP.NET MVC on Stack Overflow, I find myself violently thrust back into the bad old days of tag soup that I remember from my tenure as a classic ASP developer in the late 90's. If you're not careful bordering on manically fastidious in constructing your Views, you'll end up with a giant mish-mash of HTML, Javascript, and server-side code. Classic tag soup; difficult to read, difficult to maintain."

If you want to comment on the blog, please use our forums at forum.gaiaware.net

Time's up! Gaia Ajax 3.6 Alpha Released!

by Jan Blomquist 13. September 2009 21:01

Thank you for your patience and continued belief in our product. It is our vision to bring you the finest quality for ajax development on the ASP.NET platform. The 3.6 version comes with practical innovation previously unavailable to ASP.NET developers. Hopefully it will bring "goosebumps" similar to the ones we had the first time Microsoft unveiled ASP.NET almost a decade ago. 

"3.6 is backwards compatible and introduces a paradigm shift called adaptive rendering"

Links and downloads

  • Click here to download Gaia Ajax 3.6 "alpha"
    Exe with Visual Studio Integration 30 day trial

  • Click here to download Gaia Ajax 3.6 "alpha" - Tar.gz binaries + source - for open source projects
  • Click here to download Gaia Ajax 3.6 "alpha" commercial (requires subscription) 

Highlights from the Gaia Ajax 3.6 release

1. Adaptive Rendering
Adaptive Rendering is a mind-blowing concept that enables dynamic insertion, removal, moving and replacement of individual controls. The concept has far reaching implications and is the breakthrough technology that will make you hunger for Gaia as the building blocks for your UI layer

  • Click here for a sample that demonstrates dynamic inserts and removals of controls and compare it to the usage of traditional partial rendering
  • Click here for a sample of the chess game featuring dynamic control moves
  • Click here for a sample of our "PageFlakes" sample that also features dynamic moves
  • Click here to check out a sample that demonstrates all features of adaptive rendering, including control replacements via databinding
Jan Blomquist has written an extensive review of Adaptive Rendering on his personal blog.

2. Ajax GridView
The Gaia Ajax GridView is a premier example of adaptive rendering as it enables the worlds most advanced GridView for ASP.NET without much code at all. The GridView still supports all the operations like ( filtering, sorting, selection, deletions, updates, etc ) and it's all ajaxified thanks to adaptive rendering.  

  • Click here for a sample that demonstrates the Gaia Ajax GridView in action

3. 100++ new Samples!
In the package you will find a total of 128 samples ranging from minimalistic ones to extensive, almost full applications in themselves. This is all packaged into a new samples framework that simplifies navigation, code view, VB.NET code availability, etc. 

Note: The samples are now utilizing the WAP project type

More...

How To Create An Async Ajax Google Search with ASP.NET And Gaia Ajax

by Stian Solberg 26. May 2009 06:30

Recently we decided to add a searching feature for the different sites we run on gaiaware.net: main site, blogs, forum, tracker, docs and API reference. We wanted to be able to search each site separately and still have all the results presented in a intuitive way. And of course, it should be built using Gaia Ajax, so it could be quickly developed (our customers say they increase the productivity by 30-50% on the ASP.NET platform when using Gaia Ajax) and give a responsive and ajaxified user experience.

Async Search with ASP.NET Ajax

We have purchased a Google Site Search subscription so we don't have to reinvent the wheel again and make our own site spider. The Google Site Search gives us the search results in XML, and we can parse and present them in any way we would like.

The challenge: multiple search sources with ASP.NET

Since we wanted to present the results from each sub site in separate sections, we needed to overcome some limitations of what Google Site Search gives us. E.g. you can return max 20 results per search. Since we wanted to separate the results in each sub domain (e.g. forum.gaiaware.net) we needed to use the useful "site:" parameter in a Google query. That meant that we needed to fire off 5-6 Google searches for each search we executed on our own page. Our immediate concern was how long time it would take to perform so many Google searches, return them, parse them and present them on our ASP.NET page.

More...

Gaia Ajax training 10-11th June in Norway

by Stian Solberg 12. May 2009 07:30

We're excited to announce the first official Gaia Ajax course. Many have been asking for this and now it's here!

This course will teach you how you can build everything from small web portals to enterprise applications using Gaia Ajax on the ASP.NET platform. We will be spending most of our time in Visual Studio.NET exploring required ASP.NET skills and the essential Gaia knowledge.

Early Bird Offer

Quick Facts

Registration: Via contact form or email us: support@gaiaware.net with number of participants.

Target Audience: .NET Developers
Max Participants: 12
Language: English

Date: June 10-11th at 09.00 - 15.30
Price: EUR 1100 Incl.lunch. excl.hotel

Location: Gaiaware HQ (Klosterøya), Skien – NORWAY
57 km from Torp International Airport
134 km from Oslo
View map

Hotel suggestions:
Thon Hotel Høyers
Clarion Collection Hotel Bryggeparken

Agenda

  • Quick introduction 
  • Important ASP.NET semantics 
  • Get to know the Gaia Server Controls 
  • Unleash your productivity with Aspects in Gaia 
  • Effect library 
  • Skinning Gaia 
  • Extending Gaia 
  • Data management with Gaia 
  • Debugging, error handling and security with Gaia

At the evening we're planning to do a bit of socializing and exchange experiences with building web applications using Gaia.

Instructor: Jan Blomquist (MVP)

Jan Blomquist (MVP)Jan Blomquist has many years experience in software development and is one of the core architects behind Gaia Ajax. Jan has also been awarded Microsoft MVP (Most Valued Professional) since 2005. Jan Blomquist has trained thousands of people in building software and has often been a presenter at various Microsoft events. Jan has also appeared on DotNetRocks TV (http://dnrtv.com), which is a very popular TV show for .NET developers worldwide.

Includes complete course on DVD

The entire course will be screen-recorded for later viewing. Each student is granted a non-transferable viewer license to the course recordings. The student will receive the videos on a DVD or in a downloadable package either on-site or at a later time.

 

Gaiaware HQ in summer
Gaiaware HQ in summer


Gaiaware HQ entrance
Gaiaware HQ entrance

Clarion Collection Hotel Bryggeparken - in walking distance
Clarion Collection Hotel Bryggeparken - in walking distance

Where's the Right Way to Ajax?

by Stian Solberg 20. April 2009 10:59

Dino Esposito has written an article on DotNetSlackers with an oveview of different Ajax Web Architectures. The article covers how Gaia Ajax fits into a "Active Server Pages" pattern, and why Gaia is a solid architecture for your next web application.

Gaia Ajax is an Ajax toolbox for ASP.NET and Mono. The library is dual licensed, where you can use the GPL license for building open source projects, and for your proprietary projects you can obtain a commercial license.

Read the complete article on DotNetSlackers

Gaia Ajax 3.5 Released!

by Stian Solberg 4. March 2009 13:53
"Imagination is the beginning of creation. You imagine what you desire, you will what you imagine and at last you create what you will."
-George Bernard Shaw

Highlights of Gaia Ajax 3.5

Doubled Speed
Massive performance gains - up to 50% - in Ajax callbacks.



Zero ViewState
We've improved our internal ViewState logic.
For you: even less data sent, even faster applications!


20+ New Features And Enhancements
Built-in Default Skin, Multi File Upload, Better AspectKey, Improved Hybrid Control Collection ++ See list of new features and enhancements



60+ Bug Fixes
Thanks to feedback from our community and customers, over 60 bugs are fixed. Gaia is now even more stable! Complete change log 

  

Even More Stuff!

Improved Pricing

Take a look at our order page to see the new prices.

Take a quick survey - win a subscription license!

To constantly improve the quality of our deliverance we are conducting a quick survey. It takes two minutes, and all participating will have a chance to win a one year subscription of Gaia Ajax (value: $595) 
Take the survey here

Case Study: Logica

Logica is a leading IT and business services company, employing 40,000 people.
Read how they succeeded with Gaia 


Yes,one last thing: everyone can download the trial version. Go to http://gaiaware.net/download

As always, we love feedback. Use the comments or our the forum.

Best regards,

The Gaiaware Team.

Gaia and Ajax on Mobile Devices

by Jan Blomquist 25. February 2009 10:28

More and more Ajax Web applications are targeting the mobile browser. The age of dull and slow web experiences are long gone and the demand for high response and high interactivity on the mobile phone is here. At the end we present the 10 key tenets for building these next generation mobile web applications. 

Gaia Ajax on Mobile Devices in the Real World

Recently we delivered an Ajax Web Application with a Dual UI using templating techniques spiced with inspiration from Model View Presenter. The result was a single codebase with simple multi-device targeting. All built with open source technologies like Gaia Ajax, Castle ActiveRecord, Nhibernate, ZedGraph, NUnit and MySQL. And of course the solution worked nicely on Mono too :-)

We've tested Gaia Ajax on the following devices

All of them worked nicely with Gaia Ajax, except a few customizations for Opera Mobile. Let's have a look at how you can enable Gaia Ajax for this wonderful browser too, which by coincidence happens to be developed here in Norway too.

Fix for Opera Mobile

We use Prototype.js under the hood on the client side and unfortunately there's a small bug in Prototype that makes the Ajax engine break down on Opera Mobile. There are two ways to work around this problem.

  1. Embed the code snippet below somewhere on your ASP.NET page to override the Ajax.Request prototype implementation.
  2. Overwrite prototype.js in the Gaia.WebWidgets project and rebuild.

Code

   1:  <script type="text/javascript">
   2:      Element.observe(window, 'load', function() {
   3:          Ajax.Request.prototype.initialize = function(url, options) {
   4:              this.options = {
   5:                  method:       'post',
   6:                  asynchronous: true,
   7:                  contentType:  'application/x-www-form-urlencoded',
   8:                  encoding:     'UTF-8',
   9:                  parameters:   '',
  10:                  evalJSON:     true,
  11:                  evalJS:       true
  12:              };
  13:              Object.extend(this.options, options || { });
  14:   
  15:              this.options.method = this.options.method.toLowerCase();
  16:              if (Object.isString(this.options.parameters))
  17:                  this.options.parameters = this.options.parameters.toQueryParams();
  18:              else if (Object.isHash(this.options.parameters))
  19:                  this.options.parameters = this.options.parameters.toObject();
  20:              
  21:              this.transport = Ajax.getTransport();
  22:              this.request(url);
  23:          }
  24:      });
  25:  </script>

It's worth mentioning that this patch is only valid for Gaia Ajax since we know what we use.

Note! This is not a patch that should be applied to Prototype.js overall.  

Another 10 Key Reasons to use Gaia Ajax for Mobile Web Development

  1. Unified codebase
  2. Multi device targeting for broad reach
  3. No need to expose biz logic to client
  4. Single point of deployment
  5. Based on open standards
  6. Write applications in managed code (C#, VB.NET, Ruby.NET, IronPython, etc)
  7. No sync issues
  8. Minimal maintenance costs
  9. Rich user experience without the need for javascript
  10. No security hazards/breaches
Don't surrender to binary code distributions, but embrace open standards.