Ustal, czy przesłany plik jest obraz (dowolny format) na MVC

Question

więc używam tego kodu do widoku:

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

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

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

To dla modelu

[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"); 
} 

Działa świetnie, chyba że użytkownik dodać plik, który nie jest obrazem. Jak mogę zapewnić, że przesłany plik jest obrazem. Dzięki

Answer 1

W przypadku może on pomaga każdemu, tutaj jest statyczna metoda HttpPostedFileBase, który sprawdza, czy dany plik jest przesłany obraz:

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; 
    } 
} 

Edycja 10.02.2017: Według sugerowanej edycji, dodany Ostateczne polecenie resetowania strumienia, abyśmy mogli go później użyć.

Answer 2

Nie masz kompilatora pod ręką, ale coś takiego powinien zrobić:

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

Answer 3

W pierwszym kroku należy utworzyć białą listę wokół dopuszczalnych typów MIME przeciwko własności ContentType.

Answer 4

Zastosowanie w statycznej klasy pomocnika:

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

Zastosowanie w 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; 
        } 
       } 
     } 
    } 

Ten przykład sprawdza, czy obraz jest prawdziwy obraz, można modyfikować i przekonwertuj to.

Zjada pamięć jako przykład sześciocylindrowego V8, więc powinno się go używać, gdy naprawdę chcemy się dowiedzieć, jaki to obraz.

Answer 5

na stronie serwera porównać typu zawartości, jeśli jego dopasowanie z wymaganym formacie przesłanym następnie postępować albo zwrócić komunikat o błędzie

Answer 6

Dla każdego, który biegnie do tego.

Można również użyć parametru file.ContentType.Contains("image"), aby sprawdzić, czy typem treści jest obraz/*.

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

Nie jestem pewien, czy to najlepsza praktyka, ale działa dla mnie.

Answer 7

Wdrożenie w znacznie bardziej czystszego sposób

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()); 
    } 
}