C# HttpResponse.BinaryWrite方法代码示例

        public void GetImage(HttpResponse reponse, int id)
        {
            using (SqlConnection connection = new SqlConnection("Data Source=DESKTOP-5A9RHHB;Initial Catalog=EcommerceSimplifie; Integrated Security=True"))
            {
                //try
                //{
                SqlCommand command = new SqlCommand("select Picture.PictureBinary, Picture.MimeType from Picture inner join Product_Picture_Mapping on Picture.Id = Product_Picture_Mapping.PictureId where ProductId = @id and DisplayOrder = 1;");
                command.Connection = connection;
                command.Parameters.Add(new SqlParameter("@id", id));

                connection.Open();

                SqlDataReader reader = command.ExecuteReader();

                while (reader.Read())
                {

                    //type de l'image
                    string typeMime = reader.GetString(1);
                    reponse.ContentType = (string.IsNullOrEmpty(typeMime)) ? "image/jpeg" : typeMime;

                    //mise en cache
                    reponse.Cache.SetCacheability(HttpCacheability.Public);

                    int indexDepart = 0;
                    int tailleBuffer = 1024;
                    long nombreOctets = 0;
                    Byte[] flux = new Byte[1024];

                    nombreOctets = reader.GetBytes(0, indexDepart, flux, 0, tailleBuffer);

                    while (nombreOctets == tailleBuffer)
                    {
                        reponse.BinaryWrite(flux);
                        reponse.Flush();
                        indexDepart += tailleBuffer;
                        nombreOctets = reader.GetBytes(0, indexDepart, flux, 0, tailleBuffer);
                    }
                    if (nombreOctets > 0)
                    {
                        reponse.BinaryWrite(flux);
                        reponse.Flush();
                    }
                    reponse.End();

                }
                //catch(Exception)
                //{
                //    throw new Exception("Pas d'image disponible.");
                //}
                //}
            }
        }

        /// <summary>
        /// Datatable数据填充如excel
        /// </summary>
        /// <param name="filename">excel文件名</param>
        /// <param name="dt"> 数据源</param>
        /// <param name="Response"> response响应</param>
        ///  <param name="headerStr"> 表头标题</param>
        public static void DataTableToExcel(string filename, DataTable dt, string sheetname, HttpResponse Response, string headerStr)
        {
            MemoryStream ms = StreamData(dt, sheetname, headerStr) as MemoryStream; //as MemoryStream  as用作转换,此处可以省略
            try
            {

                Response.Clear();
                Response.ContentType = "application/vnd.ms-excel";
                Response.ContentEncoding = Encoding.UTF8;
                Response.AddHeader("content-disposition", "attachment;filename=" + HttpUtility.UrlEncode(filename + ".xls"));
                Response.AddHeader("content-length", ms.Length.ToString());
                Byte[] data = ms.ToArray(); //文件写入采用二进制流的方式。所以此处要转换为字节数组
                Response.BinaryWrite(data);
            }
            catch
            {
                Response.Clear();
                Response.ClearHeaders();
                Response.Write("<script language=javascript>alert( '导出Excel错误'); </script>");
            }
            Response.Flush();
            Response.Close();
            Response.End();
            ms = null;
        }

 public void Process(HttpResponse response)
 {
     response.AppendHeader("Last-Modified", serverFingerprint.LastModifiedTime.ToString("r"));
     response.AppendHeader("ETag", serverFingerprint.ETag);
     response.AppendHeader("Cache-Control", "private, max-age=0");
     response.BinaryWrite(content);
 }

 public static bool DownFile(HttpRequest _Request, HttpResponse _Response, string _fileName, string _fullPath, long _speed)
 {
     try
     {
         FileStream input = new FileStream(_fullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
         BinaryReader reader = new BinaryReader(input);
         try
         {
             _Response.AddHeader("Accept-Ranges", "bytes");
             _Response.Buffer = false;
             long length = input.Length;
             long num2 = 0L;
             int count = 0x2800;
             double d = ((long) (0x3e8 * count)) / _speed;
             int millisecondsTimeout = ((int) Math.Floor(d)) + 1;
             if (_Request.Headers["Range"] != null)
             {
                 _Response.StatusCode = 0xce;
                 num2 = Convert.ToInt64(_Request.Headers["Range"].Split(new char[] { '=', '-' })[1]);
             }
             _Response.AddHeader("Content-Length", (length - num2).ToString());
             if (num2 != 0L)
             {
                 _Response.AddHeader("Content-Range", string.Format(" bytes {0}-{1}/{2}", num2, length - 1L, length));
             }
             _Response.AddHeader("Connection", "Keep-Alive");
             _Response.ContentType = "application/octet-stream";
             _Response.AddHeader("Content-Disposition", "attachment;filename=" + HttpUtility.UrlEncode(_fileName, Encoding.UTF8));
             reader.BaseStream.Seek(num2, SeekOrigin.Begin);
             double num6 = (length - num2) / ((long) count);
             int num7 = ((int) Math.Floor(num6)) + 1;
             for (int i = 0; i < num7; i++)
             {
                 if (_Response.IsClientConnected)
                 {
                     _Response.BinaryWrite(reader.ReadBytes(count));
                     Thread.Sleep(millisecondsTimeout);
                 }
                 else
                 {
                     i = num7;
                 }
             }
         }
         catch
         {
             return false;
         }
         finally
         {
             reader.Close();
             input.Close();
         }
     }
     catch
     {
         return false;
     }
     return true;
 }

        //defaultfile is under userpath
        public static void GetImageFromFile(string filename,string defaultfile,HttpResponse response)
        {
            if (!File.Exists(filename))
            {
                string userdatapath = Functions.GetAppConfigString("UserDataPath", "");
                filename = userdatapath + "\\"+defaultfile;
            }

            System.IO.FileStream fs = null;
            System.IO.MemoryStream ms = null;
            try
            {

                fs = new System.IO.FileStream(filename, System.IO.FileMode.Open, System.IO.FileAccess.Read);
                byte[] buffer = new byte[fs.Length];
                fs.Read(buffer, 0, buffer.Length);
                fs.Close();

                ms = new System.IO.MemoryStream(buffer);

                response.ClearContent();
                response.BinaryWrite(ms.ToArray());
                ms.Close();

            }
            finally
            {
                fs.Dispose();
                ms.Dispose();

            }
        }

        /// <summary>
        /// Writes the result directly into the response stream, e.g. for a classic ASP.NET response
        /// </summary>
        /// <param name="response">A standard HttpResponse object</param>
        /// <param name="result">An IBackloadResult object</param>
        public static void Write(HttpResponse response, IBackloadResult result)
        {

            response.StatusCode = (int)result.HttpStatusCode;
            if ((int)result.HttpStatusCode < 300)
            {

                // Write result to the response (Json or file data, default: Json response)
                if (result.RequestType == RequestType.Default)
                {
                    // Json response (We use the systems JavaScriptSerializer, you can also use Newtonsoft.Json)
                    IFileStatusResult status = (IFileStatusResult)result;
                    var serializer = new System.Web.Script.Serialization.JavaScriptSerializer();

                    if ((status.ClientStatus != null) && (result.Exception == null))
                        response.Write(serializer.Serialize(status.ClientStatus));
                }
                else if ((result.RequestType == RequestType.File) || (result.RequestType == RequestType.Thumbnail))
                {
                    // file data (byte array) response
                    IFileDataResult data = (IFileDataResult)result;

                    if ((data.FileData != null) && (result.Exception == null))
                        response.BinaryWrite(data.FileData);
                }
            }
        }

 /// <summary>
 /// Sends the file to the response with content-length header
 /// Works with all types of files, not image specific
 /// </summary>
 /// <param name="response"></param>
 /// <param name="file"></param>
 /// <param name="mimetype"></param>
 private static void SendToResponse(HttpResponse response, byte[] fileContent, DateTime lastWriteTime, string mimetype)
 {
   response.ClearHeaders();
   setCacheHeaders(response);
   
   response.Cache.SetLastModified(lastWriteTime); // to avoid rounding problems with header (no millisecs there)
   response.ContentType = mimetype;      
   response.AppendHeader("Content-Length", fileContent.Length.ToString());
   response.BinaryWrite(fileContent);
   response.End();
 }

        public static bool ResponseFile(HttpRequest request, HttpResponse response, string fileName, string fullPath, long speed, string pageUrl)
        {
            FileStream myFile = new FileStream(fullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(myFile);
            try
            {
                response.AddHeader("Accept-Ranges", "bytes");
                response.Buffer = false;
                long fileLength = myFile.Length;
                long startBytes = 0;

                const int pack = 10240;
                int sleep = (int)Math.Floor((double)(1000 * pack / speed)) + 1;
                if (request.Headers["Range"] != null)
                {
                    response.StatusCode = 206;
                    string[] range = request.Headers["Range"].Split(new[] { '=', '-' });
                    startBytes = Convert.ToInt64(range[1]);
                }
                response.AddHeader("Content-Length", (fileLength - startBytes).ToString());
                if (startBytes != 0)
                {
                    response.AddHeader("Content-Range", string.Format(" bytes {0}-{1}/{2}", startBytes, fileLength - 1, fileLength));
                }
                response.AddHeader("Connection", "Keep-Alive");
                response.ContentType = "application/octet-stream";
                response.AddHeader("Content-Disposition", "attachment;filename=" + HttpUtility.UrlEncode(fileName, Encoding.UTF8));

                br.BaseStream.Seek(startBytes, SeekOrigin.Begin);
                int maxCount = (int)Math.Floor((double)((fileLength - startBytes) / pack)) + 1;

                for (int i = 0; i < maxCount; i++)
                {
                    if (response.IsClientConnected)
                    {
                        response.BinaryWrite(br.ReadBytes(pack));
                        Thread.Sleep(sleep);
                    }
                    else
                    {
                        i = maxCount;
                    }
                }
            }
            finally
            {
                br.Close();
                myFile.Close();
            }

            return true;
        }

        public static void ToExcel(HttpResponse Response,DataTable dt , string fileName)
        {
            Response.ContentType = "application/csv";
            Response.Charset = "";
            Response.AddHeader("Content-Disposition", "attachment;filename=" + fileName);
            Response.ContentEncoding = Encoding.Unicode;
            Response.BinaryWrite(Encoding.Unicode.GetPreamble());

            try
            {
                StringBuilder sb = new StringBuilder();

                //Add Header
                for (int count = 0; count < dt.Columns.Count - 1; count++)
                {
                    if (dt.Columns[count].ColumnName != null)
                        sb.Append(dt.Columns[count].ColumnName);
                    sb.Append("\t");
                }
                Response.Write(sb.ToString() + "\n");
                Response.Flush();

                //Append Data
                int index = 0;
                while (dt.Rows.Count >= index + 1)
                {
                    sb = new StringBuilder();

                    for (int col = 0; col < dt.Columns.Count -1; col++)
                    {
                        if (dt.Rows[index][col] != null)
                            //sb.Append(dt.Rows[index][col].ToString().Replace(",", " "));
                            sb.Append(dt.Rows[index][col].ToString());
                        sb.Append("\t");
                    }

                    Response.Write(sb.ToString() + "\n");
                    Response.Flush();
                    index = index + 1;
                }

            }
            catch (Exception ex)
            {
                Response.Write(ex.Message);
            }

            dt.Dispose();
            Response.End();
        }

        public static void RackHandleRequest(HttpRequest request, HttpResponse response)
        {
            MyRackImage.BasePath = "Rack.Net.Tests/";

            IResponse call = rackApp.Call(ConvertToDicationary(request.Params));
            TransferHeader(response, call.Headers);
            if (call.Body.IsString())
            {
                response.Write(call.Body.ToString());
            }
            else
            {
                response.BinaryWrite(call.Body.ToBytes());
            }
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="httpResponse"></param>
 /// <param name="body"></param>
 protected void ProcessResponse(HttpResponse httpResponse, ResponseBody body)
 {
     try
     {
         SetResponseHead(httpResponse);
         var buffer = ResponseFormater.Serialize(body);
         httpResponse.BinaryWrite(buffer);
     }
     catch (Exception error)
     {
         TraceLog.WriteError("Response handle error:{0}", error);
         httpResponse.StatusCode = 500;
         httpResponse.StatusDescription = "Response error.";
     }
 }

        internal static void GenerateCsvResponse(HttpResponse response, string formName, string data)
        {
            Assert.ArgumentNotNull(response, "response");
            Assert.ArgumentNotNullOrEmpty(formName, "formName");
            Assert.ArgumentNotNullOrEmpty(data, "data");

            response.Clear();
            response.ContentType = Constants.Response.ContentType.Csv;
            response.AddHeader(Constants.Response.Header.ContentDisposition.Name,
                string.Format(Constants.Response.Header.ContentDisposition.AttachmentFilenameFormat,
                    GenerateFileNameService.GenerateFileName(formName)));
            response.Charset = Constants.Response.Charset.Utf8;
            response.BinaryWrite(Encoding.UTF8.GetPreamble());
            response.Write(data);
            response.End();
        }

 /// <summary>
 /// 保存报表文件为文件
 /// </summary>
 /// <param name="rpvObject">Reportview控件实例</param>
 /// <param name="rptType">打印的文件类型</param>
 /// <param name="filePath">文件存放路径</param>
 /// <param name="fileName">文件名</param>
 public static void Dowload(HttpResponse response, string filePath, string fileName, string extension)
 {
     if (response == null || string.IsNullOrEmpty(fileName) || string.IsNullOrEmpty(filePath) || string.IsNullOrEmpty(extension)) return;
     FileStream stream = new FileStream(filePath + fileName + "." + extension, FileMode.Open);
     byte[] bytes = new byte[stream.Length];
     stream.Read(bytes, 0, bytes.Length);
     // 设置当前流的位置为流的开始
     stream.Seek(0, SeekOrigin.Begin);
     stream.Close();
     //Download
     response.Buffer = true;
     response.Clear();
     response.ContentType = "application/" + extension;
     response.AddHeader("content-disposition", "attachment; filename=" + fileName + "." + extension);
     response.BinaryWrite(bytes);
     response.Flush();
     response.End();
 }

        public void imprimirReciboPDF(int numRecibo, HttpResponse Response)
        {
            try
            {
                DataSet dsRec = new DataSet("DataSetRec");
                DataTable dt = new DataTable("DataTableRec");
                FacturasRN ds = new FacturasRN();
                dsRec.Tables.Add(dt);

                ds.getRecibos(ref dt, numRecibo);
                ReportDataSource rds = new ReportDataSource();
                rds.Name = "DataSetRec_DataTableRec";
                rds.Value = dsRec.Tables[0];
                ReportViewer ReportViewer1 = new ReportViewer();
                ReportViewer1.LocalReport.DataSources.Clear();
                ReportViewer1.LocalReport.DataSources.Add(rds);
                ReportViewer1.LocalReport.ReportPath = "F:/EBuy/EbuyPlaceNet/FacturacionEbuy/Reportes/Recibo/Recibo_rpt.rdlc";
                //Dim p As New ReportParameter("TITULO", "DETALLE DEL LOTE " & Request.QueryString("id_lote") & " DE LA OBRA " & Request.QueryString("obra"))
                //ReportViewer1.LocalReport.SetParameters(New ReportParameter() {p})
                ReportViewer1.LocalReport.Refresh();
                string reportType = "PDF";
                string mimeType = "";
                string encoding = "";
                string fileNameExtension = "";

                string deviceInfo = "" + " PDF" + " 8.5in" + " 11in" + " 0.5in" + " 1in" + " 1in" + " 0.5in" + "";

                Warning[] Warnings = null;
                string[] streams = null;
                Byte[] renderedBytes;

                renderedBytes = ReportViewer1.LocalReport.Render(reportType, null, out mimeType, out encoding, out fileNameExtension, out streams, out Warnings);

                Response.Clear();
                Response.ContentType = mimeType;
                Response.AddHeader("content-disposition", "attachment; filename=Recibo." + fileNameExtension);
                Response.BinaryWrite(renderedBytes);
                Response.End();
            }
            catch(Exception ex)
            {

            }
        }

 public static void WriteResponse(HttpResponse response, byte[] filearray, string type)
 {
     response.ClearContent();
     response.Buffer = true;
     response.Cache.SetCacheability(HttpCacheability.Private);
     response.ContentType = "application/pdf";
     ContentDisposition contentDisposition = new ContentDisposition();
     contentDisposition.FileName = "SaldoDotacao.pdf";
     contentDisposition.DispositionType = type;
     response.AddHeader("Content-Disposition", contentDisposition.ToString());
     response.BinaryWrite(filearray);
     HttpContext.Current.ApplicationInstance.CompleteRequest();
     try
     {
         response.End();
     }
     catch (System.Threading.ThreadAbortException)
     {
     }
 }