Importer une Feuille Excel et de Valider les Données Importées avec un couplage Lâche

J'ai fait la même chose sur un projet. La différence est que je n'ai pas d'importer des feuilles de calcul Excel, mais les fichiers CSV. J'ai créé un CSVValueProvider. Et, par conséquent, les données au format CSV, était lié à mon IEnumerable modèle automatiquement.

Comme pour la validation, j'ai pensé que le fait d'aller à travers toutes les lignes et les cellules, et de valider un par un n'est pas très efficace, surtout lorsque le fichier CSV a des milliers de dossiers. Donc, ce que j'ai fait est que j'ai créé certaines méthodes de validation qui est allé à travers les données au format CSV, colonne par colonne, au lieu de, ligne par ligne, et a fait une requête linq sur chaque colonne et retourné les numéros de ligne des cellules avec des données non valides. Puis, il a ajouté l'invalide numéro de ligne/colonne des noms de ModelState.

Mise à JOUR:

Voici ce que j'ai fait...

CSVReader Classe:

//A class that can read and parse the data in a CSV file.
public class CSVReader
{
//Regex expression that's used to parse the data in a line of a CSV file
private const string ESCAPE_SPLIT_REGEX = "({1}[^{1}]*{1})*(?<Separator>{0})({1}[^{1}]*{1})*";
//String array to hold the headers (column names)
private string[] _headers;
//List of string arrays to hold the data in the CSV file. Each string array in the list represents one line (row).
private List<string[]> _rows;
//The StreamReader class that's used to read the CSV file.
private StreamReader _reader;
public CSVReader(StreamReader reader)
{
_reader = reader;
Parse();
}
//Reads and parses the data from the CSV file
private void Parse()
{
_rows = new List<string[]>();
string[] row;
int rowNumber = 1;
var headerLine = "RowNumber," + _reader.ReadLine();
_headers = GetEscapedSVs(headerLine);
rowNumber++;
while (!_reader.EndOfStream)
{
var line = rowNumber + "," + _reader.ReadLine();
row = GetEscapedSVs(line);
_rows.Add(row);
rowNumber++;
}
_reader.Close();
}
private string[] GetEscapedSVs(string data)
{
if (!data.EndsWith(","))
data = data + ",";
return GetEscapedSVs(data, ",", "\"");
}
//Parses each row by using the given separator and escape characters
private string[] GetEscapedSVs(string data, string separator, string escape)
{
string[] result = null;
int priorMatchIndex = 0;
MatchCollection matches = Regex.Matches(data, string.Format(ESCAPE_SPLIT_REGEX, separator, escape));
//Skip empty rows...
if (matches.Count > 0) 
{
result = new string[matches.Count];
for (int index = 0; index <= result.Length - 2; index++)
{
result[index] = data.Substring(priorMatchIndex, matches[index].Groups["Separator"].Index - priorMatchIndex);
priorMatchIndex = matches[index].Groups["Separator"].Index + separator.Length;
}
result[result.Length - 1] = data.Substring(priorMatchIndex, data.Length - priorMatchIndex - 1);
for (int index = 0; index <= result.Length - 1; index++)
{
if (Regex.IsMatch(result[index], string.Format("^{0}.*[^{0}]{0}$", escape))) 
result[index] = result[index].Substring(1, result[index].Length - 2);
result[index] = result[index].Replace(escape + escape, escape);
if (result[index] == null || result[index] == escape) 
result[index] = "";
}
}
return result;
}
//Returns the number of rows
public int RowCount
{
get
{
if (_rows == null)
return 0;
return _rows.Count;
}
}
//Returns the number of headers (columns)
public int HeaderCount
{
get
{
if (_headers == null)
return 0;
return _headers.Length;
}
}
//Returns the value in a given column name and row index
public object GetValue(string columnName, int rowIndex)
{
if (rowIndex >= _rows.Count)
{
return null;
}
var row = _rows[rowIndex];
int colIndex = GetColumnIndex(columnName);
if (colIndex == -1 || colIndex >= row.Length)
{
return null;
}
var value = row[colIndex];
return value;
}
//Returns the column index of the provided column name
public int GetColumnIndex(string columnName)
{
int index = -1;
for (int i = 0; i < _headers.Length; i++)
{
if (_headers[i].Replace(" ","").Equals(columnName, StringComparison.CurrentCultureIgnoreCase))
{
index = i;
return index;
}
}
return index;
}
}

