Le téléchargement de fichiers est une technologie que nous devons souvent utiliser dans le processus de développement de projet. Voici plusieurs méthodes courantes. Le contenu principal de cet article comprend :
1. Comment résoudre la limite de taille de téléchargement de fichiers
2. Enregistrer sur le serveur sous forme de fichier
3. Convertir en flux d'octets binaires et enregistrer dans la base de données et la méthode de téléchargement
4. Téléchargez des ressources sur Internet
Partie 1 :
Tout d'abord, parlons de la façon de résoudre le problème de la taille limite de téléchargement de fichiers dans ASP.NET. Nous savons que par défaut, la taille limite de téléchargement de fichiers d'ASP.NET est de 2 Mo. En général, nous pouvons la personnaliser en modifiant le WEB. Fichier de configuration. La taille maximale du fichier est la suivante :
<httpRuntimeexecutionTimeout="300" maxRequestLength="40960" useFullyQualifiedRedirectUrl="false"/>De cette façon, la valeur maximale du fichier téléchargé devient 4M, mais cela ne nous permet pas d'étendre à l'infini la valeur de MaxRequestLength, car ASP. NET sera Une fois tous les fichiers chargés en mémoire, ils seront traités. La solution consiste à utiliser le HttpWorkerRequest implicite et à utiliser ses méthodes GetPreloadedEntityBody et ReadEntityBody pour lire les données en morceaux à partir du canal créé par IIS pour ASP.NET. La méthode de mise en œuvre est la suivante :
IServiceProviderprovider=(IServiceProvider)HttpContext.Current;
HttpWorkerRequestwr=(HttpWorkerRequest)provider.GetService(typeof(HttpWorkerRequest));
byte[]bs=wr.GetPreloadedEntityBody();
.
if(!wr.IsEntireEntityBodyIsPreloaded())
{
int=1024 ;
octet[]bs2=nouveloctet[n];
pendant que(wr.ReadEntityBody(bs2,n)>0)
{
..
}
}Cela résoudra le problème du téléchargement de fichiers volumineux.
Partie 2 :
Nous présenterons ensuite comment télécharger un fichier du client vers le serveur sous la forme d'un fichier et renvoyer quelques informations de base sur le fichier téléchargé. Tout d'abord, nous définissons une classe pour stocker les informations sur le fichier téléchargé (obligatoire lors du retour). .
classe publique FileUpLoad
{
public FileUpLoad()
{
}
/**//// <résumé>
/// Télécharger le nom du fichier
/// </summary>
chaîne publique NomFichier
{
obtenir
{
retourner le nom du fichier ;
}
ensemble
{
nomfichier = valeur ;
}
}
chaîne privée fileName ;
/**//// <résumé>
/// Chemin du fichier de téléchargement
/// </summary>
chaîne publique FilePath
{
obtenir
{
renvoyer le chemin du fichier ;
}
ensemble
{
chemin du fichier = valeur ;
}
}
chemin de fichier de chaîne privée ;
/**//// <résumé>
/// Extension de fichier
/// </summary>
chaîne publique Extension de fichier
{
obtenir
{
renvoyer l'extension de fichier ;
}
ensemble
{
fileExtension = valeur ;
}
}
extension de fichier de chaîne privée ;
}
De plus, nous pouvons également limiter le format des fichiers téléchargés dans le fichier de configuration (App.Config) :
<?xml version="1.0" encodage="gb2312" ?>
<Demande>
<ChargeFichier>
<Format>.jpg|.gif|.png|.bmp</Format>
</FileUpLoad>
</Application>
De cette façon, nous pouvons commencer à écrire notre méthode de téléchargement de fichiers, comme suit :
public FileUpLoad UpLoadFile(HtmlInputFile InputFile,string filePath,string myfileName,bool isRandom)
{
FileUpLoad fp = new FileUpLoad();
chaîne fileName,fileExtension;
chaîne saveName ;
//
//Créer un objet de téléchargement
//
HttpPostedFile postFile = InputFile.PostedFile;
fileName = System.IO.Path.GetFileName (postedFile.FileName);
fileExtension = System.IO.Path.GetExtension(fileName);
//
// Détermine le format de fichier en fonction du type
//
Application AppConfig = new AppConfig();
format de chaîne = app.GetPath("FileUpLoad/Format");
//
//Si le format ne correspond pas, renvoie
//
si(format.IndexOf(fileExtension)==-1)
{
throw new ApplicationException("Le format des données téléchargées est illégal");
}
//
// Génère un nom de fichier aléatoire basé sur la date et un nombre aléatoire
//
if(myfileName != string.Empty)
{
nomfichier = monnomfichier ;
}
si (est aléatoire)
{
ObjRand aléatoire = new Random();
System.DateTime date = DateTime.Now ;
// Génère un nom de fichier aléatoire
saveName = date.Year.ToString() + date.Month.ToString() + date.Day.ToString() + date.Hour.ToString() + date.Minute.ToString()
+ date.Second.ToString() + Convert.ToString(objRand.Next(99)*97 + 100);
nom de fichier = nom de sauvegarde + extension de fichier ;
}
chaîne phyPath = HttpContext.Current.Request.MapPath(filePath);
//Détermine si le chemin existe, sinon, crée le chemin
DirectoryInfo upDir = new DirectoryInfo(phyPath);
si(!upDir.Exists)
{
upDir.Create();
}
//
//sauvegarder le fichier
//
essayer
{
postedFile.SaveAs(phyPath + fileName);
fp.FilePath = filePath + fileName;
fp.FileExtension = fileExtension;
fp.FileName = fileName;
}
attraper
{
throw new ApplicationException("Échec du téléchargement!");
}
//Renvoie les informations du fichier téléchargé
retourner fp ;
}
Ensuite, nous pouvons appeler cette méthode lors du téléchargement de fichiers et enregistrer les informations du fichier renvoyées dans la base de données. Quant au téléchargement, ouvrez simplement le chemin directement et tout ira bien.
Troisième partie :
Ici, nous parlons principalement de la façon de télécharger et de télécharger des fichiers sous forme binaire. Parlons d’abord du téléchargement. La méthode est la suivante :
octet public[] UpLoadFile (HtmlInputFile f_IFile)
{
//Obtenir l'accès au fichier téléchargé spécifié par le client
HttpPostedFile upFile=f_IFile.PostedFile;
//Obtenir la longueur du fichier téléchargé
int upFileLength=upFile.ContentLength;
//Obtenir le type MIME client du fichier téléchargé
chaîne contentType = upFile.ContentType ;
octet[] FileArray=nouveau octet[upFileLength];
Stream fileStream=upFile.InputStream;
fileStream.Read(FileArray,0,upFileLength);
}Cette méthode renvoie le flux d'octets binaires du fichier téléchargé, afin que nous puissions l'enregistrer dans la base de données. Parlons de cette forme de téléchargement. Vous pensez peut-être que télécharger de cette manière consiste à créer une nouvelle page aspx, puis à supprimer le flux d'octets binaires dans son événement Page_Load(), puis à le lire. n'est pas conseillé. Dans l'application réelle, il peut y avoir une erreur qui ne peut pas ouvrir un certain site. J'utilise généralement la méthode suivante :
Tout d’abord, ajoutez : à Web.config :
<add verb="*" path="openfile.aspx" type="RuixinOA.Web.BaseClass.OpenFile, RuixinOA.Web"/>
Cela signifie que lorsque j'ouvre la page openfile.aspx, le système exécutera automatiquement les méthodes de la classe RuixinOA.Web.BaseClass.OpenFile. L'implémentation spécifique est la suivante :
utiliser le système ;
en utilisant System.Data ;
en utilisant System.Web ;
en utilisant System.IO ;
en utilisant Ruixin.WorkFlowDB ;
en utilisantRXSuite.Base ;
en utilisantRXSuite.Component ;
en utilisant RuixinOA.BusinessFacade ;
espace de noms RuixinOA.Web.BaseClass ;
{
/**//// <résumé>
/// Description sommaire de NetUFile.
/// </summary>
classe publique OpenFile : IHttpHandler
{
public void ProcessRequest (contexte HttpContext)
{
//Récupère les informations du fichier à télécharger depuis la base de données
RuixinOA.BusinessFacade.RX_OA_FileManager os = new RX_OA_FileManager();
EntityData data = os.GetFileDetail(id);
if(data != null && data.Tables["RX_OA_File"].Rows.Count > 0)
{
DataRow dr = (DataRow)data.Tables["RX_OA_File"].Rows[0];
contexte.Response.Buffer = true;
contexte.Response.Clear();
context.Response.ContentType = dr["CContentType"].ToString();
context.Response.AddHeader("Content-Disposition","attachment;filename=" + HttpUtility.UrlEncode(dr["CTitle"].ToString()));
context.Response.BinaryWrite((Byte[])dr["CContent"]);
contexte.Response.Flush();
contexte.Response.End();
}
}
public bool EstRéutilisable
{
obtenir { retourner vrai ;}
}
}
}
Après avoir exécuté la méthode ci-dessus, le système invitera l'utilisateur à choisir d'ouvrir directement ou de télécharger. C'est tout pour cette partie.
Partie 4 :
Cette partie explique principalement comment télécharger une ressource sur Internet sur le serveur. Nous avons un article précédent qui détaille comment l’utiliser, je n’en dirai donc pas plus ici.
Veuillez vous référer à : Convertir des pages dynamiques en flux d'octets binaires
Partie 5 : Résumé
Aujourd'hui, je présente brièvement plusieurs méthodes de téléchargement et de téléchargement de fichiers, qui sont souvent utilisées dans le développement de projets réels. J'espère que tout le monde pourra échanger son expérience dans le développement de projets. Corrigez-moi si j'écris mal, merci !
Courriel :[email protected]