La carga y descarga de archivos es una tecnología que a menudo necesitamos utilizar en el proceso de desarrollo del proyecto real. Aquí se presentan varios métodos comunes. El contenido principal de este artículo incluye:
1. Cómo solucionar el límite de tamaño de carga de archivos
2. Guardar en el servidor como archivo
3. Convierta a flujo de bytes binarios y guárdelo en la base de datos y método de descarga.
4. Cargar recursos en Internet
Parte 1:
Primero, hablemos sobre cómo resolver el problema del límite de tamaño de carga de archivos en ASP.NET. Sabemos que, de forma predeterminada, el límite de tamaño de carga de archivos de ASP.NET es 2 M. En general, podemos personalizarlo cambiando la WEB. Archivo de configuración. El tamaño máximo de archivo es el siguiente:
<httpRuntimeexecutionTimeout="300" maxRequestLength="40960" useFullyQualifiedRedirectUrl="false"/>De esta manera, el valor máximo del archivo cargado pasa a ser 4M, pero esto no nos permite expandir infinitamente el valor de MaxRequestLength, porque ASP. NET Una vez cargados todos los archivos en la memoria, se procesan. La solución es utilizar el HttpWorkerRequest implícito y utilizar sus métodos GetPreloadedEntityBody y ReadEntityBody para leer datos en fragmentos de la canalización creada por IIS para ASP.NET. El método de implementación es el siguiente:
IServiceProviderprovider=(IServiceProvider)HttpContext.Current;
HttpWorkerRequestwr=(HttpWorkerRequest)proveedor.GetService(tipode(HttpWorkerRequest));
byte[]bs=wr.GetPreloadedEntityBody();
.
si(!wr.IsEntireEntityBodyIsPreloaded())
{
int=1024;
byte[]bs2=nuevobyte[n];
mientras(wr.ReadEntityBody(bs2,n)>0)
{
..
}
}Esto solucionará el problema de cargar archivos grandes.
Parte 2:
A continuación, presentaremos cómo cargar un archivo desde el cliente al servidor en forma de archivo y devolver información básica sobre el archivo cargado. Primero, definimos una clase para almacenar la información sobre el archivo cargado (requerido al regresar). .
clase pública FileUpLoad
{
carga de archivos pública()
{
}
/**//// <resumen>
/// Subir nombre del archivo
/// </summary>
cadena pública nombre de archivo
{
conseguir
{
devolver nombre de archivo;
}
colocar
{
nombre de archivo = valor;
}
}
nombre de archivo de cadena privada
/**//// <resumen>
/// Subir ruta del archivo
/// </summary>
cadena pública FilePath
{
conseguir
{
devolver ruta de archivo;
}
colocar
{
ruta de archivo = valor;
}
}
ruta de archivo de cadena privada;
/**//// <resumen>
/// Extensión del archivo
/// </summary>
extensión de archivo de cadena pública
{
conseguir
{
devolver extensión de archivo;
}
colocar
{
extensión de archivo = valor;
}
}
extensión de archivo de cadena privada;
}
Además, también podemos limitar el formato de los archivos cargados en el archivo de configuración (App.Config):
<?xml versión="1.0" codificación="gb2312" ?>
<Aplicación>
<Cargar archivo>
<Formato>.jpg|.gif|.png|.bmp</Formato>
</FileUpLoad>
</Aplicación>
De esta manera podemos comenzar a escribir nuestro método de carga de archivos, de la siguiente manera:
público FileUpLoad UpLoadFile (HtmlInputFile Archivo de entrada, ruta de archivo de cadena, nombre de mi archivo de cadena, bool es aleatorio)
{
FileUpLoad fp = new FileUpLoad();
cadena nombre de archivo, extensión de archivo;
cadena guardarNombre;
//
//Crear objeto de carga
//
HttpPostedFile archivo publicado = InputFile.PostedFile
nombre de archivo = System.IO.Path.GetFileName(postedFile.FileName);
fileExtension = System.IO.Path.GetExtension (nombre de archivo);
//
//Determinar el formato de archivo según el tipo
//
Aplicación AppConfig = nueva AppConfig();
formato de cadena = app.GetPath("FileUpLoad/Format");
//
//Si el formato no coincide, regresa
//
if(formato.IndexOf(fileExtension)==-1)
{
throw new ApplicationException ("El formato de datos cargados es ilegal");
}
//
//Generar un nombre de archivo aleatorio basado en la fecha y el número aleatorio
//
if(minombrearchivo!= cadena.Vacío)
{
nombredearchivo = minombredearchivo;
}
si (es aleatorio)
{
ObjRand aleatorio = nuevo Aleatorio();
System.DateTime fecha = DateTime.Now;
//Generar nombre de archivo aleatorio
saveName = fecha.Año.ToString() + fecha.Mes.ToString() + fecha.Día.ToString() + fecha.Hora.ToString() + fecha.Minuto.ToString()
+ fecha.Segundo.ToString() + Convert.ToString(objRand.Next(99)*97 + 100);
nombre de archivo = guardar nombre + extensión de archivo;
}
cadena phyPath = HttpContext.Current.Request.MapPath(filePath);
//Determinar si la ruta existe, si no, crear la ruta
DirectoryInfo upDir = new DirectoryInfo(phyPath);
si(!upDir.Exists)
{
upDir.Create();
}
//
// guardar archivo
//
intentar
{
publicadoFile.SaveAs(phyPath + fileName);
fp.FilePath = filePath + fileName;
fp.FileExtension = extensión de archivo;
fp.FileName = nombre de archivo;
}
atrapar
{
throw new ApplicationException ("¡Error en la carga!");
}
//Devuelve la información del archivo subido
volver fp;
}
Luego podemos llamar a este método al cargar archivos y guardar la información del archivo devuelto en la base de datos. En cuanto a la descarga, simplemente abra la ruta directamente y estará bien.
Tercera parte:
Aquí hablamos principalmente de cómo cargar y descargar archivos en formato binario. Primero, hablemos de cargar. El método es el siguiente:
byte público[] UpLoadFile(HtmlInputFile f_IFile)
{
//Obtener acceso al archivo cargado especificado por el cliente
HttpPostedFile upFile=f_IFile.PostedFile;
//Obtener la longitud del archivo cargado
int upFileLength=upFile.ContentLength;
//Obtener el tipo MIME del cliente del archivo cargado
cadena contentType = upFile.ContentType;
byte[] FileArray=nuevo Byte[upFileLength];
Transmitir fileStream=upFile.InputStream;
fileStream.Read(FileArray,0,upFileLength);
}Este método devuelve el flujo de bytes binarios del archivo cargado, para que podamos guardarlo en la base de datos. Hablemos de esta forma de descarga. Puede pensar que descargar de esta manera es crear una nueva página aspx, luego extraer el flujo de bytes binarios en su evento Page_Load () y luego leerlo en voz alta. No es recomendable. En la aplicación real, puede haber un error que no puede abrir un sitio determinado. Generalmente uso el siguiente método:
Primero, agregue: a Web.config:
<añadir verbo="*" ruta="openfile.aspx" tipo="RuixinOA.Web.BaseClass.OpenFile, RuixinOA.Web"/>
Esto significa que cuando abro la página openfile.aspx, el sistema ejecutará automáticamente los métodos en la clase RuixinOA.Web.BaseClass.OpenFile. La implementación específica es la siguiente:
usando Sistema;
usando System.Data;
usando System.Web;
usando System.IO;
usando Ruixin.WorkFlowDB;
usandoRXSuite.Base;
usandoRXSuite.Component;
usando RuixinOA.BusinessFacade
espacio de nombres RuixinOA.Web.BaseClass;
{
/**//// <resumen>
/// Descripción resumida de NetUFile.
/// </summary>
clase pública OpenFile: IHttpHandler
{
Solicitud de proceso pública vacía (contexto HttpContext)
{
//Obtener la información del archivo a descargar de la base de datos
RuixinOA.BusinessFacade.RX_OA_FileManager sistema operativo = nuevo RX_OA_FileManager();
Datos de EntityData = os.GetFileDetail(id);
if(data!= null && data.Tables["RX_OA_File"].Rows.Count > 0)
{
DataRow dr = (DataRow)data.Tables["RX_OA_File"].Rows[0]
;
contexto.Respuesta.Clear();
contexto.Response.ContentType = dr["CContentType"].ToString();
context.Response.AddHeader("Content-Disposition","attachment;filename=" + HttpUtility.UrlEncode(dr["CTitle"].ToString()));
contexto.Response.BinaryWrite((Byte[])dr["CContent"]);
contexto.Response.Flush();
contexto.Respuesta.End();
}
}
bool público EsReutilizable
{
obtener {devolver verdadero;}
}
}
}
Después de ejecutar el método anterior, el sistema le pedirá al usuario que elija abrir directamente o descargar. Eso es todo por esta parte.
Parte 4:
esta parte habla principalmente sobre cómo cargar un recurso de Internet en el servidor. Tenemos un artículo anterior que detalla cómo usarlo, así que no diré más aquí.
Consulte: Convierta páginas dinámicas en flujos de bytes binarios,
Parte 5: Resumen
Hoy presento brevemente varios métodos de carga y descarga de archivos, que a menudo se utilizan en el desarrollo de proyectos reales. Espero que todos puedan intercambiar su experiencia en el desarrollo de proyectos. Corrígeme si escribo mal, ¡gracias!
Correo electrónico: [email protected]