CSVValueProviderFactory Classe:

public class CSVValueProviderFactory : ValueProviderFactory
{
public override IValueProvider GetValueProvider(ControllerContext controllerContext)
{
var uploadedFiles = controllerContext.HttpContext.Request.Files;
if (uploadedFiles.Count > 0)
{
var file = uploadedFiles[0];
var extension = file.FileName.Split('.').Last();
if (extension.Equals("csv", StringComparison.CurrentCultureIgnoreCase))
{
if (file.ContentLength > 0)
{
var stream = file.InputStream;
var csvReader = new CSVReader(new StreamReader(stream, Encoding.Default, true));
return new CSVValueProvider(controllerContext, csvReader);
}
}
}
return null;
}
}

CSVValueProvider Classe:

//Represents a value provider for the data in an uploaded CSV file.
public class CSVValueProvider : IValueProvider
{
private CSVReader _csvReader;
public CSVValueProvider(ControllerContext controllerContext, CSVReader csvReader)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
if (csvReader == null)
{
throw new ArgumentNullException("csvReader");
}
_csvReader = csvReader;
}
public bool ContainsPrefix(string prefix)
{
if (prefix.Contains('[') && prefix.Contains(']'))
{
if (prefix.Contains('.'))
{
var header = prefix.Split('.').Last();
if (_csvReader.GetColumnIndex(header) == -1)
{
return false;
}
}
int index = int.Parse(prefix.Split('[').Last().Split(']').First());
if (index >= _csvReader.RowCount)
{
return false;
}
}
return true;
}
public ValueProviderResult GetValue(string key)
{
if (!key.Contains('[') || !key.Contains(']') || !key.Contains('.'))
{
return null;
}
object value = null;
var header = key.Split('.').Last();
int index = int.Parse(key.Split('[').Last().Split(']').First());
value = _csvReader.GetValue(header, index);
if (value == null)
{
return null;
}
return new ValueProviderResult(value, value.ToString(), CultureInfo.CurrentCulture);
}
}

Pour la validation, comme je l'ai mentionné avant, j'ai pensé qu'il ne serait pas efficace de le faire en utilisant DataAnnotation attributs. Ligne par ligne de la validation des données peut prendre beaucoup de temps pour les fichiers CSV avec des milliers de lignes. Alors, j'ai décidé de valider les données dans le Contrôleur d'après le Modèle de Liaison est fait. Je devrais aussi mentionner que j'avais besoin de valider les données dans le fichier CSV à l'encontre de certaines données dans la base de données. Si vous avez juste besoin de valider des choses comme l'Adresse Email ou Numéro de Téléphone, vous pourriez tout aussi bien utiliser DataAnnotation.

Voici un exemple de méthode pour la validation de l'Adresse e-Mail colonne:

private void ValidateEmailAddress(IEnumerable<CSVViewModel> csvData)
{
var invalidRows = csvData.Where(d => ValidEmail(d.EmailAddress) == false).ToList();
foreach (var invalidRow in invalidRows)
{
var key = string.Format("csvData[{0}].{1}", invalidRow.RowNumber - 2, "EmailAddress");
ModelState.AddModelError(key, "Invalid Email Address"); 
}        
}
private static bool ValidEmail(string email)
{
if(email == "")
return false;
else
return new System.Text.RegularExpressions.Regex(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,6}$").IsMatch(email);
}

Mise à JOUR 2:

Pour validation à l'aide de DataAnnotaion, il vous suffit d'utiliser DataAnnotation attributs dans votre CSVViewModel comme ci-dessous (les CSVViewModel est la classe que vos données CSV sera lié à votre Contrôleur de l'Action):

public class CSVViewModel
{
//User proper names for your CSV columns, these are just examples...   
[Required]
public int Column1 { get; set; } 
[Required]
[StringLength(30)]
public string Column2 { get; set; }
}