Stream in Datei speichern

Question

Ich habe ein Fileupload-Steuerelement, mit dem Benutzer Bilder hochladen können, aber bevor sie Bilder hochladen kann Ich möchte Thomes Bilder Größe auf 640x480 Größe das Problem ist, ich kann nicht herausfinden, was als nächstes zu tun. Das ist was ich habe;

// CALL THE FUNCTION THAT WILL RESIZE THE IMAGE 
protected void btnUploadFile_Click(object sender, EventArgs e) 
{ 
    Stream imgStream = ir.ResizeFromStream(640, fupItemImage.PostedFile.InputStream); 

    // What to do next? 
} 

// THE FUNCTION THAT WILL RESIZE IMAGE THEN RETURN AS MEMORY STREAM 
public MemoryStream ResizeFromStream(int MaxSideSize, Stream Buffer) 
{ 
    int intNewWidth; 
    int intNewHeight; 
    System.Drawing.Image imgInput = System.Drawing.Image.FromStream(Buffer); 

    // GET IMAGE FORMAT 
    ImageFormat fmtImageFormat = imgInput.RawFormat; 

    // GET ORIGINAL WIDTH AND HEIGHT 
    int intOldWidth = imgInput.Width; 
    int intOldHeight = imgInput.Height; 

    // IS LANDSCAPE OR PORTRAIT ?? 
    int intMaxSide; 

    if (intOldWidth >= intOldHeight) 
    { 
     intMaxSide = intOldWidth; 
    } 
    else 
    { 
     intMaxSide = intOldHeight; 
    } 


    if (intMaxSide > MaxSideSize) 
    { 
     // SET NEW WIDTH AND HEIGHT 
     double dblCoef = MaxSideSize/(double)intMaxSide; 
     intNewWidth = Convert.ToInt32(dblCoef * intOldWidth); 
     intNewHeight = Convert.ToInt32(dblCoef * intOldHeight); 
    } 
    else 
    { 
     intNewWidth = intOldWidth; 
     intNewHeight = intOldHeight; 
    } 

    // CREATE NEW BITMAP 
    Bitmap bmpResized = new Bitmap(imgInput, intNewWidth, intNewHeight); 

    // SAVE BITMAP TO STREAM 
    MemoryStream imgMStream = new MemoryStream(); 
    bmpResized.Save(imgMStream, imgInput.RawFormat); 

    // RELEASE RESOURCES 
    imgInput.Dispose(); 
    bmpResized.Dispose(); 
    Buffer.Close(); 

    return imgMStream; 
} 

Danke

Answer 1

Vielleicht so etwas wie

int length = 256; 
int bytesRead = 0; 
Byte[] buffer = new Byte[length]; 
using (FileStream fs = new FileStream(filename, FileMode.Create)) 
{ 
    do 
    { 
    bytesRead = imgStream.Read(buffer, 0, length); 
    fs.Write(buffer, 0, bytesRead); 
    } 
    while (bytesRead == length); 
} 

Answer 2

in eine Datei Dumping wie etwas aussehen:

using (FileStream fsOut = new FileStream("my\\file\\path.img", FileMode.Create)) 
using (MemoryStream msImg = new MemoryStream(ir.ResizeFromStream(640 ...))) 
{ 
    byte[] imgData = msImg.ToArray(); 
    fsOut.Write(imgData, 0, imgData.Length); 
} 

Answer 3

Ich habe nur einen kurzen Blick, aber wenn Sie hat die image re-Größe bereits erfolgreich durchgeführt, dann müssen Sie nur die System.IO-Namespace-Dateiklasse verwenden, um das Memo zu speichern Übertragen Sie eine Datei in eine Datei, indem Sie die Bytes aus dem Speicher-Stream in das von Ihnen erstellte Dateiobjekt schreiben. Wenn Sie ein Codebeispiel benötigen, lassen Sie es mich wissen.

Answer 4

