* ASP.NET
ASP.NET support is divided in two pieces:
* Web Forms (Web Applications infrastructure).
* Web Services (the SOAP-based rpc system).
There is work underway for both systems. The Web Forms
support is more advanced at this point, and various ".aspx"
programs can be run using the Mono runtime and the XSP page
parser.
We are now working HttpRuntime and related classes to make our
implementation mostly compatible with MS.
Tim started work on the Web Services. Although we have a
SoapFormatter as part of the remoting infrastructure already
(contributed by Jesus), most people will be using the ASP.NET
Web Services support. Work for the supporting class libraries
just started recently.
* Web Forms: The pieces
There are a couple of components to the puzzle:
* .aspx page parser (converts .aspx to C# code).
* System.Web.HttpRuntime support.
* Web controls (System.Web.UI.HtmlControls and
System.Web.UI.WebControls).
* Underlying infrastructure for the controls (System.Web.UI).
* HttpRuntime.ProcessRequest is the core of the ASP.NET
implementation.
Gonzalo has been working on an ASP.NET parser that takes .aspx
files and generated the code required to run them (the code lives in
module `xsp' along with a little web server for testing).
Most of the runtime support was written by Patrik Torstensson
(now at Intel). This was interesting, because in order to implement
some of its features, Patrik had to go into the runtime/JIT engine and
he spent a few weeks doing work there.
The classes for running ASP.NET are being actively written.
Gaurav, Leen and Patrik worked in the core of the classes
required to run ASP.NET web application as well as a small
embeddable web server.
Duncan got our System.Web assembly to compile.
** HttpRuntime
Patrik has authored most of the HttpRuntime support (both on
the System.Web and on the foundation).
We are currently working on this.
** XSP
This is where initial development of the .aspx compiler to C#
took place. That compiler is now integrated in System.Web classes
mostly under System.Web.Compilation namespace.
We still keep the compiler and the initial web server used to debug
HtmlControls and WebControls under xsp/src directory. This will
stop working some time soon in favor of a new server, that is also
compatible with MS runtime.
There is also a bunch of .aspx pages to test the server along with
a few user controls under xsp/test.
We added a new web server that works with MS runtime and is being
used to debug our classes. Currently it does not work with mono
runtime, but will do :-). It resides in xsp/server. A couple of
classes of this new server can be reused/extended to make an apache
module/cgi using mono (MonoWorkerRequest and MonoApplicationHost).
The C# code generator has been moved to System.Web.Compilation
** Controls
A lot of work has been put in the various classes that
implement the controls (UI.HtmlControls and UI.WebControls),
but they have been coded mostly in the dark, and without being
able to test them in real life: Gaurav and Leen worked very
hard on this namespace.
We can now render all HtmlControls and almost all WebControls.
DataGrid and DataList controls are being finished by Gaurav.
Xml control needs some work on System.Xml related to XSL.
** Extending ASP.NET
Currently you have to reference in your ASP.NET the control
and all of its properties, which works fine if you have a GUI
designer, but is harder for people used to develop using text
editors.
Since we have a parser, we could extend this parser to allow
people to still use ASP.NET controls, using a simpler syntax.
For example people doing blogs and editing their templates
over the web probably do not want to use direct ASP.NET but a
wrapper around it.
** Roadmap
1. The Parser.
2. Get the parser to generate output compatible with ASP.NET.
3. Run the sample output with the real Microsoft runtime
but using our generated page.
4. Run the sample with our classes with the .NET runtime.
5. Run the samples with our classes with the our runtime (without
using HttpRuntime).
6. Finish HttpRuntime.
We are here.
7. Running our sample code with our classes with our runtime.
** How to Help
Testing and fixing HtmlControls, WebControls and validators is an
easy way to help.
In the CVS module XSP you can find the aspx to C# page parser,
a little web server used for testing and a directory containing
sample aspx pages.
You have some documentation under doc directory and in the README
file of each directory. They explain how to test our System.Web.
Testing is really easy!
We will soon get the new server working with our runtime. This way
we'll have a server that runs on both MS and mono runtime and will
make it easier to check the functionally against both runtimes.