Response is not available in context? How to solve

Question

I save a pdf file to stream. I want to save the stream to Response stream. But it always throw error:Response is not available in contex.

Here is the code:

using System;
using System.Threading;
using System.IO;

using Spire.Pdf;

namespace SingleThreadTest
{

    public partial class Test : System.Web.UI.Page
    {
        //[STAThread]
        protected void Page_Load(object sender, EventArgs e)
        {
        }
        [STAThread]
        protected void Button1_Click(object sender, EventArgs e)
        {
            ////new a thread
            ThreadStart threadStart = HTMLToPDF;
            Thread thread = new Thread(threadStart);
            thread.SetApartmentState(ApartmentState.STA);
            thread.Start();
        }

        void HTMLToPDF()
        {
            PdfDocument doc = new PdfDocument();

            String url = "http://www.e-iceblue.com/";
            doc.LoadFromHTML(url, false, true, true);

            Response.ClearContent();
            Response.ClearHeaders();
            Response.BufferOutput = true;
            Response.ContentType = "application/pdf";

            using (MemoryStream pdfStream = new MemoryStream())
            {
                doc.SaveToStream(pdfStream);
                using (MemoryStream ms = new MemoryStream())
                {
                    //ms.WriteTo(Response.OutputStream);
                    Response.OutputStream.Write(pdfStream.ToArray(), 0, pdfStream.ToArray().Length);
                }
            }

            doc.SaveToHttpResponse("Test.pdf", Response, HttpReadType.Save);
            doc.Close();
        }
    }
}

I want to sent client an attachment. How to acheive it??(The above code i use the third component of Spire.PDF).

Thanks in advance.

Answer 1

You are starting new thread to process request, but your original thread likely continues execution and successfully terminates request before your new thread even gets to doing something with the response. You have to wait for completion of the new thread in the original thread (you may be able to creatively use asynchronous pages to not block original thread http://msdn.microsoft.com/en-us/magazine/cc163725.aspx).

Answer 2

I had a similar task. I had a dataset and I needed to return to the client excel file.

I solved with the AXD handler. Add to web config reference to AXD.

See example

<httpHandlers>
      <add verb="GET,POST" path="Export.axd" type="YourNameSpace.ExportHandler, YouDLL"/>
</httpHandlers>

See below the code

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using Spire;
using Spire.Xls;

namespace SD.Reval.Admin.Services
{
    public class ExportHandler   : IHttpHandler
    {
        virtual public bool IsReusable
        {
            get { return true; }
        }


        virtual  public void ProcessRequest(HttpContext context)
        {
            try
            {

                Workbook workbook = new Workbook();
                Worksheet worksheet;

                int counter = 0;
                string methodName = HttpContext.Current.Request.QueryString["methodName"];
                string fileName = HttpContext.Current.Request.QueryString["fileName"];
                string parameters = HttpContext.Current.Request.QueryString["params"];
                if (parameters == null)
                    parameters = HttpContext.Current.Request.Form["params"];

                int workSheetCount = workbook.Worksheets.Count;
                string tableName = string.Empty ;

                if (methodName.Length > 0 && fileName.Length > 0)
                {

                    DataSet dataSet = (DataSet)ServiceInterface.InternalGenericInvoke(methodName, parameters);

                    foreach (DataTable dt in dataSet.Tables)
                    {
                        if (dt.Columns.Count > 0)
                        {
                            tableName = dt.TableName ;

                            if (counter >= workSheetCount)
                                worksheet=workbook.Worksheets.Add(tableName);
                            else
                            {
                                worksheet = workbook.Worksheets[counter];
                                worksheet.Name = tableName;
                            }


                            worksheet.InsertDataTable(dt, true, 4, 1, -1, -1);
                            counter++;
                            worksheet.AllocatedRange.AutoFitColumns();
                            worksheet.AllocatedRange.AutoFitRows();
                            worksheet.Pictures.Add(1, 1, SD.Reval.Admin.Services.ResourceFile.logo_reval );

                            //Sets header style
                            CellStyle styleHeader = worksheet.Rows[0].Style;
                            styleHeader.Borders[BordersLineType.EdgeLeft].LineStyle = LineStyleType.Thin;
                            styleHeader.Borders[BordersLineType.EdgeRight].LineStyle = LineStyleType.Thin;
                            styleHeader.Borders[BordersLineType.EdgeTop].LineStyle = LineStyleType.Thin;
                            styleHeader.Borders[BordersLineType.EdgeBottom].LineStyle = LineStyleType.Thin;
                            styleHeader.VerticalAlignment = VerticalAlignType.Center;
                            styleHeader.KnownColor = ExcelColors.Green;
                            styleHeader.Font.KnownColor = ExcelColors.White;
                            styleHeader.Font.IsBold = true;
                        }

                    }
                    fileName = fileName + ".xls";

                    workbook.SaveToHttpResponse(fileName, context.Response);

                    context.Response.Buffer = true;
                    context.Response.ContentType = "application/x-msdownload";
                    context.Response.AddHeader("Content-Disposition", "attachment; filename=" + fileName  );
                }


            }
            catch (Exception  ex)
            {
                Log.WriteLog(ex);
                throw new ApplicationException("The epxport process failed", ex);
            }
            finally
            {

            }
        }

    }
}