Carregar e baixar arquivos é uma tecnologia que frequentemente precisamos usar no processo real de desenvolvimento do projeto. Aqui estão vários métodos comuns.
1. Como resolver o limite de tamanho de upload de arquivo
2. Salve no servidor como arquivo
3. Converta para fluxo de bytes binários e salve no banco de dados e método de download
4. Carregar recursos na Internet
Parte 1:
Primeiro, vamos falar sobre como resolver o problema do limite de tamanho de upload de arquivo no ASP.NET. Sabemos que, por padrão, o limite de tamanho de upload de arquivo do ASP.NET é de 2M. Em geral, podemos personalizá-lo alterando o WEB. Arquivo de configuração. O tamanho máximo do arquivo é o seguinte:
<httpRuntime execuçãoTimeout="300" maxRequestLength="40960" useFullyQualifiedRedirectUrl="false"/>Desta forma, o valor máximo do arquivo enviado passa a ser 4M, mas isso não nos permite expandir infinitamente o valor de MaxRequestLength, pois ASP. NET irá Depois que todos os arquivos forem carregados na memória, eles serão processados. A solução é usar o HttpWorkerRequest implícito e seus métodos GetPreloadedEntityBody e ReadEntityBody para ler dados em partes do canal criado pelo IIS para ASP.NET. O método de implementação é o seguinte:
IServiceProviderprovider=(IServiceProvider)HttpContext.Current;
HttpWorkerRequestwr=(HttpWorkerRequest)provider.GetService(typeof(HttpWorkerRequest));
byte[]bs=wr.GetPreloadedEntityBody();
.
if(!wr.IsEntireEntityBodyIsPreloaded())
{
int=1024;
byte[]bs2=novobyte[n];
enquanto(wr.ReadEntityBody(bs2,n)>0)
{
..
}
}Isso resolverá o problema de upload de arquivos grandes.
Parte 2:
A seguir apresentaremos como fazer upload de um arquivo do cliente para o servidor na forma de um arquivo e retornar algumas informações básicas sobre o arquivo enviado. Primeiro, definimos uma classe para armazenar as informações sobre o arquivo enviado (necessário ao retornar). .
classe pública FileUpLoad
{
FileUpLoad público()
{
}
/**//// <resumo>
/// Carregar nome do arquivo
/// </sumário>
string pública NomeArquivo
{
pegar
{
return NomeArquivo;
}
definir
{
nomeArquivo = valor;
}
}
string privada nome do arquivo;
/**//// <resumo>
/// Carregar caminho do arquivo
/// </sumário>
string pública FilePath
{
pegar
{
retornar caminho do arquivo;
}
definir
{
caminho do arquivo = valor;
}
}
caminho de arquivo de string privada;
/**//// <resumo>
/// Extensão do arquivo
/// </sumário>
string pública FileExtension
{
pegar
{
retornar extensão de arquivo;
}
definir
{
extensãoArquivo = valor;
}
}
string privada fileExtension;
}
Além disso, também podemos limitar o formato dos arquivos carregados no arquivo de configuração (App.Config):
<?xml version="1.0" encoding="gb2312" ?>
<Aplicativo>
<FileUpLoad>
<Formato>.jpg|.gif|.png|.bmp</Format>
</FileUpLoad>
</Aplicativo>
Desta forma podemos começar a escrever nosso método de upload de arquivos, da seguinte forma:
public FileUpLoad UpLoadFile(HtmlInputFile InputFile,string filePath,string myfileName,bool isRandom)
{
FileUpLoad fp = new FileUpLoad()
;
string salvarNome;
//
//Cria objeto de upload
//
HttpPostedFile postFile = InputFile.PostedFile;
fileName = System.IO.Path.GetFileName(postedFile.FileName);
fileExtension = System.IO.Path.GetExtension(fileName);
//
//Determina o formato do arquivo com base no tipo
//
AppConfig app = new AppConfig();
formato de string = app.GetPath("FileUpLoad/Format");
//
//Se o formato não corresponder, retorne
//
if(formato.IndexOf(fileExtension)==-1)
{
throw new ApplicationException("O formato dos dados enviados é ilegal");
}
//
//Gera um nome de arquivo aleatório com base na data e no número aleatório
//
if(meunomedoarquivo!=string.Empty)
{
nomeArquivo = meuNomeArquivo;
}
if(éAleatório)
{
Aleatório objRand = new Random();
System.DateTime data = DateTime.Now;
//Gera nome de arquivo aleatório
saveName = data.Ano.ToString() + data.Mês.ToString() + data.Day.ToString() + data.Hour.ToString() + data.Minute.ToString()
+ data.Second.ToString() + Convert.ToString(objRand.Next(99)*97 + 100);
nomeArquivo = salvarNome + extensãoArquivo;
}
string phyPath = HttpContext.Current.Request.MapPath(filePath);
//Determina se o caminho existe, caso contrário, crie o caminho
DirectoryInfo upDir = new DirectoryInfo(phyPath);
if(!upDir.Exists)
{
upDir.Create();
}
//
//salva o arquivo
//
tentar
{
postFile.SaveAs(phyPath + fileName);
fp.FilePath = filePath + fileName;
fp.FileExtension = arquivoExtension;
fp.NomeArquivo = nomeArquivo;
}
pegar
{
throw new ApplicationException("Falha no upload!");
}
//Retorna as informações do arquivo enviado
retornar fp;
}
Então podemos chamar esse método ao fazer upload de arquivos e salvar as informações do arquivo retornado no banco de dados. Quanto ao download, basta abrir o caminho diretamente e tudo ficará bem.
Parte Três:
Aqui falamos principalmente sobre como fazer upload e download de arquivos em formato binário. Primeiro, vamos falar sobre upload. O método é o seguinte:
byte público[] UpLoadFile(HtmlInputFile f_IFile)
{
//Obter acesso ao arquivo enviado especificado pelo cliente
HttpPostedFile upFile=f_IFile.PostedFile;
//Obtém o comprimento do arquivo enviado
int upFileLength=upFile.ContentLength;
//Obtém o tipo MIME do cliente do arquivo enviado
string contentType = upFile.ContentType;
byte[] FileArray=novo Byte[upFileLength];
Fluxo fileStream=upFile.InputStream;
fileStream.Read(FileArray,0,upFileLength);
Este método retorna o fluxo de bytes binários do arquivo enviado, para que possamos salvá-lo no banco de dados. Vamos falar sobre essa forma de download. Você pode pensar que fazer download dessa forma é criar uma nova página aspx, retirar o fluxo de bytes binários em seu evento Page_Load() e, na verdade, ler este método. não é aconselhável. Na aplicação real, pode haver um erro que não consegue abrir um determinado site. Geralmente uso o seguinte método:
Primeiro, adicione: ao Web.config:
<add verbo="*" path="openfile.aspx" type="RuixinOA.Web.BaseClass.OpenFile, RuixinOA.Web"/>
Isso significa que quando eu abrir a página openfile.aspx, o sistema executará automaticamente os métodos da classe RuixinOA.Web.BaseClass.OpenFile. A implementação específica é a seguinte:
usando o sistema;
usando System.Data;
usando System.Web;
usando System.IO;
usando Ruixin.WorkFlowDB;
usandoRXSuite.Base;
usandoRXSuite.Component;
o namespace
RuixinOA.BusinessFacade;
{
/**//// <resumo>
/// Descrição resumida do NetUFile.
/// </sumário>
classe pública OpenFile: IHttpHandler
{
public void ProcessRequest (contexto HttpContext)
{
//Obtém as informações do arquivo a ser baixado do banco de dados
RuixinOA.BusinessFacade.RX_OA_FileManager os = novo RX_OA_FileManager();
Dados 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]
;
context.Response.Clear();
context.Response.ContentType = dr["CContentType"].ToString();
context.Response.AddHeader("Disposição de conteúdo","anexo;nome do arquivo=" + HttpUtility.UrlEncode(dr["CTitle"].ToString()));
context.Response.BinaryWrite((Byte[])dr["CContent"]);
context.Response.Flush();
context.Response.End();
}
}
bool público IsReusable
{
obter {retornar verdadeiro;}
}
}
}
Após executar o método acima, o sistema solicitará que o usuário escolha abrir diretamente ou fazer download. É isso nesta parte.
Parte 4:
Esta parte fala principalmente sobre como fazer upload de um recurso da Internet para o servidor. Temos um artigo anterior que detalha como usá-lo, então não vou falar mais nada aqui.
Consulte: Converter páginas dinâmicas em fluxos de bytes binários
Parte 5: Resumo
Hoje apresento brevemente vários métodos de upload e download de arquivos, que são frequentemente usados no desenvolvimento de projetos reais. Espero que todos possam trocar suas experiências no desenvolvimento de projetos. Por favor, corrija-me se eu escrever mal, obrigado!
E-mail: [email protected]