Das Hochladen und Herunterladen von Dateien ist eine Technologie, die wir im eigentlichen Projektentwicklungsprozess häufig verwenden müssen. Hier sind einige gängige Methoden. Zu den Hauptinhalten dieses Artikels gehören:
1. So lösen Sie die Größenbeschränkung beim Hochladen von Dateien
2. Als Datei auf dem Server speichern
3. In einen Binärbyte-Stream konvertieren und in der Datenbank speichern und die Methode herunterladen
4. Hochladen von Ressourcen im Internet
Teil 1:
Lassen Sie uns zunächst darüber sprechen, wie Sie das Problem der Datei-Upload-Größenbeschränkung in ASP.NET lösen können. Wir wissen, dass die Datei-Upload-Größenbeschränkung von ASP.NET standardmäßig 2 MB beträgt. Im Allgemeinen können wir sie anpassen, indem wir das WEB ändern. Konfigurationsdatei. Die maximale Dateigröße beträgt:
<httpRuntime ExecutionTimeout="300" maxRequestLength="40960" useFullyQualifiedRedirectUrl="false"/>Auf diese Weise beträgt der Maximalwert der hochgeladenen Datei 4 MB. Dies ermöglicht uns jedoch nicht, den Wert von MaxRequestLength aufgrund von ASP unendlich zu erweitern. NET wird verarbeitet, nachdem alle Dateien in den Speicher geladen wurden. Die Lösung besteht darin, das implizite HttpWorkerRequest zu verwenden und seine Methoden GetPreloadedEntityBody und ReadEntityBody zu verwenden, um Daten in Blöcken aus der von IIS für ASP.NET erstellten Pipe zu lesen. Die Implementierungsmethode ist wie folgt:
IServiceProviderprovider=(IServiceProvider)HttpContext.Current;
HttpWorkerRequestwr=(HttpWorkerRequest)provider.GetService(typeof(HttpWorkerRequest));
byte[]bs=wr.GetPreloadedEntityBody();
.
if(!wr.IsEntireEntityBodyIsPreloaded())
{
intn=1024;
byte[]bs2=newbyte[n];
while(wr.ReadEntityBody(bs2,n)>0)
{
..
}
}Dadurch wird das Problem des Hochladens großer Dateien gelöst.
Teil 2:
Als nächstes stellen wir vor, wie man eine Datei vom Client auf den Server in Form einer Datei hochlädt und einige grundlegende Informationen über die hochgeladene Datei zurückgibt. Zuerst definieren wir eine Klasse zum Speichern der Informationen über die hochgeladene Datei (erforderlich bei der Rückgabe). .
öffentliche Klasse FileUpLoad
{
öffentliches FileUpLoad()
{
}
/**//// <Zusammenfassung>
/// Dateiname hochladen
/// </summary>
öffentliche Zeichenfolge Dateiname
{
erhalten
{
Dateiname zurückgeben;
}
Satz
{
Dateiname = Wert;
}
}
private Zeichenfolge fileName;
/**//// <summary>
/// Dateipfad hochladen
/// </summary>
öffentliche Zeichenfolge FilePath
{
erhalten
{
Dateipfad zurückgeben;
}
Satz
{
Dateipfad = Wert;
}
}
privater String-Dateipfad;
/**//// <Zusammenfassung>
/// Dateierweiterung
/// </summary>
öffentliche Zeichenfolge FileExtension
{
erhalten
{
return fileExtension;
}
Satz
{
fileExtension = Wert;
}
}
private Zeichenfolge fileExtension;
}
Darüber hinaus können wir auch das Format hochgeladener Dateien in der Konfigurationsdatei (App.Config) einschränken:
<?xml version="1.0"kodierung="gb2312" ?>
<Anwendung>
<FileUpLoad>
<Format>.jpg|.gif|.png|.bmp</Format>
</FileUpLoad>
</Anwendung>
Auf diese Weise können wir beginnen, unsere Methode zum Hochladen von Dateien wie folgt zu schreiben:
public FileUpLoad UpLoadFile(HtmlInputFile InputFile,string filePath,string myfileName,bool isRandom)
{
FileUpLoad fp = new FileUpLoad();
string fileName,fileExtension;
string saveName;
//
//Upload-Objekt erstellen
//
HttpPostedFilepostedFile = InputFile.PostedFile;
fileName = System.IO.Path.GetFileName(postedFile.FileName);
fileExtension = System.IO.Path.GetExtension(fileName);
//
//Dateiformat anhand des Typs bestimmen
//
AppConfig app = new AppConfig();
string format = app.GetPath("FileUpLoad/Format");
//
//Wenn das Format nicht übereinstimmt, kehren Sie zurück
//
if(format.IndexOf(fileExtension)==-1)
{
throw new ApplicationException("Das hochgeladene Datenformat ist illegal");
}
//
//Erzeuge einen zufälligen Dateinamen basierend auf Datum und Zufallszahl
//
if(myfileName != string.Empty)
{
fileName = myfileName;
}
if(isRandom)
{
Random objRand = new Random();
System.DateTime date = DateTime.Now;
//Zufälligen Dateinamen generieren
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);
fileName = saveName + fileExtension;
}
string phyPath = HttpContext.Current.Request.MapPath(filePath);
//Bestimmen Sie, ob der Pfad vorhanden ist. Wenn nicht, erstellen Sie den Pfad
DirectoryInfo upDir = new DirectoryInfo(phyPath);
if(!upDir.Exists)
{
upDir.Create();
}
//
//Datei speichern
//
versuchen
{
postedFile.SaveAs(phyPath + fileName);
fp.FilePath = filePath + fileName;
fp.FileExtension = fileExtension;
fp.FileName = fileName;
}
fangen
{
throw new ApplicationException("Upload fehlgeschlagen!");
}
//Die Informationen der hochgeladenen Datei zurückgeben
fp zurückgeben;
}
Dann können wir diese Methode beim Hochladen von Dateien aufrufen und die zurückgegebenen Dateiinformationen in der Datenbank speichern. Öffnen Sie zum Herunterladen einfach den Pfad und alles ist in Ordnung.
Teil drei:
Hier geht es hauptsächlich um das Hoch- und Herunterladen von Dateien in Binärform. Lassen Sie uns zunächst über das Hochladen sprechen. Die Methode ist wie folgt:
öffentliches Byte[] UpLoadFile(HtmlInputFile f_IFile)
{
//Zugriff auf die vom Client angegebene hochgeladene Datei erhalten
HttpPostedFile upFile=f_IFile.PostedFile;
//Ermitteln Sie die Länge der hochgeladenen Datei
int upFileLength=upFile.ContentLength;
//Den Client-MIME-Typ der hochgeladenen Datei abrufen
string contentType = upFile.ContentType;
byte[] FileArray=new Byte[upFileLength];
Stream fileStream=upFile.InputStream;
fileStream.Read(FileArray,0,upFileLength);
}Diese Methode gibt den binären Bytestrom der hochgeladenen Datei zurück, damit wir ihn in der Datenbank speichern können. Lassen Sie uns über diese Form des Herunterladens sprechen. Sie denken vielleicht, dass das Herunterladen auf diese Weise darin besteht, eine neue ASPX-Seite zu erstellen, dann den binären Byte-Stream in seinem Page_Load()-Ereignis herauszunehmen und ihn dann auszulesen. Tatsächlich ist dies diese Methode In der tatsächlichen Anwendung kann es zu einem Fehler kommen, der dazu führt, dass eine bestimmte Site nicht geöffnet werden kann. Ich verwende im Allgemeinen die folgende Methode:
Fügen Sie zunächst Folgendes zu Web.config hinzu:
<add verb="*" path="openfile.aspx" type="RuixinOA.Web.BaseClass.OpenFile, RuixinOA.Web"/>
Dies bedeutet, dass das System beim Öffnen der Seite openfile.aspx automatisch die Methoden in der Klasse RuixinOA.Web.BaseClass.OpenFile ausführt. Die spezifische Implementierung lautet wie folgt:
Verwenden des Systems;
Verwenden von System.Data;
mit System.Web;
mit System.IO;
mit Ruixin.WorkFlowDB;
usingRXSuite.Base;
usingRXSuite.Component;
unter Verwendung von RuixinOA.BusinessFacade;
Namespace RuixinOA.Web.BaseClass
{
/**//// <Zusammenfassung>
/// Zusammenfassende Beschreibung von NetUFile.
/// </summary>
öffentliche Klasse OpenFile: IHttpHandler
{
public void ProcessRequest(HttpContext context)
{
//Holen Sie sich die Dateiinformationen, die aus der Datenbank heruntergeladen werden sollen
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];
context.Response.Buffer = true;
context.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"]);
context.Response.Flush();
context.Response.End();
}
}
public bool IsReusable
{
get { return true;}
}
}
}
Nach der Ausführung der oben genannten Methode fordert das System den Benutzer auf, direkt zu öffnen oder herunterzuladen. Das war’s für diesen Teil.
Teil 4:
In diesem Teil geht es hauptsächlich darum, wie man eine Ressource im Internet auf den Server hochlädt. Wir haben einen früheren Artikel, der die Verwendung detailliert beschreibt, daher werde ich hier nicht mehr sagen.
Weitere Informationen finden Sie unter: Konvertieren dynamischer Seiten in binäre Byteströme,
Teil 5: Zusammenfassung
Heute stelle ich kurz einige Methoden zum Hochladen und Herunterladen von Dateien vor, die häufig in der tatsächlichen Projektentwicklung verwendet werden. Ich hoffe, dass jeder seine Erfahrungen in der Projektentwicklung austauschen kann. Bitte korrigieren Sie mich, wenn ich schlecht schreibe, danke!
E-Mail:[email protected]