FileStream fs=new FileStream("filename",FileMode.Create); 
ir.ResizeFromStream(640, fupItemImage.PostedFile.InputStream).WriteTo(fs); 
fs.Close(); 

Answer 5

Wenn Sie nicht den Strom verwenden von ResizeFromStream zurück können Sie auch diese Methode ändern und die konvertierte Bitmap machen zurückzukehren. Verwenden Sie dann Bitmap.Save(<path>), um das Bild als Datei zu speichern.

Answer 6

1. Ihr aktueller Code wird Ressourcen verlieren, wenn Ausnahmen auftreten. Sie sollten die Aufrufe immer an .Dispose in einem finally oder catch-Block platzieren (abhängig davon, ob die Ressource immer entsorgt werden muss oder nur im Falle eines Fehlers beseitigt werden muss). versuchen Sie ... schließlich kann Dispose mit dem Schlüsselwort using kurz und bündig geschrieben werden - Sparen Sie sich zukünftige Kopfschmerzen und versuchen Sie, alle IDisposables in einen using oder try..catch Block zu legen.
2. Bei der Größenanpassung von Bildern mit Windows Forms wird standardmäßig ein minderwertiger Resampler verwendet. Dies führt im Allgemeinen zu einer schlecht aussehenden Ausgabe; Sie müssen den entsprechenden Interpolationsmodus festlegen (siehe unten für Code).
3. Beim Speichern von Bildern können Probleme mit Bildcodec-Einstellungen auftreten: Der standardmäßige JPEG-Encoder hat beispielsweise standardmäßig eine extrem niedrige Ausgabequalität. Auch dies müssen Sie manuell einstellen (siehe unten).
4. Schließlich ist das Speichern der Datei auf der Festplatte oder in der Datenbank wirklich der einfachste Teil von allem - anstatt einen Speicherstream zu speichern, nehmen Sie einfach einen Stream-Parameter. Dieser Parameter kann dann so konstruiert werden, dass er bei Bedarf in eine Datei oder eine Datenbank schreibt.

Ich verwende die folgende Funktion Bilder, um die Größe (dies wird das Seitenverhältnis ändern):

public static Bitmap Resize(Image oldImage, int newWidth, int newHeight) 
{ 
    Bitmap bitmap = null; 
    try 
    { 
     bitmap = new Bitmap(newWidth, newHeight); 
     using (Graphics g = Graphics.FromImage(bitmap)) 
     { 
      g.SmoothingMode = SmoothingMode.HighQuality; 
      g.PixelOffsetMode = PixelOffsetMode.HighQuality; 
      g.CompositingQuality = CompositingQuality.HighQuality; 
      g.InterpolationMode = InterpolationMode.HighQualityBicubic; 
      g.DrawImage(oldImage, new Rectangle(0, 0, newWidth, newHeight)); 
     } 
    } 
    catch 
    { 
     if (bitmap != null) bitmap.Dispose(); 
     throw; 
    } 
    return bitmap; 
} 

eine Datei als JPEG gespeichert könnte über zum Beispiel durchgeführt werden:

public static void SaveImageAsJpeg(Image image, Stream outputStream, int quality) 
{ 
    ImageCodecInfo jpgInfo = ImageCodecInfo.GetImageEncoders() 
     .Where(codecInfo => codecInfo.MimeType == "image/jpeg").First(); 
    using (EncoderParameters encParams = new EncoderParameters(1)) 
    { 
     encParams.Param[0] = new EncoderParameter(Encoder.Quality,(long)quality); 
     //quality should be in the range [0..100] 
     image.Save(outputStream, jpgInfo, encParams); 
    } 
} 

des Sie könnten über etwas auf der Linie von ...

using(var origImage=Image.FromStream(inputStream, true, true)) 
{ 
    //set newWidth, newHeight however you wish; determine outputFilePath 
    using(var newImage = Resize(origImage, newWidth, newHeight)) 
    using(var outputStream = File.Open(outputFilePath, FileMode.Create)) 
     SaveImageAsJpeg(newImage,outputStream, 90); 
}