using System;
using System.Data;
using System.Data.SqlClient;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.Configuration;

public partial class AsyncDataBind : System.Web.UI.Page
{
    private SqlConnection _connection;
    private SqlCommand _command;
    private SqlDataReader _reader;
    
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            AddOnPreRenderCompleteAsync(
                new BeginEventHandler(BeginAsyncOperation),
                new EndEventHandler(EndAsyncOperation)
            );
        }
    }

    IAsyncResult BeginAsyncOperation (object sender, EventArgs e,
        AsyncCallback cb, object state)
    {
        string connect = WebConfigurationManager.ConnectionStrings
            ["AsyncPubs"].ConnectionString;
        _connection = new SqlConnection(connect);
        _connection.Open();
        _command = new SqlCommand(
            "SELECT title_id, title, price FROM titles", _connection);
        return _command.BeginExecuteReader (cb, state);
    }

    void EndAsyncOperation(IAsyncResult ar)
    {
        _reader = _command.EndExecuteReader(ar);
    }

    protected void Page_PreRenderComplete(object sender, EventArgs e)
    {
        Output.DataSource = _reader;
        Output.DataBind();
    }

    public override void Dispose()
    {
        if (_connection != null) _connection.Close();
        base.Dispose();
    }
}

<%@ WebHandler Language="C#" Class="TerraServiceImageGrabber" %>

using System;
using System.Web;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

public class TerraServiceImageGrabber : IHttpHandler
{
    public void ProcessRequest (HttpContext context)
    {
        // Extract user input from the query string
        string city = context.Request["City"];
        string state = context.Request["State"];
        string scale = context.Request["Scale"];

        // If city or state wasn't specified, throw an exception
        if (String.IsNullOrEmpty(city) || String.IsNullOrEmpty(state))
            throw new ArgumentException(
                "City and state must be specified via query string");

        // Determine the scale
        Scale res = Scale.Scale8m;
        if (!String.IsNullOrEmpty (scale))
        {
            switch (scale)
            {
                case "1":
                    res = Scale.Scale1m;
                    break;

                case "2":
                    res = Scale.Scale2m;
                    break;

                case "4":
                    res = Scale.Scale4m;
                    break;

                case "8":
                    res = Scale.Scale8m;
                    break;

                case "16":
                    res = Scale.Scale16m;
                    break;

                case "32":
                    res = Scale.Scale32m;
                    break;
            }
        }

        // Generate the requested image
        using(Bitmap bitmap = GetTiledImage(city, state, res, 900, 600))
        {
            // Set the response's content type
            context.Response.ContentType = "image/jpeg";

            // Write the image to the HTTP response
            bitmap.Save(context.Response.OutputStream, ImageFormat.Jpeg);
        }
    }

    public bool IsReusable { get { return true; } }

    private Bitmap GetTiledImage (string city, string state,
        Scale scale, int cx, int cy)
    {
        // Instantiate the TerraService proxy
        TerraService ts = new TerraService ();

        // Get the latitude and longitude of the requested city
        Place place = new Place ();
        place.City = city;
        place.State = state;
        place.Country = "USA";
        LonLatPt point = ts.ConvertPlaceToLonLatPt (place);

        // Compute the parameters for a bounding box
        AreaBoundingBox abb = ts.GetAreaFromPt (point, Theme.Photo,
            scale, cx, cy);

        // Create an image to fit the bounding box
        Bitmap bitmap = new Bitmap (cx, cy, PixelFormat.Format32bppRgb);
        using(Graphics g = Graphics.FromImage(bitmap))
        {
            int x1 = abb.NorthWest.TileMeta.Id.X;
            int y1 = abb.NorthWest.TileMeta.Id.Y;
            int x2 = abb.NorthEast.TileMeta.Id.X;
            int y2 = abb.SouthWest.TileMeta.Id.Y;

            for (int x=x1; x<=x2; x++) {
                for (int y=y1; y>=y2; y--) {
                    TileId tid = abb.NorthWest.TileMeta.Id;
                    tid.X = x;
                    tid.Y = y;
                    using(Image tile = Image.FromStream(
                        new MemoryStream(ts.GetTile(tid))))
                    {
                        g.DrawImage(tile,
                            (x - x1) * tile.Width  - 
                                (int) abb.NorthWest.Offset.XOffset,
                            (y1 - y) * tile.Height - 
                                (int) abb.NorthWest.Offset.YOffset,
                            tile.Width, tile.Height);
                    }
                }
            }
        }

        // Return the image
        return bitmap;
    }
}

<%@ WebHandler Language="C#" Class="AsyncTerraServiceImageGrabber" %>

