निर्धारित करें यदि अपलोड की गई फ़ाइल छवि (किसी भी प्रारूप) MVC

Question

पर तो मैं देखने के लिए इस कोड का उपयोग कर रहा है:

<form action="" method="post" enctype="multipart/form-data"> 

    <label for="file">Filename:</label> 
    <input type="file" name="file" id="file" /> 

    <input type="submit" /> 
</form> 

यह मॉडल के लिए: जब तक कि उपयोगकर्ता एक जोड़ने

[HttpPost] 
public ActionResult Index(HttpPostedFileBase file) { 

    if (file.ContentLength > 0) { 
    var fileName = Path.GetFileName(file.FileName); 
    var path = Path.Combine(Server.MapPath("~/App_Data/uploads"), fileName); 
    file.SaveAs(path); 
    } 

    return RedirectToAction("Index"); 
} 

बढ़िया काम करता है फ़ाइल जो एक छवि नहीं है। मैं अपलोड की गई फाइल को कैसे आश्वस्त कर सकता हूं एक छवि है। धन्यवाद

Answer 1

मामले यह कर सकते हैं में किसी को भी मदद करता है, यहाँ यह है कि अगर किसी दिए गए अपलोड की गई फ़ाइल एक छवि है की जाँच करता है HttpPostedFileBase के लिए एक स्थिर विधि है:

public static class HttpPostedFileBaseExtensions 
{ 
    public const int ImageMinimumBytes = 512; 

    public static bool IsImage(this HttpPostedFileBase postedFile) 
    { 
     //------------------------------------------- 
     // Check the image mime types 
     //------------------------------------------- 
     if (postedFile.ContentType.ToLower() != "image/jpg" && 
        postedFile.ContentType.ToLower() != "image/jpeg" && 
        postedFile.ContentType.ToLower() != "image/pjpeg" && 
        postedFile.ContentType.ToLower() != "image/gif" && 
        postedFile.ContentType.ToLower() != "image/x-png" && 
        postedFile.ContentType.ToLower() != "image/png") 
     { 
      return false; 
     } 

     //------------------------------------------- 
     // Check the image extension 
     //------------------------------------------- 
     if (Path.GetExtension(postedFile.FileName).ToLower() != ".jpg" 
      && Path.GetExtension(postedFile.FileName).ToLower() != ".png" 
      && Path.GetExtension(postedFile.FileName).ToLower() != ".gif" 
      && Path.GetExtension(postedFile.FileName).ToLower() != ".jpeg") 
     { 
      return false; 
     } 

     //------------------------------------------- 
     // Attempt to read the file and check the first bytes 
     //------------------------------------------- 
     try 
     { 
      if (!postedFile.InputStream.CanRead) 
      { 
       return false; 
      } 

      if (postedFile.ContentLength < ImageMinimumBytes) 
      { 
       return false; 
      } 

      byte[] buffer = new byte[512]; 
      postedFile.InputStream.Read(buffer, 0, 512); 
      string content = System.Text.Encoding.UTF8.GetString(buffer); 
      if (Regex.IsMatch(content, @"<script|<html|<head|<title|<body|<pre|<table|<a\s+href|<img|<plaintext|<cross\-domain\-policy", 
       RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Multiline)) 
      { 
       return false; 
      } 
     } 
     catch (Exception) 
     { 
      return false; 
     } 

     //------------------------------------------- 
     // Try to instantiate new Bitmap, if .NET will throw exception 
     // we can assume that it's not a valid image 
     //------------------------------------------- 

     try 
     { 
      using (var bitmap = new System.Drawing.Bitmap(postedFile.InputStream)) 
      { 
      } 
     } 
     catch (Exception) 
     { 
      return false; 
     } 
     finally 
     { 
      postedFile.InputStream.Position = 0; 
     } 

     return true; 
    } 
} 

संपादित करें 2017/02/10: एक सुझाव संपादित के अनुसार, जोड़ा धारा को रीसेट करने के लिए अंत में एक बयान, ताकि हम इसे बाद में उपयोग कर सकें। स्थिर सहायक कक्षा में

Answer 2

हाथ में संकलक है नहीं, लेकिन कुछ इस तरह करना चाहिए:

try 
{ 
    var bitmap = Bitmap.FromStream(file.InputStream); 
    // valid image stream 
} 
catch 
{ 
    // not an image 
} 

Answer 3

पहले कदम के रूप, आप ContentType संपत्ति के खिलाफ स्वीकार्य MIME प्रकार के चारों ओर एक सफेद सूची होना चाहिए।

Answer 4

उपयोग:

public static bool IsImage(HttpPostedFileBase postedFile) 
    { 
     try { 
       using (var bitmap = new System.Drawing.Bitmap(postedFile.InputStream)) 
        {       
          return !bitmap.Size.IsEmpty; 
        } 
       } 
       catch (Exception) 
       { 
        return false; 
       } 
      } 
    } 

ASP.NET MVC viewmodel में उपयोग:

public class UploadFileViewModel 
    { 
     public HttpPostedFileBase postedFile { get; set; } 

     public bool IsImage() 
     { 
      try { 
        using (var bitmap = new System.Drawing.Bitmap(this.postedFile.InputStream)) 
         {       
           return !bitmap.Size.IsEmpty; 
         } 
        } 
        catch (Exception) 
        { 
         return false; 
        } 
       } 
     } 
    } 

यह उदाहरण देखने के लिए कि क्या छवि एक वास्तविक छवि है की जाँच करता है, और आप संशोधित कर सकते हैं और इसे परिवर्तित करें

यह स्मृति को छः लीटर वी 8 के उदाहरण के रूप में खाता है, इसलिए इसका उपयोग तब किया जाना चाहिए जब आप वास्तव में यह जानना चाहते हैं कि यह छवि क्या है।

Answer 5

सर्वर साइड में

सामग्री प्रकार के साथ तुलना करें अगर आपके लिए आवश्यक अपलोड प्रारूप के साथ अपने मिलान तो आगे बढ़ना या फिर त्रुटि संदेश

Answer 6

लौट किसी को भी है कि इस में चलाता है।

सामग्री प्रकार/छवि के प्रकार की जांच करने के लिए आप file.ContentType.Contains("image") का भी उपयोग कर सकते हैं।

if(file.ContentLength > 0 && file.ContentType.Contains("image")) 
{ 
    //valid image 
} 
else 
{ 
    //not a valid image 
} 

अगर यह सबसे अच्छा अभ्यास है, लेकिन यह मेरे लिए काम करता सुनिश्चित नहीं हैं।

और अधिक क्लीनर रास्ते में

Answer 7

कार्यान्वयन,

public static class FileExtensions 
{ 
    private static readonly IDictionary<string, string> ImageMimeDictionary = new Dictionary<string, string> 
    { 
     { ".bmp", "image/bmp" }, 
     { ".dib", "image/bmp" }, 
     { ".gif", "image/gif" }, 
     { ".svg", "image/svg+xml" }, 
     { ".jpe", "image/jpeg" }, 
     { ".jpeg", "image/jpeg" }, 
     { ".jpg", "image/jpeg" }, 
     { ".png", "image/png" }, 
     { ".pnz", "image/png" } 
    }; 

    public static bool IsImage(this string file) 
    { 
     if (string.IsNullOrEmpty(file)) 
     { 
      throw new ArgumentNullException(nameof(file)); 
     } 

     var extension = Path.GetExtension(file); 
     return ImageMimeDictionary.ContainsKey(extension.ToLower()); 
    } 
}