using System;
using System.Web;
using System.Drawing;
using System.Drawing.Imaging;
using System.Threading;
using System.IO;

public class AsyncTerraServiceImageGrabber : IHttpAsyncHandler
{
    private TerraService _ts;
    private TerraServiceAsyncResult _ar;
    private Scale _scale = Scale.Scale8m;
    private AreaBoundingBox _abb;
    private Bitmap _bitmap;
    private int _count = 0;
    private int _max;
    private HttpContext _context;
    private Exception _ex;
    private int _cx = 900, _cy = 600; // Width and height of bitmap
    
    public void ProcessRequest (HttpContext context)
    {
        // Never called
    }
        
    public bool IsReusable { get { return false; } }

    public IAsyncResult BeginProcessRequest(HttpContext context,
        AsyncCallback cb, object state)
    {
        _context = context;
        
        // Extract user input from the query string
        string city = context.Request["City"];
        string region = context.Request["State"];
        string scale = context.Request["Scale"];

        // If city or state wasn’t specified, throw an exception
        if (String.IsNullOrEmpty(city) || String.IsNullOrEmpty(region))
            throw new ArgumentException(
                "City and state must be specified via query string");
        
        // Determine the scale
        if (!String.IsNullOrEmpty (scale))
        {
            switch (scale)
            {
                case "1":
                    _scale = Scale.Scale1m;
                    break;

                case "2":
                    _scale = Scale.Scale2m;
                    break;

                case "4":
                    _scale = Scale.Scale4m;
                    break;

                case "8":
                    _scale = Scale.Scale8m;
                    break;

                case "16":
                    _scale = Scale.Scale16m;
                    break;

                case "32":
                    _scale = Scale.Scale32m;
                    break;
            }
        }

        // Instantiate a TerraServiceAsyncResult
        _ar = new TerraServiceAsyncResult(cb, state);
          
        // Instantiate the TerraService proxy
        _ts = new TerraService();

        // Make an async call to get the latitude and longitude
        // of the requested city
        Place place = new Place();
        place.City = city;
        place.State = region;
        place.Country = "USA";

        _ts.BeginConvertPlaceToLonLatPt(place,
            new AsyncCallback(ConvertPlaceToLonLatCompleted), null);

        // Return an IAsyncResult that delays EndProcessRequest until
        // the final asynchronous Web service call has completed
        return _ar;
    }

    private void ConvertPlaceToLonLatCompleted(IAsyncResult ar)
    {
        try
        {
            // Complete the async call
            LonLatPt point = _ts.EndConvertPlaceToLonLatPt(ar);

            // Make an async call to compute the parameters
            // for a bounding box
            _ts.BeginGetAreaFromPt(point, Theme.Photo, _scale, _cx,
              _cy, new AsyncCallback(GetAreaFromPointCompleted), null);
        }
        catch (Exception ex)
        {
            _ex = ex;
            _ar.CompleteCall();
        }
    }

    private void GetAreaFromPointCompleted(IAsyncResult ar)
    {
        try
        {
            // Complete the async call
            _abb = _ts.EndGetAreaFromPt(ar);

            // Create an image to fit the bounding box
            _bitmap = new Bitmap(_cx, _cy, PixelFormat.Format32bppRgb);

            int x1 = _abb.NorthWest.TileMeta.Id.X;
            int y1 = _abb.NorthWest.TileMeta.Id.Y;
            int x2 = _abb.NorthEast.TileMeta.Id.X;
            int y2 = _abb.SouthWest.TileMeta.Id.Y;

            _max = (x2 - x1 + 1) * (y1 - y2 + 1);

            // Place concurrent async calls to TerraService to
            // fetch image tiles
            for (int x = x1; x <= x2; x++)
            {
                for (int y = y1; y >= y2; y--)
                {
                    TileId tid = new TileId();
                    tid.Theme = _abb.NorthWest.TileMeta.Id.Theme;
                    tid.Scale = _abb.NorthWest.TileMeta.Id.Scale;
                    tid.Scene = _abb.NorthWest.TileMeta.Id.Scene;
                    tid.X = x;
                    tid.Y = y;
                    _ts.BeginGetTile(tid,
                        new AsyncCallback(GetTileCompleted),
                        new Point(x - x1, y1 - y));
                }
            }
        }
        catch (Exception ex)
        {
            _ex = ex;
            _ar.CompleteCall();
        }
    }

    private void GetTileCompleted(IAsyncResult ar)
    {
        try
        {
            // Complete the async call
            using(Image tile = Image.FromStream(
                new MemoryStream(_ts.EndGetTile(ar))))
            {
                // Draw the tile onto the bitmap
                Point point = (Point)ar.AsyncState;
                int dx = point.X;
                int dy = point.Y;

                lock (_bitmap)
                {
                    using(Graphics g = Graphics.FromImage(_bitmap))
                    {
                        g.DrawImage(tile,
                            dx * tile.Width – 
                                (int)_abb.NorthWest.Offset.XOffset,
                            dy * tile.Height – 
                                (int)_abb.NorthWest.Offset.YOffset,
                            tile.Width, tile.Height);
                }
            }

            // Increment the tile count and complete the request if all
            // tiles have been fetched
            int count = Interlocked.Increment(ref _count);
            if (count == _max) _ar.CompleteCall();
        }
        catch (Exception ex)
        {
            _ex = ex;
            _ar.CompleteCall();
        }
    }

    public void EndProcessRequest(IAsyncResult ar)
    {
        if (_ex != null)
        {
            // If an exception was thrown, rethrow it
            throw _ex;
        }
        else
        {
            // Otherwise return the generated image
            _context.Response.ContentType = "image/jpeg";
            _bitmap.Save(_context.Response.OutputStream,
                ImageFormat.Jpeg);
            _bitmap.Dispose();
        }
    }
}

class TerraServiceAsyncResult : IAsyncResult
{
    private AsyncCallback _cb;
    private object _state;
    private ManualResetEvent _event;
    private bool _completed = false;
    private object _lock = new object();

    public TerraServiceAsyncResult(AsyncCallback cb, object state)
    {
        _cb = cb;
        _state = state;
    }
    
    public Object AsyncState { get { return _state; } }

    public bool CompletedSynchronously { get { return false; } }

    public bool IsCompleted { get { return _completed; } }

    public WaitHandle AsyncWaitHandle
    {
        get
        {
            lock (_lock)
            {
                if (_event == null)
                    _event = new ManualResetEvent(IsCompleted);
                return _event;
            }
        }
    }

    public void CompleteCall()
    {
        lock (_lock)
        {
            _completed = true;
            if (_event != null) _event.Set();
        }

        if (_cb != null) _cb(this);
    }
}

using System;
using System.Web; 
using System.IO;

public class RequestLogModule : IHttpModule
{
    public void Init (HttpApplication application)
    { 
        application.PreRequestHandlerExecute +=
            new EventHandler(OnPreRequestHandlerExecute);
    }

    public void Dispose () {}

    void OnPreRequestHandlerExecute(Object sender, EventArgs e)
    {
        HttpApplication app = (HttpApplication)sender;
        DateTime time = DateTime.Now;

        using(StreamWriter writer = new StreamWriter(
            app.Server.MapPath("~/App_Data/RequestLog.txt"), true))
        {
            string line = String.Format(
                "{0,10:d}    {1,11:T}    {2, 32}   {3}",
                time, time,
                app.User.Identity.IsAuthenticated ?
                app.User.Identity.Name :
                app.Request.UserHostAddress,
                app.Request.Url);
            writer.WriteLine (line);
        }
    }
}

using System;
using System.Web; 
using System.IO;
using System.Threading;
using System.Text;

public class AsyncRequestLogModule : IHttpModule
{
    private FileStream _file;
    private static long _position = 0;
    private static object _lock = new object();
    
    public void Init (HttpApplication application)
    { 
        application.AddOnPreRequestHandlerExecuteAsync (
            new BeginEventHandler (BeginPreRequestHandlerExecute), 
            new EndEventHandler (EndPreRequestHandlerExecute)
        );
    }

    IAsyncResult BeginPreRequestHandlerExecute (Object source,
        EventArgs e, AsyncCallback cb, Object state)
    {
        HttpApplication app = (HttpApplication)source;
        DateTime time = DateTime.Now;

        string line = String.Format(
            "{0,10:d}    {1,11:T}    {2, 32}   {3}\r\n",
            time, time,
            app.User.Identity.IsAuthenticated ?
            app.User.Identity.Name :
            app.Request.UserHostAddress,
            app.Request.Url);

        byte[] output = Encoding.ASCII.GetBytes(line);

        lock (_lock)
        {
            _file = new FileStream(
                HttpContext.Current.Server.MapPath(
                    "~/App_Data/RequestLog.txt"),
                FileMode.OpenOrCreate, FileAccess.Write,
                FileShare.Write, 1024, true);

            _file.Seek(_position, SeekOrigin.Begin);
            _position += output.Length;
            return _file.BeginWrite(output, 0, output.Length, cb, state);
        }
    }

    void EndPreRequestHandlerExecute (IAsyncResult ar)
    {
        _file.EndWrite(ar);
        _file.Close();
    }

    public void Dispose () {}
}